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

# OpenCode

> Aponte o OpenCode para o FlexInference apenas com configuração.

O OpenCode lê uma entrada de provedor de um arquivo JSON, sem alteração de código-fonte e sem fork.

O OpenCode pode definir `start_within` na configuração, então uma chave de agente é opcional aqui. A chave ainda é o caminho mais simples, porque ela muda sem um reinício. Veja [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 chave de API: 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 OpenCode to send its requests to FlexInference. This is config only: no source change, no fork, no patch.

  You will never see or handle my API key. The provider entry stores only the `{env:FLEXINFERENCE_API_KEY}` template, and I export the value myself. Do not ask me for the key, and do not read it from my environment.

  Ask me whether this should apply to every project or one project, then write the provider entry to the matching file. Global is `~/.config/opencode/opencode.json`. Per project is `opencode.json` in the project root. Project config wins over global. Create the file if it does not exist, and merge into it rather than overwriting anything already there.

  The entry:

  {
    "$schema": "https://opencode.ai/config.json",
    "model": "flexinference/gpt-5.6-sol",
    "provider": {
      "flexinference": {
        "name": "FlexInference",
        "env": ["FLEXINFERENCE_API_KEY"],
        "npm": "@ai-sdk/openai-compatible",
        "options": {
          "apiKey": "{env:FLEXINFERENCE_API_KEY}",
          "baseURL": "https://api.flexinference.com/v1"
        },
        "models": {
          "gpt-5.6-sol": {
            "name": "GPT-5.6 Sol",
            "reasoning": true,
            "tool_call": true,
            "limit": { "context": 400000, "output": 128000 }
          }
        }
      }
    }
  }

  Then print this line for me to run in the shell I start OpenCode from. Do not run it and do not ask for the value:

      export FLEXINFERENCE_API_KEY=<paste your key here>

  Rules that matter, do not deviate:
  - Keep `options.apiKey` as the literal `{env:FLEXINFERENCE_API_KEY}` template. Never inline my key.
  - The top-level `model` field is what selects the provider. Without it OpenCode stays on its built-in default and never reaches FlexInference.
  - `options.baseURL` must end in `/v1`.
  - Every key under `models` is a slug sent verbatim on the wire, so it must be one FlexInference serves. `gpt-5.6-sol` is a safe default.
  - Do not put `seed`, `stop`, `presence_penalty`, `frequency_penalty`, `logit_bias`, `logprobs`, `top_logprobs`, `prediction`, `audio`, `modalities`, or `web_search_options` in any model's `options`. FlexInference refuses those Chat Completions parameters, and they also conflict with a key that carries a flex duration.
  - Do not add `start_within` unless I ask. My agent key already carries the deadline, and a key duration falls back safely on models that cannot race while a config duration errors.
  - If I mention working in repositories I do not control, tell me to set `OPENCODE_DISABLE_PROJECT_CONFIG`. A project config wins over the global one and can repoint `baseURL` while still reading my exported key. `OPENCODE_CONFIG` does not prevent that, because project config loads after it.

  Verify the file is valid JSON, then report what you changed and which file you wrote.
  ```
</Accordion>

## Configurar o OpenCode

1. Exporte a chave no shell que inicia o OpenCode.

```bash theme={null}
export FLEXINFERENCE_API_KEY=flex_live_...
```

2. Escreva a entrada do provedor em `opencode.json`.

```json theme={null}
{
  "$schema": "https://opencode.ai/config.json",
  "model": "flexinference/gpt-5.6-sol",
  "provider": {
    "flexinference": {
      "name": "FlexInference",
      "env": ["FLEXINFERENCE_API_KEY"],
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "apiKey": "{env:FLEXINFERENCE_API_KEY}",
        "baseURL": "https://api.flexinference.com/v1"
      },
      "models": {
        "gpt-5.6-sol": {
          "name": "GPT-5.6 Sol",
          "reasoning": true,
          "tool_call": true,
          "limit": { "context": 400000, "output": 128000 }
        }
      }
    }
  }
}
```

3. Inicie o OpenCode usando esse arquivo.

```bash theme={null}
OPENCODE_CONFIG=/path/to/opencode.json opencode
```

Quatro campos contêm a integração. `npm` seleciona o pacote compatível com OpenAI. `options.baseURL` envia as requisições para o roteador. `options.apiKey` lê a chave do ambiente. Cada chave em `models` é um slug que executamos.

Adicione um modelo adicionando uma chave em `models`. Todo o resto na entrada é exibição e limites.

## Global ou por projeto

Coloque a entrada do provedor em um de dois lugares, dependendo de quão amplamente você deseja que ela se aplique.

| Escopo       | Caminho                                 | Aplica-se a                         |
| ------------ | --------------------------------------- | ----------------------------------- |
| Global       | `~/.config/opencode/opencode.json`      | todo projeto nesta máquina          |
| Por projeto  | `opencode.json` na raiz do projeto      | apenas aquele projeto               |
| Uma execução | qualquer caminho, via `OPENCODE_CONFIG` | a execução para a qual você o passa |

**A configuração do projeto prevalece sobre a global.** O OpenCode procura por `opencode.json` no diretório de trabalho e sobe até o diretório Git mais próximo, então um repositório pode substituir seu provedor em toda a máquina sem tocá-lo.

Coloque a entrada do provedor no arquivo global e o prazo permanece o mesmo em todos os lugares. Coloque-o em um arquivo de projeto e apenas aquele repositório roteia através de nós.

Defina `OPENCODE_DISABLE_PROJECT_CONFIG` para interromper a busca ascendente.

Existem mais duas fontes para bundles e automação. `OPENCODE_CONFIG_DIR` nomeia um diretório de onde o OpenCode lê a configuração, e `OPENCODE_CONFIG_CONTENT` contém o JSON inline. Use `OPENCODE_CONFIG` para um arquivo que você opta por usar por execução.

```bash theme={null}
OPENCODE_CONFIG=/path/to/opencode.json opencode
```

## Defina o prazo na configuração em vez disso

O OpenCode pode enviar `start_within` por si mesmo. Ambos os lugares são JSON simples, e ambos superam a chave.

Defina-o por modelo. O bloco `options` vai para o corpo da requisição para aquele modelo.

```json theme={null}
"gpt-5.6-sol": {
  "name": "GPT-5.6 Sol",
  "options": { "start_within": "00h-00m-30s", "reasoningEffort": "medium" }
}
```

Defina-o por variante, para alternar sem mudar o modelo. Escolha um com `--variant` em `opencode run`, ou alterne-os na TUI com `ctrl+t`.

```json theme={null}
"gpt-5.6-sol": {
  "name": "GPT-5.6 Sol",
  "variants": {
    "patient": { "start_within": "00h-05m-00s", "reasoningEffort": "high" },
    "now": { "start_within": "priority", "reasoningEffort": "low" }
  }
}
```

Uma duração aqui falha em um modelo que não pode competir. A mesma duração na chave retorna a um padrão. Essa é a razão para preferir a chave.

## Confirme que a chave foi aplicada

Toda resposta vem com `x-flexinference-defaults-applied`. O OpenCode não mostra os cabeçalhos de resposta na TUI, então leia a requisição no painel em **Logs** em vez disso.

## Solução de problemas

**As requisições nunca nos alcançam.** O campo `model` de nível superior é o que seleciona o provedor, então definir um provedor sem nomeá-lo lá deixa o OpenCode em seu padrão embutido. Defina `"model": "flexinference/<slug>"`.

**[`401 invalid_api_key`](/pt/errors#invalid_api_key).** `FLEXINFERENCE_API_KEY` não está definido no shell que iniciou o OpenCode. Exporte-o antes de iniciar, já que `options.apiKey` o lê do ambiente.

**[`400 unsupported_parameter`](/pt/errors#unsupported_parameter).** Um parâmetro de Chat Completions que não traduzimos estava nas `options` de um modelo, como `seed` ou `stop`. Remova-o da entrada.

**[`400 key_default_not_applicable`](/pt/errors#key_default_not_applicable).** Sua chave contém uma duração e um desses parâmetros veio junto. Edite a chave para um nível ou remova o parâmetro.

**[`400 flex_unsupported_for_anthropic`](/pt/errors#flex_unsupported_for_anthropic).** Uma duração em `options` alcançou um modelo `claude-*` em sua própria chave Anthropic. A [corrida](/pt/deadline-routing) que uma duração Claude executa requer chaves gerenciadas. Remova a duração e deixe a chave manter o prazo, já que uma duração de chave retorna a um padrão.

**Uma edição de configuração não mudou nada.** Uma fonte de configuração posterior a substituiu. Verifique a ordem de busca acima e prefira `OPENCODE_CONFIG` para optar por um arquivo por execução.

Veja [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 OpenCode. [OpenWork](/pt/openwork) e [OpenScience](/pt/openscience) leem a mesma entrada de provedor.