> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenClaw

> Dirija OpenClaw a FlexInference a través de su incorporación de proveedor personalizado o su archivo de configuración.

OpenClaw accede a cualquier endpoint compatible con OpenAI a través de un proveedor personalizado. La incorporación crea la entrada por usted, y el archivo de configuración la almacena posteriormente.

OpenClaw no tiene un campo de plazo por solicitud propio, por lo que el plazo se establece en la clave. Cree una primero (consulte [claves de agente](/es/agent-keys)).

## Configúrelo con un agente

Abra el bloque siguiente y cópielo en cualquier agente de codificación. El prompt nunca le pedirá su clave de API: el agente configura todo lo demás y luego imprime la línea de exportación para que la ejecute usted mismo.

<Accordion title="Copiar prompt de configuración del agente">
  ```text theme={null}
  Configure OpenClaw to send its requests to FlexInference through a custom provider. Use the OpenClaw CLI, not hand-edited JSON, so every write is schema-validated.

  You will never see or handle my API key. OpenClaw will read it from the `FLEXINFERENCE_API_KEY` environment variable through a secret reference, and I export that myself. Do not ask me for the key, do not pass it on any command line, and do not read it from my environment.

  Ask whether to use my default OpenClaw profile or a separate one. A separate profile isolates config, state, gateway port, and workspace, and is the safe way to try this. Prefix every command with `--profile flex` if I choose one.

  1. Confirm which config file is active with `openclaw config file`.

  2. Tell me to export the key first, and stop until I confirm. Print this line; do not run it and do not ask for the value:

  export FLEXINFERENCE_API_KEY=<paste your key here>

  3. Write the provider entry. It carries no credential. The model row is required, because OpenClaw refuses a third-party provider that declares no `models`; step 5 replaces it with the full catalog:

  openclaw config set models.providers.flexinference --merge --strict-json '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'

  4. Declare an environment secrets provider, then point the provider's apiKey at it. Both commands pass only the VARIABLE NAME, never the value:

  openclaw config set secrets.providers.default \
    --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY

  openclaw config set models.providers.flexinference.apiKey \
    --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY

  5. Fill the model list from the live FlexInference catalog rather than by hand:

  curl -s https://api.flexinference.com/v1/models \
    -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
  | jq '{models:{providers:{flexinference:{models:
      [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
  | openclaw config patch --stdin

  Run every write with `--dry-run` first and show me the diff before applying it.

  6. Verify with `openclaw models list --provider flexinference`, then run `openclaw security audit`.

  Rules that matter, do not deviate:
  - Never pass my key as an argument to an `openclaw` command, and never write it into a config file. `openclaw onboard --custom-api-key` does both, which is why step 4 uses a reference instead.
  - Step 5 is the one place the key expands, into curl's `-H` argument, where a same-user process can read it. That is a deliberate trade for a single catalog read. Do not extend it to any other command.
  - The provider id must be `flexinference` in every command. If an earlier setup derived `custom-api-flexinference-com` from the host, tell me, and use that id consistently instead of creating a second provider.
  - `api` must be `openai-completions`. That is the only adapter FlexInference's Chat Completions surface works with here.
  - The base URL must end in `/v1`.
  - You MUST list models explicitly. OpenClaw only lets its own built-in provider ids omit `models`, and it will never call `GET /v1/models` for a provider defined in config. Model discovery is a plugin capability and does not apply here.
  - Every model row needs `compat: { supportsUsageInStreaming: true }`. OpenClaw makes streaming usage opt-in for third-party endpoints, and without it every streamed turn reports zero tokens and no cost.
  - Leave `"mode": "merge"` alone so my existing providers survive.
  - Step 4 resolves the reference at write time, so it fails if I have not exported the variable yet. That failure is expected, not a reason to fall back to a literal key.
  - FlexInference's catalog publishes no context window or token ceiling, so generated rows carry neither. Do not invent values; leave them out unless I give you numbers.

  Report what you changed and which config file you wrote.
  ```
</Accordion>

## Incorporar un proveedor personalizado

1. Inicie la configuración guiada.

   ```bash theme={null}
   openclaw onboard
   ```

2. Elija la opción de proveedor personalizado cuando pregunte sobre la autenticación. Esa es `custom-api-key`.

3. Ingrese el router como la URL base, incluyendo el sufijo `/v1`.

   ```text theme={null}
   https://api.flexinference.com/v1
   ```

4. Pegue su clave de agente.

5. Deje el modo de compatibilidad en `openai`. Esa es nuestra superficie de Chat Completions.

6. Ingrese un ID de modelo que ejecutemos, como `gpt-5.6-sol`.

El prompt nunca coloca su clave en una línea de comandos, por lo que este es el camino que se muestra aquí.

`openclaw onboard --non-interactive` también existe, pero su modo de autenticación `custom-api-key` lee la credencial de `--custom-api-key`, por lo que el secreto termina en el historial de su shell y en los argumentos del proceso. En su lugar, automatice la configuración con comandos de configuración y una referencia secreta, lo que produce el mismo resultado sin la exposición.

Cualquiera que sea la ruta que tome, configure el ID del proveedor usted mismo:

```bash theme={null}
openclaw config set models.providers.flexinference --merge --strict-json \
  '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'
```

Si se deja solo, OpenClaw deriva el ID del host y termina con `custom-api-flexinference-com`, y cada comando posterior en esta página necesitaría ese nombre en su lugar.

La escritura incluye una fila de modelo porque es necesario. OpenClaw rechaza un proveedor de terceros que no declara `models`, por lo que una escritura solo con `baseUrl` falla la validación del esquema. Reemplace toda la fila en la siguiente sección.

El modo de compatibilidad se asigna a `api`. `openai` escribe `openai-completions`, que es con el que funciona nuestro endpoint de Chat Completions. Las otras opciones son `openai-responses` y `anthropic`.

## El archivo de configuración

La incorporación escribe en `~/.openclaw/openclaw.json` bajo `models.providers`. Imprima la ruta que OpenClaw está utilizando con `openclaw config file`.

```json theme={null}
{
  "models": {
    "mode": "merge",
    "providers": {
      "flexinference": {
        "baseUrl": "https://api.flexinference.com/v1",
        "api": "openai-completions",
        "apiKey": {
          "source": "env",
          "provider": "default",
          "id": "FLEXINFERENCE_API_KEY"
        },
        "models": [
          {
            "id": "gpt-5.6-sol",
            "name": "GPT-5.6 Sol",
            "contextWindow": 400000,
            "maxTokens": 128000,
            "input": ["text", "image"],
            "compat": { "supportsUsageInStreaming": true }
          }
        ]
      }
    }
  }
}
```

`"mode": "merge"` mantiene sus proveedores integrados y añade este junto a ellos.

`api` debe ser `openai-completions`. El modo de compatibilidad `openai` de la incorporación escribe exactamente eso.

`apiKey` también acepta una cadena de texto simple, que es lo que escribe la incorporación. La referencia que se muestra aquí mantiene el secreto fuera del archivo. Consulte mantener la clave fuera del archivo de configuración.

**Liste sus modelos usted mismo.** Solo los ID de proveedor integrados de OpenClaw pueden omitir `models`. Un ID de tercero debe declarar tanto `baseUrl` como `models`, así que añada una fila por cada modelo que desee en el selector.

**Configure `compat.supportsUsageInStreaming`.** OpenClaw hace que el uso de streaming sea opcional para un endpoint de terceros, porque algunos servidores lo rechazan. Sin esta bandera, nunca recibimos la solicitud de un marco de uso, por lo que cada turno transmitido reporta cero tokens y ningún costo.

## Rellenar la lista de modelos desde nuestro catálogo

OpenClaw no llamará a `GET /v1/models` para un proveedor que usted defina en la configuración. El descubrimiento de modelos es una capacidad de plugin, y los plugins incluidos que la tienen son los únicos que la utilizan. Un proveedor definido en la configuración lee su array `models` y nada más.

Genere ese array desde nuestro catálogo en su lugar, y escríbalo en un solo comando.

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>

curl -s https://api.flexinference.com/v1/models \
  -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
| jq '{models:{providers:{flexinference:{models:
    [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
| openclaw config patch --stdin
```

`config patch` fusiona objetos y reemplaza arrays, por lo que esto intercambia la lista de modelos y deja `baseUrl` y `apiKey` intactos. Añada `--dry-run` para ver la escritura primero.

Conserve solo los modelos que compiten en el nivel más económico filtrando por la propia bandera del catálogo.

```bash theme={null}
jq '[.data[] | select(.flexinference.flex_race) | {id, name: .id}]'
```

Nuestro catálogo no publica ventana de contexto ni límite de tokens, por lo que las filas creadas de esta manera no tienen ninguno. Añada `contextWindow` y `maxTokens` usted mismo donde los valores predeterminados de OpenClaw no se ajusten al modelo.

Vuelva a ejecutar el comando cada vez que nuestro catálogo cambie. Verifique el resultado:

```bash theme={null}
openclaw models list --provider flexinference
```

## Configuración global y perfiles

OpenClaw mantiene una configuración por perfil, no una por carpeta. El directorio de trabajo nunca cambia el archivo que lee.

| Ámbito         | Ruta de configuración       | Cómo seleccionarlo     |
| -------------- | --------------------------- | ---------------------- |
| Predeterminado | `~/.openclaw/openclaw.json` | el predeterminado      |
| Con nombre     | `~/.openclaw-<name>/`       | `--profile <name>`     |
| Desarrollo     | `~/.openclaw-dev/`          | `--dev`                |
| Explícito      | cualquier ruta              | `OPENCLAW_CONFIG_PATH` |

Utilice un perfil con nombre para probar FlexInference sin afectar su configuración habitual.

```bash theme={null}
openclaw --profile flex onboard
```

Un perfil aísla el estado y la configuración, por lo que su puerto de gateway y su espacio de trabajo también son independientes.

## Mantener la clave fuera del archivo de configuración

La incorporación escribe la clave en `openclaw.json` en texto plano. En su lugar, configure `apiKey` como una referencia secreta, y la configuración almacenará el nombre de la variable en lugar de su valor.

1. Exporte la clave en el shell desde el que ejecutará estos comandos.

   ```bash theme={null}
   export FLEXINFERENCE_API_KEY=<your agent key>
   ```

2. Declare un proveedor de secretos de entorno y permita esa única variable.

   ```bash theme={null}
   openclaw config set secrets.providers.default \
     --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY
   ```

3. Apunte el `apiKey` del proveedor a ella.

   ```bash theme={null}
   openclaw config set models.providers.flexinference.apiKey \
     --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY
   ```

La configuración entonces contendrá `{"source": "env", "provider": "default", "id": "FLEXINFERENCE_API_KEY"}` y ningún secreto. La clave tampoco llega a la línea de comandos, porque el paso 3 solo pasa el nombre de la variable.

OpenClaw resuelve la referencia cuando ejecuta el paso 3, así que exporte la variable primero. Una variable faltante o vacía hará que la escritura falle con `SecretRefResolutionError` en lugar de almacenar algo incorrecto. Añada `--dry-run` para verificar sin escribir.

Verifique lo que está expuesto con la auditoría integrada.

```bash theme={null}
openclaw security audit
```

## Confirmar que la clave se aplicó

Cada respuesta viene con `x-flexinference-defaults-applied`. OpenClaw no muestra los encabezados de respuesta, así que lea la solicitud en el dashboard bajo **Logs** en su lugar.

## Solución de problemas

**El selector de modelos es corto, o falta un modelo.** Un proveedor definido en la configuración nunca llama a `GET /v1/models`, por lo que solo muestra las filas que usted escribió. Regenere la lista desde nuestro catálogo.

**Los turnos reportan cero tokens y ningún costo.** OpenClaw no nos solicitó el uso de streaming, por lo que no enviamos ningún marco de uso. Configure `compat.supportsUsageInStreaming` en `true` en cada fila de modelo.

**Se rechaza un ID de modelo.** Las filas que escribió manualmente pueden diferir de lo que ejecutamos, ya que el `id` se envía exactamente como está escrito. Regenere la lista desde nuestro catálogo en lugar de editar los ID.

**Los cambios de configuración no surten efecto.** El gateway mantiene la configuración antigua. Reinícielo y confirme que editó el archivo que imprime `openclaw config file`.

Consulte [errores](/es/errors) para cada rechazo que devolvemos, y [claves de agente](/es/agent-keys) para aquellos que no son específicos de OpenClaw.