> ## 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 gebruiken met CometAPI

> Gebruik deze handleiding om vier CometAPI API-indelingen als aangepaste providers in OpenCode te configureren.

Gebruik deze handleiding om [OpenCode](https://opencode.ai/docs/) met CometAPI.
De configuratie stelt vier API-indelingen beschikbaar via afzonderlijke aangepaste providers.

Deze configuratie is getest met OpenCode 1.18.16.

Officiële referenties:

* [OpenCode-installatie](https://opencode.ai/docs/#install)
* [OpenCode-configuratie](https://opencode.ai/docs/config/)
* [Aangepaste OpenCode-providers](https://opencode.ai/docs/providers/#custom-provider)
* [OpenCode-modelselectie](https://opencode.ai/docs/models/)
* [OpenCode-machtigingen](https://opencode.ai/docs/permissions/)

<Note>
  Vervang elke `your-model-id`-waarde door een model-ID van de
  [CometAPI Models-pagina](/nl/overview/models). Kies een model dat de API
  indeling van de omringende providervermelding accepteert.
</Note>

## Vereisten

* Node.js en npm, of een andere installatiemethode uit de OpenCode-handleiding
* Een CometAPI-account met een actieve API-sleutel uit het
  [dashboard](https://www.cometapi.com/console/token)
* Een of meer model-ID's van de [CometAPI Models-pagina](/nl/overview/models)

## De API-indelingen begrijpen

Elke provider-ID selecteert één SDK-adapter en één API-indeling.

| Provider-ID          | OpenCode-adapter            | Basis-URL                         | API-indeling           |
| -------------------- | --------------------------- | --------------------------------- | ---------------------- |
| `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 |

Deze handleiding controleert de Gemini-streamingbewerking die tijdens een normale
draai van de OpenCode-agent wordt gebruikt. De Google-adapter voegt
`:streamGenerateContent?alt=sse` toe aan het modelpad.

Voeg geen `/chat/completions`, `/responses`, `/messages` of een Gemini-modelpad
toe aan `baseURL`. Elke adapter voegt het vereiste bewerkingspad toe.

## Runtime-machtigingen begrijpen

OpenCode wordt uitgevoerd met de machtigingen van het proces waarmee u het start. Start
OpenCode in de bedoelde projectdirectory en houd een herstelmogelijkheid achter de hand, zoals
git. Gebruik een container of sandbox wanneer u sterkere grenzen voor het bestandssysteem, processen,
netwerk of API-sleutels nodig hebt.

## OpenCode configureren

<Steps>
  <Step title="OpenCode installeren">
    Installeer OpenCode met het officiële npm-pakket:

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

    Bevestig dat de CLI beschikbaar is:

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

    Zie de [installatiehandleiding voor OpenCode](https://opencode.ai/docs/#install)
    voor Homebrew, Windows, Docker en andere installatiemethoden.
  </Step>

  <Step title="Uw CometAPI API-sleutel instellen">
    Sla uw CometAPI API-sleutel op in de omgevingsvariabele `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Lees de API-sleutel zonder deze in de terminal weer te geven:

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

      <Tab title="Windows PowerShell">
        Lees de API-sleutel in de huidige PowerShell-sessie:

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

    Stel de variabele in in elke shellsessie die OpenCode start. Sla API-sleutels niet
    op in versiebeheer.
  </Step>

  <Step title="Een configuratielocatie kiezen">
    Gebruik een van deze ondersteunde locaties:

    * Globale configuratie: `~/.config/opencode/opencode.json`
    * Projectconfiguratie: `opencode.json` in de hoofdmap van het project

    OpenCode voegt configuratiebestanden samen. Een projectconfiguratie overschrijft
    conflicterende waarden uit de globale configuratie.

    Gebruik het globale bestand als u de providers in elk project wilt gebruiken. Gebruik het
    projectbestand wanneer een repository eigen modelvermeldingen nodig heeft.
  </Step>

  <Step title="De CometAPI-providers toevoegen">
    Maak het geselecteerde configuratiebestand. Als het bestand al een
    `provider` object bevat, voegt u deze vier vermeldingen samen in dat object:

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

    Vervang elke `your-model-id`-key afzonderlijk. De vier vermeldingen kunnen
    verschillende model-ID's gebruiken.

    De configuratie stelt geen `model` op hoofdniveau in. Hiermee kunt u kiezen
    de vereiste API-indeling en het model via `/models`.

    <Warning>
      Gebruik `/connect` niet voor deze configuratie. De velden `apiKey` lezen
      `COMETAPI_KEY` uit de omgeving. Een niet-ingestelde variabele wordt omgezet in een
      lege waarde in plaats van een opgeslagen `/connect` API-sleutel.
    </Warning>
  </Step>

  <Step title="Elke provider selecteren en verifiëren">
    Start OpenCode in het project waartoe u toegang wilt geven:

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

    Voer `/models` uit en selecteer vervolgens een `provider/model`-vermelding. In de vier controles
    voor deze handleiding gebruikte elke modelbeurt de API
    indeling die overeenkwam met de geselecteerde vermelding. Er werd geen fan-out van aanvragen tussen indelingen of automatische onderhandeling over API-indelingen
    waargenomen.

    Voer het volgende uit om Chat Completions vanaf de opdrachtregel te verifiëren:

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

    Voer het volgende uit om Responses vanaf de opdrachtregel te verifiëren:

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

    Voer het volgende uit om Anthropic Messages vanaf de opdrachtregel te verifiëren:

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

    Voer het volgende uit om Gemini generateContent vanaf de opdrachtregel te verifiëren:

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

## Probleemoplossing

<AccordionGroup>
  <Accordion title="OpenCode toont geen CometAPI-model">
    Controleer of de configuratie geldige JSON is. Elke aangepaste vermelding moet zich
    binnen het object `provider` op het hoogste niveau bevinden en elke model-ID moet zich binnen
    het overeenkomstige object `models` bevinden. Herstart OpenCode en open vervolgens `/models` opnieuw.
  </Accordion>

  <Accordion title="OpenCode meldt een API-sleutel- of authenticatiefout">
    Controleer of `COMETAPI_KEY` is ingesteld in de shell waarmee OpenCode wordt gestart.
    Een niet-ingestelde verwijzing naar `{env:COMETAPI_KEY}` wordt een lege waarde. Open een nieuwe
    shell nadat je een shellprofiel hebt gewijzigd.
  </Accordion>

  <Accordion title="Een model-ID is niet beschikbaar">
    Controleer de [CometAPI Models-pagina](/nl/overview/models), en vervang vervolgens de model-
    ID binnen de vermelding van de geselecteerde provider. Controleer of het model de API-indeling van die
    provider accepteert.
  </Accordion>

  <Accordion title="Verzoeken gebruiken een onjuist pad">
    Houd `baseURL` op `/v1` voor Chat Completions, Responses en Messages. Gebruik
    `/v1beta` voor Gemini. Neem geen bewerkingspad op in `baseURL`.
  </Accordion>

  <Accordion title="Eén provider werkt, maar een andere provider faalt">
    Gebruik een model-ID die de API-indeling van de geselecteerde provider accepteert. Ga er niet
    van uit dat één model-ID alle vier de indelingen accepteert.
  </Accordion>

  <Accordion title="De projectconfiguratie wijzigt een globale provider">
    OpenCode voegt globale en projectconfiguratie samen. Wijzig de naam van de project-
    provider-ID of verwijder de conflicterende waarden als je wilt dat de globale
    providervermelding ongewijzigd blijft.
  </Accordion>

  <Accordion title="OpenCode heeft meer toegang dan verwacht">
    OpenCode gebruikt de machtigingen van het proces waarmee het is gestart. Voer OpenCode
    uit in een container of sandbox wanneer je strengere toegangsgrenzen nodig hebt.
  </Accordion>
</AccordionGroup>

## Gerelateerde bronnen

* [Snel aan de slag met CometAPI](/nl/overview/quick-start)
* [Pagina met CometAPI-modellen](/nl/overview/models)
* [Aangepaste providers van OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [OpenCode-configuratie](https://opencode.ai/docs/config/)
* [Modelselectie in OpenCode](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 gebruiken met CometAPI",
        "description": "Gebruik deze handleiding om vier CometAPI API-indelingen als aangepaste providers in OpenCode te configureren.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "OpenCode installeren",
            "text": "Installeer OpenCode en bevestig dat de CLI beschikbaar is."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Je CometAPI API-sleutel instellen",
            "text": "Sla je CometAPI API-sleutel op in de omgevingsvariabele COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Een configuratielocatie kiezen",
            "text": "Kies de globale OpenCode-configuratie of een projectconfiguratie."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "De CometAPI-providers toevoegen",
            "text": "Voeg vier vermeldingen voor aangepaste CometAPI-providers toe aan opencode.json."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Elke provider selecteren en verifiëren",
            "text": "Selecteer en verifieer de vereiste CometAPI-provider en het vereiste model."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "CometAPI-documentatie",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integraties",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "OpenCode gebruiken met CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>