> ## 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

> Aponte o OpenClaw para o FlexInference através de sua integração de provedor personalizado ou de seu arquivo de configuração.

O OpenClaw acessa qualquer endpoint compatível com OpenAI através de um provedor personalizado. A integração cria a entrada para você, e o arquivo de configuração a mantém posteriormente.

O OpenClaw não possui um campo de prazo por solicitação próprio, então o prazo é definido na key. Crie uma primeiro (consulte [chaves de agente](/pt/agent-keys)).

## Configure isso com um agente

Abra o bloco abaixo e copie-o para qualquer agente de codificação. O prompt nunca pede sua API key: o agente configura todo o resto e, em seguida, imprime a linha de exportação para você executar.

<Accordion title="Copiar prompt de configuração do 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>

## Integrar um provedor personalizado

1. Inicie a configuração guiada.

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

2. Escolha a opção de provedor personalizado quando perguntar sobre autenticação. Essa é `custom-api-key`.

3. Insira o roteador como a URL base, incluindo o sufixo `/v1`.

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

4. Cole sua agent key.

5. Mantenha o modo de compatibilidade em `openai`. Essa é a nossa interface de Chat Completions.

6. Insira um model id que executamos, como `gpt-5.6-sol`.

O prompt nunca coloca sua key em uma linha de comando, por isso é o caminho mostrado aqui.

`openclaw onboard --non-interactive` também existe, mas seu modo de autenticação `custom-api-key` lê a credencial de `--custom-api-key`, então o segredo acaba no histórico do seu shell e nos argumentos do processo. Em vez disso, automatize a configuração com comandos de configuração e uma referência secreta, o que resulta no mesmo sem a exposição.

Qualquer que seja o caminho que você escolha, defina o provider id você mesmo:

```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}}]}'
```

Deixado por conta própria, o OpenClaw deriva o id do host e acaba com `custom-api-flexinference-com`, e cada comando posterior nesta página precisaria desse nome em vez disso.

A gravação inclui uma linha de model porque é obrigatório. O OpenClaw recusa um provedor de terceiros que não declara `models`, então uma gravação apenas com `baseUrl` falha na validação do esquema. Substitua a linha inteira na próxima seção.

O modo de compatibilidade mapeia para `api`. `openai` escreve `openai-completions`, que é o que nosso endpoint de Chat Completions funciona. As outras opções são `openai-responses` e `anthropic`.

## O arquivo de configuração

A integração grava em `~/.openclaw/openclaw.json` sob `models.providers`. Imprima o caminho que o OpenClaw está usando com `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"` mantém seus provedores integrados e adiciona este ao lado deles.

`api` deve ser `openai-completions`. O modo de compatibilidade `openai` da integração escreve exatamente isso.

`apiKey` também aceita uma string simples, que é o que a integração escreve. A referência mostrada aqui mantém o segredo fora do arquivo. Consulte manter a key fora do arquivo de configuração.

**Liste seus models você mesmo.** Apenas os provider ids integrados do OpenClaw podem omitir `models`. Um id de terceiros deve declarar `baseUrl` e `models`, então adicione uma linha por model que você deseja no seletor.

**Defina `compat.supportsUsageInStreaming`.** O OpenClaw torna o uso de streaming opcional para um endpoint de terceiros, porque alguns servidores o recusam. Sem essa flag, nunca recebemos a solicitação de um frame de uso, então cada turno transmitido relata zero tokens e nenhum custo.

## Preencher a lista de models do nosso catálogo

O OpenClaw não chamará `GET /v1/models` para um provedor que você define na configuração. A descoberta de models é uma capacidade de plugin, e os plugins empacotados que a possuem são os únicos que a utilizam. Um provedor definido na configuração lê seu array `models` e nada mais.

Em vez disso, gere esse array a partir do nosso catálogo e escreva-o em um único 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` mescla objetos e substitui arrays, então isso troca a lista de models e deixa `baseUrl` e `apiKey` intocados. Adicione `--dry-run` para ver a gravação primeiro.

Mantenha apenas os models que competem na camada mais barata, filtrando pela própria flag do catálogo.

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

Nosso catálogo não publica janela de contexto nem limite de tokens, então as linhas criadas dessa forma não possuem nenhum dos dois. Adicione `contextWindow` e `maxTokens` você mesmo onde os padrões do OpenClaw não se encaixam no model.

Execute o comando novamente sempre que nosso catálogo mudar. Verifique o resultado:

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

## Configuração global e perfis

O OpenClaw mantém uma configuração por perfil, não uma por pasta. O diretório de trabalho nunca altera qual arquivo ele lê.

| Escopo          | Caminho da configuração     | Como selecioná-lo      |
| --------------- | --------------------------- | ---------------------- |
| Padrão          | `~/.openclaw/openclaw.json` | o padrão               |
| Nomeado         | `~/.openclaw-<name>/`       | `--profile <name>`     |
| Desenvolvimento | `~/.openclaw-dev/`          | `--dev`                |
| Explícito       | qualquer caminho            | `OPENCLAW_CONFIG_PATH` |

Use um perfil nomeado para experimentar o FlexInference sem alterar sua configuração usual.

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

Um perfil isola o estado, bem como a configuração, então sua porta de gateway e workspace também são separados.

## Mantenha a key fora do arquivo de configuração

A integração grava a key em `openclaw.json` em texto simples. Em vez disso, defina `apiKey` como uma referência secreta, e a configuração armazena o nome da variável em vez de seu valor.

1. Exporte a key no shell de onde você executará esses comandos.

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

2. Declare um provedor de segredos de ambiente e permita essa variável.

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

3. Aponte o `apiKey` do provedor para ele.

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

A configuração então contém `{"source": "env", "provider": "default", "id": "FLEXINFERENCE_API_KEY"}` e nenhum segredo. A key nunca chega a uma linha de comando, porque o passo 3 passa apenas o nome da variável.

O OpenClaw resolve a referência quando você executa o passo 3, então exporte a variável primeiro. Uma variável ausente ou vazia falha na gravação com `SecretRefResolutionError` em vez de armazenar algo quebrado. Adicione `--dry-run` para verificar sem gravar.

Verifique o que está exposto com a auditoria integrada.

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

## Confirmar a key aplicada

Cada resposta vem com `x-flexinference-defaults-applied`. O OpenClaw não mostra os cabeçalhos de resposta, então leia a solicitação no painel em **Logs**.

## Solução de problemas

**O seletor de models está incompleto, ou um model está faltando.** Um provedor definido na configuração nunca chama `GET /v1/models`, então ele mostra apenas as linhas que você escreveu. Regenere a lista a partir do nosso catálogo.

**Os turnos relatam zero tokens e nenhum custo.** O OpenClaw não nos pediu uso de streaming, então não enviamos nenhum frame de uso. Defina `compat.supportsUsageInStreaming` como `true` em cada linha de model.

**Um model id é recusado.** As linhas que você escreveu manualmente podem divergir do que executamos, já que o `id` é enviado exatamente como escrito. Regenere a lista a partir do nosso catálogo em vez de editar ids.

**As edições de configuração não surtem efeito.** O gateway mantém a configuração antiga. Reinicie-o e confirme que você editou o arquivo que `openclaw config file` imprime.

Consulte [erros](/pt/errors) para cada recusa que retornamos, e [chaves de agente](/pt/agent-keys) para aquelas que não são específicas do OpenClaw.