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

# Bruk OpenCode med CometAPI

> Bruk denne veiledningen til å konfigurere fire CometAPI API-formater som egendefinerte leverandører i OpenCode.

Bruk denne veiledningen til å kjøre [OpenCode](https://opencode.ai/docs/) med CometAPI.
Konfigurasjonen eksponerer fire API-formater gjennom separate egendefinerte leverandører.

Denne konfigurasjonen ble testet med OpenCode 1.18.16.

Offisielle referanser:

* [Installere OpenCode](https://opencode.ai/docs/#install)
* [Konfigurere OpenCode](https://opencode.ai/docs/config/)
* [Egendefinerte leverandører i OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Modellvalg i OpenCode](https://opencode.ai/docs/models/)
* [Tillatelser i OpenCode](https://opencode.ai/docs/permissions/)

<Note>
  Erstatt hver `your-model-id`-verdi med en modell-ID fra
  [CometAPI Models-siden](/no/overview/models). Velg en modell som støtter API-
  formatet for den omkringliggende leverandøroppføringen.
</Note>

## Forutsetninger

* Node.js og npm, eller en annen installasjonsmetode fra OpenCode-veiledningen
* En CometAPI-konto med en aktiv API-nøkkel fra
  [dashbordet](https://www.cometapi.com/console/token)
* Én eller flere modell-ID-er fra [CometAPI Models-siden](/no/overview/models)

## Forstå API-formatene

Hver leverandør-ID velger én SDK-adapter og ett API-format.

| Leverandør-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 |

Denne veiledningen verifiserer Gemini-strømmeoperasjonen som brukes under en vanlig
agent-runde i OpenCode. Google-adapteren legger til
`:streamGenerateContent?alt=sse` i modellstien.

Ikke legg til `/chat/completions`, `/responses`, `/messages` eller en Gemini-modell
sti i `baseURL`. Hver adapter legger til den nødvendige operasjonsstien.

## Forstå kjøretidstillatelser

OpenCode kjører med tillatelsene til prosessen som starter det. Start
OpenCode i den tiltenkte prosjektkatalogen, og behold en tilbakeføringsmulighet, for eksempel
git. Bruk en container eller sandkasse når du trenger sterkere grenser for filsystem, prosesser,
nettverk eller API-nøkler.

## Konfigurer OpenCode

<Steps>
  <Step title="Installer OpenCode">
    Installer OpenCode med den offisielle npm-pakken:

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

    Bekreft at CLI-en er tilgjengelig:

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

    Se [installasjonsveiledningen for OpenCode](https://opencode.ai/docs/#install)
    for Homebrew, Windows, Docker og andre installasjonsmetoder.
  </Step>

  <Step title="Angi CometAPI API-nøkkelen din">
    Lagre CometAPI API-nøkkelen din i miljøvariabelen `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Les API-nøkkelen uten å vise den i terminalen:

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

      <Tab title="Windows PowerShell">
        Les API-nøkkelen inn i den gjeldende PowerShell-økten:

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

    Angi variabelen i hver skalløkt som starter OpenCode. Ikke
    legg API-nøkler inn i versjonskontroll.
  </Step>

  <Step title="Velg en konfigurasjonsplassering">
    Bruk én av disse støttede plasseringene:

    * Global konfigurasjon: `~/.config/opencode/opencode.json`
    * Prosjektkonfigurasjon: `opencode.json` i prosjektroten

    OpenCode slår sammen konfigurasjonsfiler. En prosjektkonfigurasjon overstyrer
    verdier som er i konflikt, fra den globale konfigurasjonen.

    Bruk den globale filen når du vil ha leverandørene i alle prosjekter. Bruk
    prosjektfilen når et repositorium trenger egne modelloppføringer.
  </Step>

  <Step title="Legg til CometAPI-leverandørene">
    Opprett den valgte konfigurasjonsfilen. Hvis filen allerede inneholder et
    `provider` objekt, fletter du disse fire oppføringene inn i det objektet:

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

    Erstatt hver `your-model-id`-nøkkel uavhengig av de andre. De fire oppføringene kan bruke
    ulike modell-ID-er.

    Konfigurasjonen angir ikke en `model` på toppnivå. Dette lar deg velge
    det nødvendige API-formatet og modellen gjennom `/models`.

    <Warning>
      Ikke bruk `/connect` for denne konfigurasjonen. Feltene `apiKey` leses
      `COMETAPI_KEY` fra miljøet. En variabel som ikke er angitt, evalueres til en
      tom verdi i stedet for en lagret `/connect` API-nøkkel.
    </Warning>
  </Step>

  <Step title="Velg og verifiser hver leverandør">
    Start OpenCode i prosjektet du vil at det skal ha tilgang til:

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

    Kjør `/models`, og velg deretter en `provider/model`-oppføring. I de fire verifiserings
    kjøringene i denne veiledningen brukte hver modellrunde den valgte oppføringens samsvarende
    API-format. Ingen forespørselsfordeling på tvers av formater eller automatisk forhandling av API-format
    ble observert.

    For å verifisere Chat Completions fra kommandolinjen kjører du:

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

    For å verifisere Responses fra kommandolinjen kjører du:

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

    For å verifisere Anthropic Messages fra kommandolinjen kjører du:

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

    For å verifisere Gemini generateContent fra kommandolinjen kjører du:

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

## Feilsøking

<AccordionGroup>
  <Accordion title="OpenCode viser ikke en CometAPI-modell">
    Bekreft at konfigurasjonen er gyldig JSON. Hver egendefinerte oppføring må være
    i `provider`-objektet på øverste nivå, og hver modell-ID må være i
    det tilsvarende `models`-objektet. Start OpenCode på nytt, og åpne deretter `/models` igjen.
  </Accordion>

  <Accordion title="OpenCode rapporterer en API-nøkkel- eller autentiseringsfeil">
    Bekreft at `COMETAPI_KEY` er angitt i skallet som starter OpenCode.
    En ikke angitt `{env:COMETAPI_KEY}`-referanse blir en tom verdi. Åpne et nytt
    skall etter at du har endret en skallprofil.
  </Accordion>

  <Accordion title="En modell-ID er ikke tilgjengelig">
    Kontroller [siden CometAPI Models](/no/overview/models), og erstatt modell-
    ID-en i den valgte leverandøroppføringen. Bekreft at modellen godtar det
    API-formatet til leverandøren.
  </Accordion>

  <Accordion title="Forespørsler bruker en feil sti">
    Behold `baseURL` på `/v1` for Chat Completions, Responses og Messages. Bruk
    `/v1beta` for Gemini. Ikke inkluder en operasjonssti i `baseURL`.
  </Accordion>

  <Accordion title="Én leverandør fungerer, men en annen mislykkes">
    Bruk en modell-ID som godtar API-formatet til den valgte leverandøren. Ikke
    anta at én modell-ID godtar alle fire formatene.
  </Accordion>

  <Accordion title="Prosjektkonfigurasjonen endrer en global leverandør">
    OpenCode slår sammen global konfigurasjon og prosjektkonfigurasjon. Gi prosjekt-
    leverandør-ID-en et nytt navn, eller fjern verdier som er i konflikt, når du vil at den globale
    leverandøroppføringen skal forbli uendret.
  </Accordion>

  <Accordion title="OpenCode har mer tilgang enn forventet">
    OpenCode bruker tillatelsene til prosessen som startet det. Kjør OpenCode
    i en container eller sandbox når du trenger strengere tilgangsgrenser.
  </Accordion>
</AccordionGroup>

## Relaterte ressurser

* [Hurtigstart for CometAPI](/no/overview/quick-start)
* [CometAPI Models-siden](/no/overview/models)
* [Egendefinerte tilbydere i OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [OpenCode-konfigurasjon](https://opencode.ai/docs/config/)
* [Modellvalg i 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": "Bruk OpenCode med CometAPI",
        "description": "Bruk denne veiledningen til å konfigurere fire CometAPI API-formater som egendefinerte tilbydere i OpenCode.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "Installer OpenCode",
            "text": "Installer OpenCode og bekreft at CLI-en er tilgjengelig."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Angi CometAPI API-nøkkelen din",
            "text": "Lagre CometAPI API-nøkkelen din i miljøvariabelen COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Velg en konfigurasjonsplassering",
            "text": "Velg den globale OpenCode-konfigurasjonen eller en prosjektkonfigurasjon."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "Legg til CometAPI-tilbyderne",
            "text": "Legg til fire egendefinerte CometAPI-tilbyderoppføringer i opencode.json."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Velg og bekreft hver tilbyder",
            "text": "Velg og bekreft den nødvendige CometAPI-tilbyderen og modellen."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "CometAPI-dokumentasjon",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integrasjoner",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Bruk OpenCode med CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>