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

# Use OpenCode con CometAPI

> Use esta guía para configurar cuatro formatos de API de CometAPI como proveedores personalizados en OpenCode.

Use esta guía para ejecutar [OpenCode](https://opencode.ai/docs/) con CometAPI.
La configuración expone cuatro formatos de API mediante proveedores personalizados independientes.

Esta configuración se probó con OpenCode 1.18.16.

Referencias oficiales:

* [Instalación de OpenCode](https://opencode.ai/docs/#install)
* [Configuración de OpenCode](https://opencode.ai/docs/config/)
* [Proveedores personalizados de OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Selección de modelos de OpenCode](https://opencode.ai/docs/models/)
* [Permisos de OpenCode](https://opencode.ai/docs/permissions/)

<Note>
  Sustituya cada valor `your-model-id` por un ID de modelo de la
  [página de modelos de CometAPI](/es/overview/models). Elija un modelo que admita el formato de API
  de la entrada del proveedor correspondiente.
</Note>

## Requisitos previos

* Node.js y npm, u otro método de instalación de la guía de OpenCode
* Una cuenta de CometAPI con una clave de API activa del
  [panel de control](https://www.cometapi.com/console/token)
* Uno o más ID de modelo de la [página de modelos de CometAPI](/es/overview/models)

## Comprender los formatos de API

Cada ID de proveedor selecciona un adaptador de SDK y un formato de API.

| ID de proveedor      | Adaptador de OpenCode       | URL base                          | Formato de 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 |

Esta guía verifica la operación de Streaming de Gemini utilizada durante un turno normal del
agente de OpenCode. El adaptador de Google agrega
`:streamGenerateContent?alt=sse` a la ruta del modelo.

No agregue `/chat/completions`, `/responses`, `/messages` ni una ruta de modelo de Gemini
a `baseURL`. Cada adaptador agrega la ruta de operación requerida.

## Comprender los permisos de tiempo de ejecución

OpenCode se ejecuta con los permisos del proceso que lo inicia. Inicie
OpenCode en el directorio de proyecto previsto y mantenga una vía de reversión, como
git. Use un contenedor o sandbox cuando necesite límites más estrictos para el sistema de archivos, los procesos,
la red o las claves de API.

## Configurar OpenCode

<Steps>
  <Step title="Instalar OpenCode">
    Instala OpenCode con el paquete oficial de npm:

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

    Confirma que la CLI esté disponible:

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

    Consulta la [guía de instalación de OpenCode](https://opencode.ai/docs/#install)
    para conocer Homebrew, Windows, Docker y otros métodos de instalación.
  </Step>

  <Step title="Configura tu clave de API de CometAPI">
    Almacena tu clave de API de CometAPI en la variable de entorno `COMETAPI_KEY`.

    <Tabs>
      <Tab title="macOS / Linux / WSL">
        Lee la clave de API sin mostrarla en la terminal:

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

      <Tab title="Windows PowerShell">
        Lee la clave de API en la sesión actual de PowerShell:

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

    Configura la variable en cada sesión de shell que inicie OpenCode. No
    confirmes claves de API en el control de versiones.
  </Step>

  <Step title="Elige una ubicación de configuración">
    Usa una de estas ubicaciones compatibles:

    * Configuración global: `~/.config/opencode/opencode.json`
    * Configuración del proyecto: `opencode.json` en la raíz del proyecto

    OpenCode combina los archivos de configuración. Una configuración de proyecto anula los
    valores en conflicto de la configuración global.

    Usa el archivo global cuando quieras los proveedores en todos los proyectos. Usa el
    archivo del proyecto cuando un repositorio necesite sus propias entradas de modelos.
  </Step>

  <Step title="Agrega los proveedores de CometAPI">
    Crea el archivo de configuración seleccionado. Si el archivo ya contiene un
    `provider` objeto, combina estas cuatro entradas en ese objeto:

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

    Reemplaza cada clave `your-model-id` de forma independiente. Las cuatro entradas pueden usar
    diferentes ID de modelo.

    La configuración no establece un `model` de nivel superior. Esto te permite elegir
    el formato de API y el modelo necesarios mediante `/models`.

    <Warning>
      No uses `/connect` para esta configuración. Los campos `apiKey` se leen
      `COMETAPI_KEY` desde el entorno. Una variable no configurada se resuelve como un
      valor vacío en lugar de una clave de API `/connect` almacenada.
    </Warning>
  </Step>

  <Step title="Selecciona y verifica cada proveedor">
    Inicia OpenCode en el proyecto al que quieres que acceda:

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

    Ejecuta `/models` y luego selecciona una entrada `provider/model`. En las cuatro ejecuciones de verificación
    de esta guía, cada turno del modelo usó el formato de API correspondiente a la entrada seleccionada.
    No se observó ninguna distribución de solicitudes entre formatos ni negociación automática del formato de API
    .

    Para verificar Chat Completions desde la línea de comandos, ejecuta:

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

    Para verificar Responses desde la línea de comandos, ejecuta:

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

    Para verificar Anthropic Messages desde la línea de comandos, ejecuta:

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

    Para verificar Gemini generateContent desde la línea de comandos, ejecuta:

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

## Solución de problemas

<AccordionGroup>
  <Accordion title="OpenCode no muestra un modelo de CometAPI">
    Confirme que la configuración sea JSON válido. Cada entrada personalizada debe estar
    dentro del objeto `provider` de nivel superior, y cada ID de modelo debe estar dentro
    del objeto `models` correspondiente. Reinicie OpenCode y luego abra `/models` de nuevo.
  </Accordion>

  <Accordion title="OpenCode informa de un error de clave de API o autenticación">
    Confirme que `COMETAPI_KEY` esté configurado en la shell que inicia OpenCode.
    Una referencia `{env:COMETAPI_KEY}` no configurada se convierte en un valor vacío. Abra una nueva
    shell después de cambiar un perfil de shell.
  </Accordion>

  <Accordion title="Un ID de modelo no está disponible">
    Consulte la [página de modelos de CometAPI](/es/overview/models), luego sustituya el modelo
    ID dentro de la entrada del proveedor seleccionada. Confirme que el modelo acepte el formato de API de ese
    proveedor.
  </Accordion>

  <Accordion title="Las solicitudes usan una ruta incorrecta">
    Mantenga `baseURL` en `/v1` para Chat Completions, Responses y Messages. Use
    `/v1beta` para Gemini. No incluya una ruta de operación en `baseURL`.
  </Accordion>

  <Accordion title="Un proveedor funciona, pero otro falla">
    Use un ID de modelo que acepte el formato de API del proveedor seleccionado. No
    suponga que un ID de modelo acepta los cuatro formatos.
  </Accordion>

  <Accordion title="La configuración del proyecto modifica un proveedor global">
    OpenCode combina la configuración global y la del proyecto. Cambie el nombre del
    ID del proveedor del proyecto o elimine sus valores en conflicto cuando desee que la entrada del proveedor global
    permanezca sin cambios.
  </Accordion>

  <Accordion title="OpenCode tiene más acceso del esperado">
    OpenCode usa los permisos del proceso que lo inició. Ejecute OpenCode
    en un contenedor o sandbox cuando necesite límites de acceso más estrictos.
  </Accordion>
</AccordionGroup>

## Recursos relacionados

* [Inicio rápido de CometAPI](/es/overview/quick-start)
* [Página de modelos de CometAPI](/es/overview/models)
* [Proveedores personalizados de OpenCode](https://opencode.ai/docs/providers/#custom-provider)
* [Configuración de OpenCode](https://opencode.ai/docs/config/)
* [Selección de modelos en 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": "Usa OpenCode con CometAPI",
        "description": "Usa esta guía para configurar cuatro formatos de API de CometAPI como proveedores personalizados en OpenCode.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-1",
            "position": 1,
            "name": "Instalar OpenCode",
            "text": "Instala OpenCode y confirma que la CLI esté disponible."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-2",
            "position": 2,
            "name": "Configura tu clave de API de CometAPI",
            "text": "Almacena tu clave de API de CometAPI en la variable de entorno COMETAPI_KEY."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-3",
            "position": 3,
            "name": "Elige una ubicación para la configuración",
            "text": "Elige la configuración global de OpenCode o una configuración del proyecto."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-4",
            "position": 4,
            "name": "Añade los proveedores de CometAPI",
            "text": "Añade cuatro entradas de proveedores personalizados de CometAPI a opencode.json."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/opencode#step-5",
            "position": 5,
            "name": "Selecciona y verifica cada proveedor",
            "text": "Selecciona y verifica el proveedor y el modelo de CometAPI necesarios."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentación de CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integraciones",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Usa OpenCode con CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/opencode"
          }
        ]
      }
    ]
    }
    `}
</script>