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

# Usare OpenCode con CometAPI

> Usa questa guida per configurare quattro formati API di CometAPI come provider personalizzati in OpenCode.

Usa questa guida per eseguire [OpenCode](https://opencode.ai/docs/) con CometAPI.
La configurazione espone quattro formati API tramite provider personalizzati separati.

Questa configurazione è stata testata con OpenCode 1.18.16.

Riferimenti ufficiali:

* [Installazione di OpenCode](https://opencode.ai/docs/#install)
* [Configurazione di OpenCode](https://opencode.ai/docs/config/)
* [Provider personalizzati di OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Selezione dei modelli in OpenCode](https://opencode.ai/docs/models/)
* [Autorizzazioni di OpenCode](https://opencode.ai/docs/permissions/)

<Note>
  Sostituisci ogni valore `your-model-id` con un ID modello dalla
  [pagina Modelli di CometAPI](/it/overview/models). Scegli un modello che accetti il formato API
  della voce del provider circostante.
</Note>

## Prerequisiti

* Node.js e npm, oppure un altro metodo di installazione dalla guida di OpenCode
* Un account CometAPI con una chiave API attiva dalla
  [dashboard](https://www.cometapi.com/console/token)
* Uno o più ID modello dalla [pagina Modelli di CometAPI](/it/overview/models)

## Comprendere i formati API

Ogni ID provider seleziona un adattatore SDK e un formato API.

| ID provider          | Adattatore OpenCode         | URL di base                       | Formato API            |
| -------------------- | --------------------------- | --------------------------------- | ---------------------- |
| `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 |

Questa guida verifica l'operazione di Streaming Gemini usata durante un normale
turno dell'agente OpenCode. L'adattatore Google aggiunge
`:streamGenerateContent?alt=sse` al percorso del modello.

Non aggiungere `/chat/completions`, `/responses`, `/messages`, né un percorso di modello Gemini
a `baseURL`. Ogni adattatore aggiunge il percorso dell'operazione richiesto.

## Comprendere le autorizzazioni di runtime

OpenCode viene eseguito con le autorizzazioni del processo che lo avvia. Avvia
OpenCode nella directory del progetto desiderata e conserva un percorso di rollback, ad esempio
git. Usa un container o una sandbox quando ti servono limiti più rigidi per filesystem, processi,
rete o chiavi API.

## Configura OpenCode

<Steps>
  <Step title="Installa OpenCode">
    Installa OpenCode con il pacchetto npm ufficiale:

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

    Conferma che la CLI sia disponibile:

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

    Consulta la [guida all'installazione di OpenCode](https://opencode.ai/docs/#install)
    per Homebrew, Windows, Docker e altri metodi di installazione.
  </Step>

  <Step title="Imposta la chiave API di CometAPI">
    Memorizza la chiave API di CometAPI nella variabile d'ambiente `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Leggi la chiave API senza visualizzarla nel terminale:

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

      <Tab title="Windows PowerShell">
        Leggi la chiave API nella sessione PowerShell corrente:

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

    Imposta la variabile in ogni sessione shell che avvia OpenCode. Non
    eseguire il commit delle chiavi API nel controllo versione.
  </Step>

  <Step title="Scegli una posizione per la configurazione">
    Usa una delle seguenti posizioni supportate:

    * Configurazione globale: `~/.config/opencode/opencode.json`
    * Configurazione del progetto: `opencode.json` nella radice del progetto

    OpenCode unisce i file di configurazione. Una configurazione di progetto sostituisce
    i valori in conflitto della configurazione globale.

    Usa il file globale quando vuoi che i provider siano disponibili in ogni progetto. Usa il
    file di progetto quando un repository necessita di proprie voci di modello.
  </Step>

  <Step title="Aggiungi i provider di CometAPI">
    Crea il file di configurazione selezionato. Se il file contiene già un
    `provider` oggetto, unisci queste quattro voci a quell'oggetto:

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

    Sostituisci ogni chiave `your-model-id` indipendentemente. Le quattro voci possono usare
    ID modello diversi.

    La configurazione non imposta un `model` di primo livello. Questo ti consente di scegliere
    il formato API e il modello richiesti tramite `/models`.

    <Warning>
      Non usare `/connect` per questa configurazione. I campi `apiKey` leggono
      `COMETAPI_KEY` dall'ambiente. Una variabile non impostata viene risolta in un
      valore vuoto anziché in una chiave API `/connect` memorizzata.
    </Warning>
  </Step>

  <Step title="Seleziona e verifica ogni provider">
    Avvia OpenCode nel progetto a cui vuoi consentire l'accesso:

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

    Esegui `/models`, quindi seleziona una voce `provider/model`. Nelle quattro verifiche
    eseguite per questa guida, ogni turno del modello ha utilizzato il formato API corrispondente alla voce selezionata.
    Non è stato osservato alcun fan-out delle richieste tra formati né alcuna negoziazione automatica del formato API
    osservata.

    Per verificare Chat Completions dalla riga di comando, esegui:

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

    Per verificare Responses dalla riga di comando, esegui:

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

    Per verificare Anthropic Messages dalla riga di comando, esegui:

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

    Per verificare Gemini generateContent dalla riga di comando, esegui:

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

## Risoluzione dei problemi

<AccordionGroup>
  <Accordion title="OpenCode non mostra un modello CometAPI">
    Verifica che la configurazione sia JSON valido. Ogni voce personalizzata deve trovarsi
    all'interno dell'oggetto `provider` di primo livello, e ogni ID modello deve trovarsi all'interno
    dell'oggetto `models` corrispondente. Riavvia OpenCode, quindi apri nuovamente `/models`.
  </Accordion>

  <Accordion title="OpenCode segnala un errore relativo alla chiave API o all'autenticazione">
    Verifica che `COMETAPI_KEY` sia impostato nella shell che avvia OpenCode.
    Un riferimento `{env:COMETAPI_KEY}` non impostato diventa un valore vuoto. Apri una nuova
    shell dopo aver modificato un profilo della shell.
  </Accordion>

  <Accordion title="Un ID modello non è disponibile">
    Consulta la [pagina Modelli di CometAPI](/it/overview/models), quindi sostituisci l'ID del modello
    all'interno della voce del provider selezionato. Verifica che il modello accetti il
    formato API del provider.
  </Accordion>

  <Accordion title="Le richieste usano un percorso errato">
    Mantieni `baseURL` impostato su `/v1` per Chat Completions, Responses e Messages. Usa
    `/v1beta` per Gemini. Non includere un percorso dell'operazione in `baseURL`.
  </Accordion>

  <Accordion title="Un provider funziona, ma un altro non riesce">
    Usa un ID modello che accetti il formato API del provider selezionato. Non
    presumere che un unico ID modello accetti tutti e quattro i formati.
  </Accordion>

  <Accordion title="La configurazione del progetto modifica un provider globale">
    OpenCode unisce la configurazione globale e quella di progetto. Rinomina l'ID del provider di progetto
    oppure rimuovi i valori in conflitto quando vuoi che la voce del provider globale
    rimanga invariata.
  </Accordion>

  <Accordion title="OpenCode dispone di più accesso del previsto">
    OpenCode usa le autorizzazioni del processo che lo ha avviato. Esegui OpenCode
    in un container o in una sandbox quando hai bisogno di limiti di accesso più rigorosi.
  </Accordion>
</AccordionGroup>

## Risorse correlate

* [Guida rapida di CometAPI](/it/overview/quick-start)
* [Pagina dei modelli di CometAPI](/it/overview/models)
* [Provider personalizzati di OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Configurazione di OpenCode](https://opencode.ai/docs/config/)
* [Selezione dei modelli 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": "Usare OpenCode con CometAPI",
        "description": "Usa questa guida per configurare quattro formati API di CometAPI come provider personalizzati in OpenCode.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "Installare OpenCode",
            "text": "Installa OpenCode e verifica che la CLI sia disponibile."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Impostare la chiave API di CometAPI",
            "text": "Memorizza la chiave API di CometAPI nella variabile d'ambiente COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Scegliere una posizione per la configurazione",
            "text": "Scegli la configurazione globale di OpenCode o una configurazione di progetto."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "Aggiungere i provider di CometAPI",
            "text": "Aggiungi quattro voci di provider personalizzati CometAPI a opencode.json."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Selezionare e verificare ogni provider",
            "text": "Seleziona e verifica il provider e il modello CometAPI richiesti."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentazione di CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integrazioni",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Usare OpenCode con CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>