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

# OpenWork

> Aponte o OpenWork para o FlexInference importando um pacote de configuração do OpenCode.

O OpenWork opera um backend OpenCode, então o arquivo que você escreve é um arquivo de configuração OpenCode. O backend lê a entrada do provedor a partir dele.

O OpenWork não oferece um local em sua própria interface para definir `start_within`, então o prazo depende da chave. 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 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 OpenWork to send its requests to FlexInference. OpenWork drives an OpenCode backend, so the file you write is an OpenCode config file that OpenWork imports into its profile.

  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.

  1. Create a directory named `config/` beside my OpenWork checkout and put `opencode.json` in it with this content:

  {
    "$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 }
          }
        }
      }
    }
  }

  2. Find the OpenCode binary OpenWork should drive and note its path.

  3. Give me the launch command, with the binary path filled in:

  OPENWORK_ELECTRON_USERDATA="$PWD/.openwork-flex-userdata" \
  OPENWORK_DATA_DIR="$PWD/.openwork-flex-data" \
  OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR="$PWD/config" \
  OPENWORK_OPENCODE_BIN=<path to the opencode binary> \
    pnpm dev

  4. Print this line for me to run in that same shell. Do not run it and do not ask for the value:

     export FLEXINFERENCE_API_KEY=<paste your key here>

     OpenWork passes its parent environment to the backend, which is how the value reaches the provider entry.

  5. Add `.openwork-flex-userdata/` and `.openwork-flex-data/` to `.gitignore` if this is a Git repository.

  Rules that matter, do not deviate:
  - OpenWork ignores a config file in the working directory. The bundle only reaches the backend through `OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR`.
  - The import only runs when `OPENWORK_DEV_MODE=1`, which `pnpm dev` sets. A production launch skips it entirely.
  - Reuse the same `OPENWORK_ELECTRON_USERDATA` and `OPENWORK_DATA_DIR` paths on every launch, or you start a fresh profile and lose session history. The copy overwrites on each launch but never deletes.
  - 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 the backend stays on its built-in default.

  Report what you created and give me the exact command to run.
  ```
</Accordion>

## Configurar o OpenWork

1. Coloque um `opencode.json` em um diretório próprio. Use a entrada do provedor de [OpenCode](/pt/opencode).
2. Exporte a chave no shell que inicia o OpenWork.

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

3. Inicie o OpenWork com o caminho de importação definido.

```bash theme={null}
OPENWORK_ELECTRON_USERDATA="$PWD/.openwork-flex-userdata" \
OPENWORK_DATA_DIR="$PWD/.openwork-flex-data" \
OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR="$PWD/config" \
OPENWORK_OPENCODE_BIN=/path/to/opencode/binary \
  pnpm dev
```

O OpenWork mantém o backend em um perfil isolado, então ele ignora um arquivo de configuração no seu diretório de trabalho. Ele copia o diretório nomeado para o perfil no lançamento e, em seguida, inicia o backend com `OPENCODE_CONFIG_DIR` definido para essa cópia.

`pnpm dev` define `OPENWORK_DEV_MODE=1`, que é o que ativa a importação.

O OpenWork passa o ambiente pai para o backend, de modo que `FLEXINFERENCE_API_KEY` alcança a entrada do provedor.

## O escopo vem do perfil, não da pasta

O OpenWork não lê a configuração do seu diretório de trabalho, então a divisão global e por projeto que o [OpenCode](/pt/opencode) oferece não se aplica aqui. O escopo vem do perfil contra o qual você inicia.

| Escopo    | O que o define                                     | Aplica-se a              |
| --------- | -------------------------------------------------- | ------------------------ |
| Um perfil | `OPENWORK_ELECTRON_USERDATA` e `OPENWORK_DATA_DIR` | cada sessão nesse perfil |
| O pacote  | `OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR`          | o que o perfil importar  |

Mantenha um par de caminhos de perfil por configuração que você deseja alternar. O mesmo pacote importado para dois perfis oferece duas configurações isoladas, cada uma com seu próprio histórico de sessão.

Reutilize os caminhos acima para manter um perfil. Altere-os para iniciar um novo.

## A importação copia a cada inicialização e nunca exclui

A cópia é executada a cada inicialização e sobrescreve. Edite o pacote, reinicie nos mesmos caminhos `OPENWORK_ELECTRON_USERDATA` e `OPENWORK_DATA_DIR`, e o backend lerá o novo arquivo.

Nunca exclui. Um arquivo que você removeu do pacote permanece na cópia do perfil. Limpar isso requer novos caminhos para ambas as variáveis, o que reinicia o perfil e perde seu histórico de sessão. Faça isso apenas quando um arquivo restante estiver atrapalhando.

## Confirmar a chave aplicada

Cada resposta vem com `x-flexinference-defaults-applied`. Nem o backend nem a interface do OpenWork mostram os cabeçalhos de resposta, então leia a requisição no painel em **Logs**.

## Solução de problemas

**A importação nunca foi executada.** `OPENWORK_DEV_MODE=1` é o que a habilita, e `pnpm dev` a define. Uma inicialização de produção ignora a importação.

**Uma edição de configuração não mudou nada.** A cópia é executada por inicialização, mas apenas no perfil que lhe foi dado. Reinicie nos mesmos caminhos `OPENWORK_ELECTRON_USERDATA` e `OPENWORK_DATA_DIR`.

**Um arquivo que você excluiu ainda está sendo carregado.** A cópia sobrescreve, mas nunca exclui. Inicie um novo perfil com novos caminhos para ambas as variáveis, aceitando a perda do histórico de sessão.

**As requisições nunca nos alcançam.** O campo `model` de nível superior no pacote é o que seleciona o provedor. Sem ele, o backend permanece em seu padrão integrado.

**[`401 invalid_api_key`](/pt/errors#invalid_api_key).** `FLEXINFERENCE_API_KEY` não está definida no shell que iniciou o OpenWork. Exporte-a lá, pois o backend herda o ambiente desse shell.

Consulte [erros](/pt/errors) para cada recusa que retornamos, [chaves de agente](/pt/agent-keys) para aquelas que não são específicas do OpenWork, e [OpenCode](/pt/opencode) para a entrada do provedor e as opções de prazo por modelo.