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

> Pointez OpenCode vers FlexInference avec la configuration uniquement.

OpenCode lit une entrée de fournisseur à partir d'un fichier JSON, sans modification du code source et sans fork.

OpenCode peut définir `start_within` dans la configuration, de sorte qu'une clé d'agent est facultative ici. La clé reste le chemin le plus simple, car elle peut être modifiée sans redémarrage. Voir [clés d'agent](/fr/agent-keys).

## Configurer cela avec un agent

Ouvrez le bloc ci-dessous et copiez-le dans n'importe quel agent de codage. L'invite ne vous demandera jamais votre clé API : l'agent configure tout le reste, puis affiche la ligne d'exportation que vous devrez exécuter vous-même.

<Accordion title="Copier l'invite de configuration de l'agent">
  ```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>

## Configurer OpenCode

1. Exportez la clé dans le shell qui démarre OpenCode.

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

2. Écrivez l'entrée du fournisseur dans `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. Démarrez OpenCode avec ce fichier.

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

Quatre champs gèrent l'intégration. `npm` sélectionne le package compatible OpenAI. `options.baseURL` envoie les requêtes au routeur. `options.apiKey` lit la clé depuis l'environnement. Chaque clé sous `models` est un slug que nous exécutons.

Ajoutez un modèle en ajoutant une clé sous `models`. Tout le reste dans l'entrée concerne l'affichage et les limites.

## Global ou par projet

Placez l'entrée du fournisseur à l'un des deux endroits, selon l'étendue que vous souhaitez lui donner.

| Portée        | Chemin                                       | S'applique à                       |
| ------------- | -------------------------------------------- | ---------------------------------- |
| Global        | `~/.config/opencode/opencode.json`           | chaque projet sur cette machine    |
| Par projet    | `opencode.json` à la racine du projet        | ce projet uniquement               |
| Une exécution | n'importe quel chemin, via `OPENCODE_CONFIG` | le lancement auquel vous le passez |

**La configuration du projet l'emporte sur la configuration globale.** OpenCode recherche `opencode.json` dans le répertoire de travail et remonte jusqu'au répertoire Git le plus proche, de sorte qu'un dépôt peut remplacer votre fournisseur à l'échelle de la machine sans le modifier.

Placez l'entrée du fournisseur dans le fichier global et la date limite reste la même partout. Placez-la dans un fichier de projet et seul ce dépôt passera par nous.

Définissez `OPENCODE_DISABLE_PROJECT_CONFIG` pour arrêter la recherche ascendante.

Deux autres sources existent pour les bundles et l'automatisation. `OPENCODE_CONFIG_DIR` nomme un répertoire à partir duquel OpenCode lit la configuration, et `OPENCODE_CONFIG_CONTENT` contient le JSON en ligne. Utilisez `OPENCODE_CONFIG` pour un fichier que vous choisissez d'utiliser par exécution.

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

## Définir la date limite dans la configuration à la place

OpenCode peut envoyer `start_within` lui-même. Les deux emplacements sont du JSON simple, et les deux l'emportent sur la clé.

Définissez-le par modèle. Le bloc `options` est inséré dans le corps de la requête pour ce modèle.

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

Définissez-le par variante à la place, pour changer sans modifier le modèle. Choisissez-en une avec `--variant` sur `opencode run`, ou faites-les défiler dans l'interface utilisateur textuelle (TUI) avec `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" }
  }
}
```

Une durée ici échoue sur un modèle qui ne peut pas faire la course. La même durée sur la clé se replie à la place. C'est la raison de préférer la clé.

## Confirmer que la clé a été appliquée

Chaque réponse est accompagnée de `x-flexinference-defaults-applied`. OpenCode n'affiche pas les en-têtes de réponse dans l'interface utilisateur textuelle (TUI), alors lisez plutôt la requête dans le tableau de bord sous **Logs**.

## Dépannage

**Les requêtes ne nous parviennent jamais.** Le champ `model` de niveau supérieur est ce qui sélectionne le fournisseur, donc définir un fournisseur sans le nommer là laisse OpenCode sur son défaut intégré. Définissez `"model": "flexinference/<slug>"`.

**[`401 invalid_api_key`](/fr/errors#invalid_api_key).** `FLEXINFERENCE_API_KEY` n'est pas défini dans le shell qui a démarré OpenCode. Exportez-le avant le lancement, car `options.apiKey` le lit depuis l'environnement.

**[`400 unsupported_parameter`](/fr/errors#unsupported_parameter).** Un paramètre Chat Completions que nous ne traduisons pas était dans les `options` d'un modèle, tel que `seed` ou `stop`. Supprimez-le de l'entrée.

**[`400 key_default_not_applicable`](/fr/errors#key_default_not_applicable).** Votre clé contient une durée et l'un de ces paramètres l'accompagnait. Modifiez la clé pour un niveau, ou supprimez le paramètre.

**[`400 flex_unsupported_for_anthropic`](/fr/errors#flex_unsupported_for_anthropic).** Une durée dans `options` a atteint un modèle `claude-*` sur votre propre clé Anthropic. La [course](/fr/deadline-routing) qu'une durée Claude exécute nécessite des clés gérées. Supprimez la durée et laissez la clé gérer la date limite, car une durée de clé se replie à la place.

**Une modification de la configuration n'a rien changé.** Une source de configuration ultérieure l'a remplacée. Vérifiez l'ordre de recherche ci-dessus, et préférez `OPENCODE_CONFIG` pour choisir un fichier par exécution.

Consultez [errors](/fr/errors) pour chaque refus que nous renvoyons, et [agent keys](/fr/agent-keys) pour ceux qui ne sont pas spécifiques à OpenCode. [OpenWork](/fr/openwork) et [OpenScience](/fr/openscience) lisent la même entrée de fournisseur.