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

> OpenCode nur über die Konfiguration auf FlexInference verweisen.

OpenCode liest einen Provider-Eintrag aus einer JSON-Datei, ohne Quellcodeänderungen oder Forks.

OpenCode kann `start_within` in der Konfiguration festlegen, sodass ein Agent-Schlüssel hier optional ist. Der Schlüssel ist jedoch weiterhin der einfachere Weg, da er sich ohne Neustart ändern lässt. Siehe [Agent-Schlüssel](/de/agent-keys).

## Einrichtung mit einem Agenten

Öffnen Sie den folgenden Block und kopieren Sie ihn in einen beliebigen Coding-Agenten. Der Prompt fragt niemals nach Ihrem API-Schlüssel: Der Agent konfiguriert alles andere und gibt dann die eine Exportzeile aus, die Sie selbst ausführen können.

<Accordion title="Agent-Setup-Prompt kopieren">
  ```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>

## OpenCode konfigurieren

1. Exportieren Sie den Schlüssel in der Shell, die OpenCode startet.

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

2. Schreiben Sie den Provider-Eintrag in `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. Starten Sie OpenCode mit dieser Datei.

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

Vier Felder steuern die Integration. `npm` wählt das OpenAI-kompatible Paket aus. `options.baseURL` sendet Anfragen an den Router. `options.apiKey` liest den Schlüssel aus der Umgebung. Jeder Schlüssel unter `models` ist ein Slug, den wir ausführen.

Fügen Sie ein Modell hinzu, indem Sie einen Schlüssel unter `models` hinzufügen. Alles andere im Eintrag dient der Anzeige und den Limits.

## Global oder pro Projekt

Platzieren Sie den Provider-Eintrag an einer von zwei Stellen, je nachdem, wie weit Sie ihn anwenden möchten.

| Geltungsbereich | Pfad                                    | Gilt für                            |
| --------------- | --------------------------------------- | ----------------------------------- |
| Global          | `~/.config/opencode/opencode.json`      | jedes Projekt auf diesem Rechner    |
| Pro Projekt     | `opencode.json` im Projekt-Root         | nur dieses Projekt                  |
| Einmaliger Lauf | beliebiger Pfad, über `OPENCODE_CONFIG` | den Start, an den Sie ihn übergeben |

**Projektkonfiguration hat Vorrang vor globaler Konfiguration.** OpenCode sucht im Arbeitsverzeichnis nach `opencode.json` und geht bis zum nächsten Git-Verzeichnis hoch, sodass ein Repository Ihren maschinenweiten Provider überschreiben kann, ohne ihn zu ändern.

Platzieren Sie den Provider-Eintrag in der globalen Datei, und die Deadline bleibt überall gleich. Platzieren Sie ihn in einer Projektdatei, und nur dieses Repository leitet Anfragen über uns.

Setzen Sie `OPENCODE_DISABLE_PROJECT_CONFIG`, um die aufsteigende Suche zu beenden.

Zwei weitere Quellen existieren für Bundles und Automatisierung. `OPENCODE_CONFIG_DIR` benennt ein Verzeichnis, aus dem OpenCode Konfigurationen liest, und `OPENCODE_CONFIG_CONTENT` enthält das JSON inline. Verwenden Sie `OPENCODE_CONFIG` für eine Datei, die Sie pro Lauf auswählen.

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

## Deadline stattdessen in der Konfiguration festlegen

OpenCode kann `start_within` selbst senden. Beide Stellen sind reines JSON, und beide haben Vorrang vor dem Schlüssel.

Legen Sie es pro Modell fest. Der `options`-Block wird in den Request-Body für dieses Modell eingefügt.

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

Legen Sie es stattdessen pro Variante fest, um ohne Modellwechsel zu wechseln. Wählen Sie eine mit `--variant` bei `opencode run` aus oder wechseln Sie sie in der TUI mit `ctrl+t` durch.

```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" }
  }
}
```

Eine hier festgelegte Dauer schlägt bei einem Modell fehl, das nicht am Wettlauf teilnehmen kann. Dieselbe Dauer auf dem Schlüssel führt stattdessen zu einem Fallback. Das ist der Grund, den Schlüssel zu bevorzugen.

## Bestätigen, dass der Schlüssel angewendet wurde

Jede Antwort enthält `x-flexinference-defaults-applied`. OpenCode zeigt keine Response-Header in der TUI an, lesen Sie stattdessen die Anfrage im Dashboard unter **Logs**.

## Fehlerbehebung

**Anfragen erreichen uns nie.** Das Top-Level-Feld `model` wählt den Provider aus. Wenn Sie also einen Provider definieren, ohne ihn dort zu benennen, bleibt OpenCode bei seiner integrierten Standardeinstellung. Setzen Sie `"model": "flexinference/<slug>"`.

**[`401 invalid_api_key`](/de/errors#invalid_api_key).** `FLEXINFERENCE_API_KEY` ist in der Shell, die OpenCode gestartet hat, nicht gesetzt. Exportieren Sie ihn vor dem Start, da `options.apiKey` ihn aus der Umgebung liest.

**[`400 unsupported_parameter`](/de/errors#unsupported_parameter).** Ein Chat Completions-Parameter, den wir nicht übersetzen, war in den `options` eines Modells enthalten, z. B. `seed` oder `stop`. Entfernen Sie ihn aus dem Eintrag.

**[`400 key_default_not_applicable`](/de/errors#key_default_not_applicable).** Ihr Schlüssel enthält eine Dauer, und einer dieser Parameter wurde daneben angegeben. Bearbeiten Sie den Schlüssel auf eine Stufe oder entfernen Sie den Parameter.

**[`400 flex_unsupported_for_anthropic`](/de/errors#flex_unsupported_for_anthropic).** Eine Dauer in `options` erreichte ein `claude-*`-Modell mit Ihrem eigenen Anthropic-Schlüssel. Der [Wettlauf](/de/deadline-routing), den eine Claude-Dauer ausführt, erfordert verwaltete Schlüssel. Entfernen Sie die Dauer und lassen Sie den Schlüssel die Deadline halten, da eine Schlüssel-Dauer stattdessen ein Fallback auslöst.

**Eine Konfigurationsänderung bewirkte nichts.** Eine spätere Konfigurationsquelle hat sie überschrieben. Überprüfen Sie die oben genannte Suchreihenfolge und bevorzugen Sie `OPENCODE_CONFIG`, um sich pro Lauf für eine Datei zu entscheiden.

Siehe [Fehler](/de/errors) für jede von uns zurückgegebene Ablehnung und [Agent-Schlüssel](/de/agent-keys) für diejenigen, die nicht spezifisch für OpenCode sind. [OpenWork](/de/openwork) und [OpenScience](/de/openscience) lesen denselben Provider-Eintrag.