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

# Utiliser OpenCode avec CometAPI

> Utilisez ce guide pour configurer quatre formats d’API CometAPI comme fournisseurs personnalisés dans OpenCode.

Utilisez ce guide pour exécuter [OpenCode](https://opencode.ai/docs/) avec CometAPI.
La configuration expose quatre formats d’API par l’intermédiaire de fournisseurs personnalisés distincts.

Cette configuration a été testée avec OpenCode 1.18.16.

Références officielles :

* [Installation d’OpenCode](https://opencode.ai/docs/#install)
* [Configuration d’OpenCode](https://opencode.ai/docs/config/)
* [Fournisseurs personnalisés d’OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Sélection des modèles dans OpenCode](https://opencode.ai/docs/models/)
* [Permissions d’OpenCode](https://opencode.ai/docs/permissions/)

<Note>
  Remplacez chaque valeur `your-model-id` par un ID de modèle de la
  [page des modèles CometAPI](/fr/overview/models). Choisissez un modèle qui accepte le format d’API
  de l’entrée de fournisseur correspondante.
</Note>

## Prérequis

* Node.js et npm, ou une autre méthode d’installation indiquée dans le guide OpenCode
* Un compte CometAPI avec une clé API active depuis le
  [tableau de bord](https://www.cometapi.com/console/token)
* Un ou plusieurs ID de modèle provenant de la [page des modèles CometAPI](/fr/overview/models)

## Comprendre les formats d’API

Chaque ID de fournisseur sélectionne un adaptateur SDK et un format d’API.

| ID du fournisseur    | Adaptateur OpenCode         | URL de base                       | Format d’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 |

Ce guide vérifie l’opération de Streaming de Gemini utilisée lors d’un
tour normal de l’agent OpenCode. L’adaptateur Google ajoute
`:streamGenerateContent?alt=sse` au chemin du modèle.

N’ajoutez pas `/chat/completions`, `/responses`, `/messages`, ni de chemin de modèle Gemini
à `baseURL`. Chaque adaptateur ajoute le chemin d’opération requis.

## Comprendre les autorisations d’exécution

OpenCode s’exécute avec les autorisations du processus qui le lance. Lancez
OpenCode dans le répertoire du projet prévu et conservez une voie de retour en arrière telle que
git. Utilisez un conteneur ou un bac à sable lorsque vous avez besoin de limites plus strictes pour le système de fichiers, les processus,
le réseau ou les clés API.

## Configurer OpenCode

<Steps>
  <Step title="Installer OpenCode">
    Installez OpenCode avec le package npm officiel :

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

    Confirmez que la CLI est disponible :

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

    Consultez le [guide d’installation d’OpenCode](https://opencode.ai/docs/#install)
    pour connaître les méthodes d’installation avec Homebrew, Windows, Docker et d’autres options.
  </Step>

  <Step title="Définir votre clé API CometAPI">
    Stockez votre clé API CometAPI dans la variable d’environnement `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Lisez la clé API sans l’afficher dans le terminal :

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

      <Tab title="Windows PowerShell">
        Lisez la clé API dans la session PowerShell actuelle :

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

    Définissez la variable dans chaque session de shell qui lance OpenCode. Ne
    commitez pas de clés API dans le contrôle de version.
  </Step>

  <Step title="Choisir un emplacement de configuration">
    Utilisez l’un de ces emplacements pris en charge :

    * Configuration globale : `~/.config/opencode/opencode.json`
    * Configuration de projet : `opencode.json` à la racine du projet

    OpenCode fusionne les fichiers de configuration. Une configuration de projet remplace
    les valeurs conflictuelles de la configuration globale.

    Utilisez le fichier global lorsque vous souhaitez disposer des fournisseurs dans chaque projet. Utilisez le
    fichier de projet lorsqu’un dépôt a besoin de ses propres entrées de modèle.
  </Step>

  <Step title="Ajouter les fournisseurs CometAPI">
    Créez le fichier de configuration sélectionné. Si le fichier contient déjà un
    `provider` objet, fusionnez ces quatre entrées dans cet objet :

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

    Remplacez chaque clé `your-model-id` séparément. Les quatre entrées peuvent utiliser
    des ID de modèle différents.

    La configuration ne définit pas de `model` de niveau supérieur. Cela vous permet de choisir
    le format d’API et le modèle requis via `/models`.

    <Warning>
      N’utilisez pas `/connect` pour cette configuration. Les champs `apiKey` sont lus
      `COMETAPI_KEY` depuis l’environnement. Une variable non définie devient une
      valeur vide au lieu d’une clé API `/connect` stockée.
    </Warning>
  </Step>

  <Step title="Sélectionner et vérifier chaque fournisseur">
    Démarrez OpenCode dans le projet auquel vous souhaitez qu’il accède :

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

    Exécutez `/models`, puis sélectionnez une entrée `provider/model`. Lors des quatre vérifications
    effectuées pour ce guide, chaque tour de modèle a utilisé le format d’API correspondant à l’entrée sélectionnée.
    Aucun envoi simultané de requêtes entre formats ni aucune négociation automatique du format d’API
    n’a été observé.

    Pour vérifier Chat Completions depuis la ligne de commande, exécutez :

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

    Pour vérifier Responses depuis la ligne de commande, exécutez :

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

    Pour vérifier Anthropic Messages depuis la ligne de commande, exécutez :

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

    Pour vérifier Gemini generateContent depuis la ligne de commande, exécutez :

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

## Dépannage

<AccordionGroup>
  <Accordion title="OpenCode n’affiche pas de modèle CometAPI">
    Vérifiez que la configuration est un JSON valide. Chaque entrée personnalisée doit se trouver
    dans l’objet `provider` de niveau supérieur, et chaque ID de modèle doit se trouver dans
    l’objet `models` correspondant. Redémarrez OpenCode, puis ouvrez de nouveau `/models`.
  </Accordion>

  <Accordion title="OpenCode signale une erreur de clé API ou d’authentification">
    Vérifiez que `COMETAPI_KEY` est défini dans le shell qui lance OpenCode.
    Une référence `{env:COMETAPI_KEY}` non définie devient une valeur vide. Ouvrez un nouveau
    shell après avoir modifié un profil de shell.
  </Accordion>

  <Accordion title="Un ID de modèle n’est pas disponible">
    Consultez la [page CometAPI Models](/fr/overview/models), puis remplacez l’ID de modèle
    dans l’entrée du fournisseur sélectionné. Vérifiez que le modèle accepte le format d’API de ce
    fournisseur.
  </Accordion>

  <Accordion title="Les requêtes utilisent un chemin incorrect">
    Conservez `baseURL` sur `/v1` pour Chat Completions, Responses et Messages. Utilisez
    `/v1beta` pour Gemini. N’incluez pas de chemin d’opération dans `baseURL`.
  </Accordion>

  <Accordion title="Un fournisseur fonctionne, mais un autre échoue">
    Utilisez un ID de modèle qui accepte le format d’API du fournisseur sélectionné. Ne supposez pas
    qu’un ID de modèle accepte les quatre formats.
  </Accordion>

  <Accordion title="La configuration du projet modifie un fournisseur global">
    OpenCode fusionne les configurations globale et de projet. Renommez l’ID du fournisseur du projet
    ou supprimez ses valeurs conflictuelles lorsque vous souhaitez que l’entrée du fournisseur global
    reste inchangée.
  </Accordion>

  <Accordion title="OpenCode dispose de plus d’accès que prévu">
    OpenCode utilise les autorisations du processus qui l’a lancé. Exécutez OpenCode
    dans un conteneur ou un sandbox lorsque vous avez besoin de limites d’accès plus strictes.
  </Accordion>
</AccordionGroup>

## Ressources associées

* [Démarrage rapide de CometAPI](/fr/overview/quick-start)
* [Page des modèles CometAPI](/fr/overview/models)
* [Fournisseurs personnalisés d’OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Configuration d’OpenCode](https://opencode.ai/docs/config/)
* [Sélection des modèles dans 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": "Utiliser OpenCode avec CometAPI",
        "description": "Utilisez ce guide pour configurer quatre formats d’API CometAPI en tant que fournisseurs personnalisés dans OpenCode.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "Installer OpenCode",
            "text": "Installez OpenCode et vérifiez que la CLI est disponible."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Définir votre clé API CometAPI",
            "text": "Stockez votre clé API CometAPI dans la variable d’environnement COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Choisir un emplacement de configuration",
            "text": "Choisissez la configuration globale d’OpenCode ou une configuration de projet."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "Ajouter les fournisseurs CometAPI",
            "text": "Ajoutez quatre entrées de fournisseurs personnalisés CometAPI à opencode.json."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Sélectionner et vérifier chaque fournisseur",
            "text": "Sélectionnez et vérifiez le fournisseur et le modèle CometAPI requis."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentation de CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Intégrations",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Utiliser OpenCode avec CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>