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

> Verbinden Sie OpenWork mit FlexInference, indem Sie ein OpenCode-Konfigurationspaket importieren.

OpenWork steuert ein OpenCode-Backend, daher ist die Datei, die Sie schreiben, eine OpenCode-Konfigurationsdatei. Das Backend liest den Provider-Eintrag daraus.

OpenWork bietet in seiner eigenen Benutzeroberfläche keine Möglichkeit, `start_within` festzulegen, daher hängt die Frist vom Schlüssel ab. Erstellen Sie zuerst einen: siehe [Agentenschlüssel](/de/agent-keys).

## Einrichtung mit einem Agenten

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

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

## OpenWork konfigurieren

1. Legen Sie eine `opencode.json` in ein eigenes Verzeichnis. Verwenden Sie den Provider-Eintrag von [OpenCode](/de/opencode).
2. Exportieren Sie den Schlüssel in der Shell, die OpenWork startet.

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

3. Starten Sie OpenWork mit dem festgelegten Importpfad.

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

OpenWork hält das Backend in einem isolierten Profil, sodass es eine Konfigurationsdatei in Ihrem Arbeitsverzeichnis ignoriert. Es kopiert das benannte Verzeichnis beim Start in das Profil und startet dann das Backend mit `OPENCODE_CONFIG_DIR`, das auf diese Kopie gesetzt ist.

`pnpm dev` setzt `OPENWORK_DEV_MODE=1`, was den Import aktiviert.

OpenWork leitet die übergeordnete Umgebung an das Backend weiter, wodurch `FLEXINFERENCE_API_KEY` den Provider-Eintrag erreicht.

## Der Geltungsbereich kommt vom Profil, nicht vom Ordner

OpenWork liest keine Konfiguration aus Ihrem Arbeitsverzeichnis, daher gilt die von [OpenCode](/de/opencode) angebotene globale und pro-Projekt-Aufteilung hier nicht. Der Geltungsbereich ergibt sich aus dem Profil, gegen das Sie starten.

| Geltungsbereich | Was ihn festlegt                                     | Gilt für                      |
| --------------- | ---------------------------------------------------- | ----------------------------- |
| Ein Profil      | `OPENWORK_ELECTRON_USERDATA` und `OPENWORK_DATA_DIR` | jede Sitzung in diesem Profil |
| Das Paket       | `OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR`            | was das Profil importiert     |

Behalten Sie ein Paar von Profilpfaden pro Konfiguration bei, zwischen denen Sie wechseln möchten. Dasselbe Paket, das in zwei Profile importiert wird, bietet Ihnen zwei isolierte Setups, jedes mit seiner eigenen Sitzungshistorie.

Verwenden Sie die oben genannten Pfade wieder, um ein Profil beizubehalten. Ändern Sie sie, um ein neues zu starten.

## Der Import kopiert bei jedem Start und löscht nie

Der Kopiervorgang läuft bei jedem Start und überschreibt. Bearbeiten Sie das Paket, starten Sie es auf denselben `OPENWORK_ELECTRON_USERDATA`- und `OPENWORK_DATA_DIR`-Pfaden neu, und das Backend liest die neue Datei.

Es wird nie gelöscht. Eine Datei, die Sie aus dem Paket entfernt haben, bleibt in der Profilkopie. Um dies zu bereinigen, sind neue Pfade für beide Variablen erforderlich, was das Profil neu startet und seine Sitzungshistorie verliert. Tun Sie dies nur, wenn eine verbleibende Datei im Weg ist.

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

Jede Antwort enthält `x-flexinference-defaults-applied`. Weder das Backend noch die OpenWork-Benutzeroberfläche zeigen Antwort-Header an, lesen Sie stattdessen die Anfrage im Dashboard unter **Logs**.

## Fehlerbehebung

**Der Import wurde nie ausgeführt.** `OPENWORK_DEV_MODE=1` aktiviert ihn, und `pnpm dev` setzt ihn. Ein Produktionsstart überspringt den Import.

**Eine Konfigurationsänderung hat nichts bewirkt.** Die Kopie wird pro Start ausgeführt, aber nur in das angegebene Profil. Starten Sie auf denselben `OPENWORK_ELECTRON_USERDATA`- und `OPENWORK_DATA_DIR`-Pfaden neu.

**Eine gelöschte Datei wird immer noch geladen.** Die Kopie überschreibt, löscht aber nie. Starten Sie ein neues Profil mit neuen Pfaden für beide Variablen und akzeptieren Sie den Verlust der Sitzungshistorie.

**Anfragen erreichen uns nie.** Das Top-Level-Feld `model` im Paket wählt den Provider aus. Ohne dieses bleibt das Backend bei seiner integrierten Standardeinstellung.

**[`401 invalid_api_key`](/de/errors#invalid_api_key).** `FLEXINFERENCE_API_KEY` ist in der Shell, die OpenWork gestartet hat, nicht gesetzt. Exportieren Sie es dort, da das Backend die Umgebung dieser Shell erbt.

Siehe [Fehler](/de/errors) für jede von uns zurückgegebene Ablehnung, [Agentenschlüssel](/de/agent-keys) für diejenigen, die nicht spezifisch für OpenWork sind, und [OpenCode](/de/opencode) für den Provider-Eintrag und die pro-Modell-Fristoptionen.