> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenCode mit CometAPI verwenden

> Verwende diese Anleitung, um vier CometAPI-API-Formate als benutzerdefinierte Provider in OpenCode zu konfigurieren.

Verwende diese Anleitung, um [OpenCode](https://opencode.ai/docs/) mit CometAPI auszuführen.
Die Konfiguration stellt vier API-Formate über separate benutzerdefinierte Provider bereit.

Diese Konfiguration wurde mit OpenCode 1.18.16 getestet.

Offizielle Referenzen:

* [OpenCode-Installation](https://opencode.ai/docs/#install)
* [OpenCode-Konfiguration](https://opencode.ai/docs/config/)
* [Benutzerdefinierte OpenCode-Provider](https://opencode.ai/docs/providers/#custom-provider)
* [OpenCode-Modellauswahl](https://opencode.ai/docs/models/)
* [OpenCode-Berechtigungen](https://opencode.ai/docs/permissions/)

<Note>
  Ersetze jeden Wert `your-model-id` durch eine Modell-ID von der
  [CometAPI Models-Seite](/de/overview/models). Wähle ein Modell, das das API-
  Format des umgebenden Provider-Eintrags unterstützt.
</Note>

## Voraussetzungen

* Node.js und npm oder eine andere Installationsmethode aus dem OpenCode-Leitfaden
* Ein CometAPI-Konto mit einem aktiven API-Schlüssel aus dem
  [Dashboard](https://www.cometapi.com/console/token)
* Eine oder mehrere Modell-IDs von der [CometAPI Models-Seite](/de/overview/models)

## API-Formate verstehen

Jede Provider-ID wählt einen SDK-Adapter und ein API-Format aus.

| Provider-ID          | OpenCode-Adapter            | Basis-URL                         | API-Format             |
| -------------------- | --------------------------- | --------------------------------- | ---------------------- |
| `cometapi-chat`      | `@ai-sdk/openai-compatible` | `https://api.cometapi.com/v1`     | Chat Completions       |
| `cometapi-responses` | `@ai-sdk/openai`            | `https://api.cometapi.com/v1`     | Responses              |
| `cometapi-messages`  | `@ai-sdk/anthropic`         | `https://api.cometapi.com/v1`     | Anthropic Messages     |
| `cometapi-gemini`    | `@ai-sdk/google`            | `https://api.cometapi.com/v1beta` | Gemini generateContent |

Diese Anleitung überprüft den Gemini-Streaming-Vorgang, der während eines normalen
OpenCode-Agent-Durchlaufs verwendet wird. Der Google-Adapter fügt
`:streamGenerateContent?alt=sse` dem Modellpfad hinzu.

Füge `/chat/completions`, `/responses`, `/messages` oder einen Gemini-Modellpfad nicht
zu `baseURL` hinzu. Jeder Adapter fügt seinen erforderlichen Operationspfad hinzu.

## Laufzeitberechtigungen verstehen

OpenCode wird mit den Berechtigungen des Prozesses ausgeführt, der es startet. Starte
OpenCode im vorgesehenen Projektverzeichnis und halte einen Rücksetzpfad wie
git bereit. Verwende einen Container oder eine Sandbox, wenn du strengere Grenzen für Dateisystem, Prozesse,
Netzwerk oder API-Schlüssel benötigst.

## OpenCode konfigurieren

<Steps>
  <Step title="OpenCode installieren">
    Installieren Sie OpenCode mit dem offiziellen npm-Paket:

    ```bash theme={null}
    npm install -g opencode-ai
    ```

    Bestätigen Sie, dass die CLI verfügbar ist:

    ```bash theme={null}
    opencode --version
    ```

    Siehe den [OpenCode-Installationsleitfaden](https://opencode.ai/docs/#install)
    für Homebrew, Windows, Docker und andere Installationsmethoden.
  </Step>

  <Step title="Ihren CometAPI API-Schlüssel festlegen">
    Speichern Sie Ihren CometAPI API-Schlüssel in der Umgebungsvariable `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Lesen Sie den API-Schlüssel, ohne ihn im Terminal anzuzeigen:

        ```bash theme={null}
        read -rsp "CometAPI API key: " COMETAPI_KEY
        printf '\n'
        export COMETAPI_KEY
        ```
      </Tab>

      <Tab title="Windows PowerShell">
        Lesen Sie den API-Schlüssel in die aktuelle PowerShell-Sitzung ein:

        ```powershell theme={null}
        $secureKey = Read-Host "CometAPI API key" -AsSecureString
        $env:COMETAPI_KEY = [System.Net.NetworkCredential]::new(
          "",
          $secureKey
        ).Password
        ```
      </Tab>
    </Tabs>

    Legen Sie die Variable in jeder Shell-Sitzung fest, die OpenCode startet. Übertragen Sie
    API-Schlüssel nicht in die Versionsverwaltung.
  </Step>

  <Step title="Einen Konfigurationsspeicherort auswählen">
    Verwenden Sie einen dieser unterstützten Speicherorte:

    * Globale Konfiguration: `~/.config/opencode/opencode.json`
    * Projektkonfiguration: `opencode.json` im Projektstammverzeichnis

    OpenCode führt Konfigurationsdateien zusammen. Eine Projektkonfiguration überschreibt
    widersprüchliche Werte aus der globalen Konfiguration.

    Verwenden Sie die globale Datei, wenn Sie die Anbieter in jedem Projekt verwenden möchten. Verwenden Sie die
    Projektdatei, wenn ein Repository eigene Modelleinträge benötigt.
  </Step>

  <Step title="Die CometAPI-Anbieter hinzufügen">
    Erstellen Sie die ausgewählte Konfigurationsdatei. Wenn die Datei bereits ein
    `provider` Objekt enthält, führen Sie diese vier Einträge mit diesem Objekt zusammen:

    ```json theme={null}
    {
      "$schema": "https://opencode.ai/config.json",
      "provider": {
        "cometapi-chat": {
          "npm": "@ai-sdk/openai-compatible",
          "name": "CometAPI Chat Completions",
          "options": {
            "baseURL": "https://api.cometapi.com/v1",
            "apiKey": "{env:COMETAPI_KEY}"
          },
          "models": {
            "your-model-id": {
              "name": "CometAPI Chat model"
            }
          }
        },
        "cometapi-responses": {
          "npm": "@ai-sdk/openai",
          "name": "CometAPI Responses",
          "options": {
            "baseURL": "https://api.cometapi.com/v1",
            "apiKey": "{env:COMETAPI_KEY}"
          },
          "models": {
            "your-model-id": {
              "name": "CometAPI Responses model"
            }
          }
        },
        "cometapi-messages": {
          "npm": "@ai-sdk/anthropic",
          "name": "CometAPI Anthropic Messages",
          "options": {
            "baseURL": "https://api.cometapi.com/v1",
            "apiKey": "{env:COMETAPI_KEY}"
          },
          "models": {
            "your-model-id": {
              "name": "CometAPI Messages model"
            }
          }
        },
        "cometapi-gemini": {
          "npm": "@ai-sdk/google",
          "name": "CometAPI Gemini",
          "options": {
            "baseURL": "https://api.cometapi.com/v1beta",
            "apiKey": "{env:COMETAPI_KEY}"
          },
          "models": {
            "your-model-id": {
              "name": "CometAPI Gemini model"
            }
          }
        }
      }
    }
    ```

    Ersetzen Sie jeden Schlüssel `your-model-id` unabhängig. Die vier Einträge können
    unterschiedliche Modell-IDs verwenden.

    Die Konfiguration legt kein übergeordnetes `model` fest. Dadurch können Sie
    das erforderliche API-Format und Modell über `/models` auswählen.

    <Warning>
      Verwenden Sie `/connect` nicht für diese Konfiguration. Die Felder `apiKey` lesen
      `COMETAPI_KEY` aus der Umgebung. Eine nicht gesetzte Variable wird als
      leerer Wert statt als gespeicherter `/connect` API-Schlüssel aufgelöst.
    </Warning>
  </Step>

  <Step title="Jeden Anbieter auswählen und überprüfen">
    Starten Sie OpenCode in dem Projekt, auf das es zugreifen soll:

    ```bash theme={null}
    opencode
    ```

    Führen Sie `/models` aus und wählen Sie dann einen Eintrag `provider/model` aus. Bei den vier Verifizierungs
    durchläufen dieses Leitfadens verwendete jeder Modellaufruf das zum ausgewählten Eintrag passende API
    Format. Es wurde keine formatübergreifende Anfrageverteilung oder automatische Aushandlung des API-Formats
    beobachtet.

    Führen Sie zum Überprüfen von Chat Completions über die Befehlszeile Folgendes aus:

    ```bash theme={null}
    opencode run \
      --model cometapi-chat/your-model-id \
      "Reply exactly with: COMETAPI_CHAT_OK"
    ```

    Führen Sie zum Überprüfen von Responses über die Befehlszeile Folgendes aus:

    ```bash theme={null}
    opencode run \
      --model cometapi-responses/your-model-id \
      "Reply exactly with: COMETAPI_RESPONSES_OK"
    ```

    Führen Sie zum Überprüfen von Anthropic Messages über die Befehlszeile Folgendes aus:

    ```bash theme={null}
    opencode run \
      --model cometapi-messages/your-model-id \
      "Reply exactly with: COMETAPI_MESSAGES_OK"
    ```

    Führen Sie zum Überprüfen von Gemini generateContent über die Befehlszeile Folgendes aus:

    ```bash theme={null}
    opencode run \
      --model cometapi-gemini/your-model-id \
      "Reply exactly with: COMETAPI_GEMINI_OK"
    ```
  </Step>
</Steps>

## Fehlerbehebung

<AccordionGroup>
  <Accordion title="OpenCode zeigt kein CometAPI-Modell an">
    Vergewissern Sie sich, dass die Konfiguration gültiges JSON ist. Jeder benutzerdefinierte Eintrag muss sich
    im `provider`-Objekt der obersten Ebene befinden, und jede Modell-ID muss sich im
    entsprechenden `models`-Objekt befinden. Starten Sie OpenCode neu und öffnen Sie dann `/models` erneut.
  </Accordion>

  <Accordion title="OpenCode meldet einen API-Schlüssel- oder Authentifizierungsfehler">
    Vergewissern Sie sich, dass `COMETAPI_KEY` in der Shell gesetzt ist, die OpenCode startet.
    Ein nicht gesetzter Verweis auf `{env:COMETAPI_KEY}` wird zu einem leeren Wert. Öffnen Sie eine neue
    Shell, nachdem Sie ein Shell-Profil geändert haben.
  </Accordion>

  <Accordion title="Eine Modell-ID ist nicht verfügbar">
    Prüfen Sie die [CometAPI-Modellseite](/de/overview/models), und ersetzen Sie dann die Modell-
    ID im Eintrag des ausgewählten Anbieters. Vergewissern Sie sich, dass das Modell das
    API-Format dieses Anbieters unterstützt.
  </Accordion>

  <Accordion title="Anfragen verwenden einen falschen Pfad">
    Belassen Sie `baseURL` für Chat Completions, Responses und Messages auf `/v1`. Verwenden Sie
    `/v1beta` für Gemini. Fügen Sie keinen Vorgangspfad in `baseURL` ein.
  </Accordion>

  <Accordion title="Ein Anbieter funktioniert, aber ein anderer Anbieter schlägt fehl">
    Verwenden Sie eine Modell-ID, die das API-Format des ausgewählten Anbieters unterstützt. Gehen Sie nicht
    davon aus, dass eine Modell-ID alle vier Formate unterstützt.
  </Accordion>

  <Accordion title="Die Projektkonfiguration ändert einen globalen Anbieter">
    OpenCode führt die globale und die Projektkonfiguration zusammen. Benennen Sie die Anbieter-ID des
    Projekts um oder entfernen Sie die widersprüchlichen Werte, wenn Sie möchten, dass der globale
    Anbietereintrag unverändert bleibt.
  </Accordion>

  <Accordion title="OpenCode hat mehr Zugriff als erwartet">
    OpenCode verwendet die Berechtigungen des Prozesses, der es gestartet hat. Führen Sie OpenCode
    in einem Container oder einer Sandbox aus, wenn Sie stärkere Zugriffsgrenzen benötigen.
  </Accordion>
</AccordionGroup>

## Weiterführende Ressourcen

* [CometAPI-Schnellstart](/de/overview/quick-start)
* [CometAPI-Modellseite](/de/overview/models)
* [Benutzerdefinierte OpenCode-Anbieter](https://opencode.ai/docs/providers/#custom-provider)
* [OpenCode-Konfiguration](https://opencode.ai/docs/config/)
* [OpenCode-Modellauswahl](https://opencode.ai/docs/models/)

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "HowTo",
        "@id": "https://apidoc.cometapi.com/integrations/opencode#howto",
        "name": "OpenCode mit CometAPI verwenden",
        "description": "Verwenden Sie diese Anleitung, um vier CometAPI-API-Formate als benutzerdefinierte Anbieter in OpenCode zu konfigurieren.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "OpenCode installieren",
            "text": "Installieren Sie OpenCode und bestätigen Sie, dass die CLI verfügbar ist."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Ihren CometAPI-API-Schlüssel festlegen",
            "text": "Speichern Sie Ihren CometAPI-API-Schlüssel in der Umgebungsvariable COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Einen Konfigurationsspeicherort auswählen",
            "text": "Wählen Sie die globale OpenCode-Konfiguration oder eine Projektkonfiguration aus."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "Die CometAPI-Anbieter hinzufügen",
            "text": "Fügen Sie vier Einträge für benutzerdefinierte CometAPI-Anbieter zu opencode.json hinzu."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Jeden Anbieter auswählen und überprüfen",
            "text": "Wählen Sie den erforderlichen CometAPI-Anbieter und das Modell aus und überprüfen Sie sie."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "CometAPI-Dokumentation",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integrationen",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "OpenCode mit CometAPI verwenden",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>