# Opencode Providers

> |

- **Type:** Skill
- **Install:** `agentstack add skill-timmy6942025-opencode-builder-skill-opencode-providers`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Timmy6942025](https://agentstack.voostack.com/s/timmy6942025)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Timmy6942025](https://github.com/Timmy6942025)
- **Source:** https://github.com/Timmy6942025/opencode-builder-skill/tree/main/skills/opencode-providers

## Install

```sh
agentstack add skill-timmy6942025-opencode-builder-skill-opencode-providers
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# OpenCode Providers

> **📚 Official Docs:** For the latest information, always refer to the official documentation:
> [https://opencode.ai/docs/providers/](https://opencode.ai/docs/providers/)

## Overview

OpenCode uses the [AI SDK](https://ai-sdk.dev/) and [Models.dev](https://models.dev) to support **75+ LLM providers** and local models. Providers are configured through `opencode.json` and authenticated via the `/connect` command.

**Quick start:**
1. Run `/connect` in the TUI and select your provider
2. Enter your API key when prompted
3. Run `/models` to select a model

### Credentials

API keys added via `/connect` are stored in `~/.local/share/opencode/auth.json`.

### Provider Config

Customize providers through the `provider` section in `opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}
```

**Key config fields:**
- `npm` — AI SDK package (e.g. `@ai-sdk/openai-compatible` for OpenAI-compatible endpoints, `@ai-sdk/openai` for `/v1/responses` endpoints)
- `name` — Display name in UI
- `options.baseURL` — API endpoint URL
- `options.apiKey` — API key (or use `/connect`)
- `options.headers` — Custom headers sent with each request
- `models` — Map of model IDs to configurations
- `limit.context` — Maximum input tokens the model accepts
- `limit.output` — Maximum tokens the model can generate

---

## OpenCode Zen

OpenCode Zen is a curated list of tested and verified models provided by the OpenCode team. It works like any other provider — pay-as-you-go, completely optional.

**Setup:**
1. Sign in at [opencode.ai/auth](https://opencode.ai/auth), add billing details, copy API key
2. Run `/connect`, select **OpenCode Zen**, paste API key
3. Run `/models` to see recommended models

**Free models available:**
- DeepSeek V4 Flash Free
- MiMo-V2.5 Free
- Nemotron 3 Super Free
- Big Pickle (stealth model)

**Pricing (per 1M tokens, selected models):**

| Model | Input | Output | Cached Read |
|-------|-------|--------|-------------|
| GPT 5.5 (≤272K) | $5.00 | $30.00 | $0.50 |
| GPT 5.4 | $2.50 | $15.00 | $0.25 |
| Claude Opus 4.8 | $5.00 | $25.00 | $0.50 |
| Claude Sonnet 4.6 | $3.00 | $15.00 | $0.30 |
| Gemini 3.5 Flash | $1.50 | $9.00 | $0.15 |
| Kimi K2.5 | $0.60 | $3.00 | $0.10 |
| MiniMax M2.7 | $0.30 | $1.20 | $0.06 |
| Qwen3.6 Plus | $0.20 | $1.20 | $0.02 |
| GPT 5 Nano | $0.05 | $0.40 | $0.005 |

**Features:**
- **Auto-reload**: Balance below $5 triggers $20 reload (configurable, can disable)
- **Monthly limits**: Set per-workspace and per-member spending caps
- **Teams**: Invite teammates, assign roles (Admin/Member), curate model access, bring your own keys
- **Privacy**: Zero-retention by default; free models may use data for improvement; OpenAI/Anthropic retain requests 30 days

**Model ID format in config:** `opencode/` (e.g. `opencode/gpt-5.5`)

**Endpoints:**
- OpenAI models: `https://opencode.ai/zen/v1/responses`
- Anthropic models: `https://opencode.ai/zen/v1/messages`
- Google models: `https://opencode.ai/zen/v1/models/`
- Other models: `https://opencode.ai/zen/v1/chat/completions`

---

## OpenCode Go

OpenCode Go is a low-cost subscription plan for popular open coding models.

- **$5 first month, $10/month** after that
- Models tested and verified for coding tasks

**Setup:**
1. Run `/connect`, select **OpenCode Go**, go to [opencode.ai/auth](https://opencode.ai/zen)
2. Sign in, add billing, copy API key
3. Paste API key in terminal
4. Run `/models` to see available models

**Usage limits:**
- 5 hour limit: $12
- Weekly limit: $30
- Monthly limit: $60

**Available models:**
- GLM-5
- GLM-5.1
- Kimi K2.5
- Kimi K2.6
- MiMo-V2.5
- MiMo-V2.5-Pro
- MiniMax M2.5
- MiniMax M2.7
- Qwen3.6 Plus
- Qwen3.7 Max
- DeepSeek V4 Pro
- DeepSeek V4 Flash

---

## Major Providers

### Anthropic (Claude)

Supports Claude Pro/Max OAuth and API keys.

**Setup:**
1. Run `/connect`, select **Anthropic**
2. Select **Claude Pro/Pro Max** for OAuth (opens browser) or **Manually enter API Key**
3. Run `/models` to select model

**Available models:** Claude Opus 4, Claude Sonnet 4, Claude Haiku 3.5, and others.

**Config example:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}
```

**Note:** Claude Pro/Max OAuth is the only supported way to use Anthropic subscriptions. Third-party plugins that use Claude subscriptions are explicitly prohibited by Anthropic and are no longer bundled with OpenCode as of v1.3.0.

### OpenAI

Supports ChatGPT Plus/Pro OAuth and API keys.

**Setup:**
1. Run `/connect`, select **OpenAI**
2. Select **ChatGPT Plus/Pro** for OAuth or **Manually enter API Key**
3. Run `/models` to select model

**Using API keys:** Select **Manually enter API Key** and paste your key.

### xAI

Supports SuperGrok OAuth, device-code flow, and API keys.

**Auth Method 1 — SuperGrok OAuth (browser):**
1. Run `/connect`, select **xAI**
2. Select **xAI Grok OAuth (SuperGrok Subscription)**
3. Browser opens for consent

**Auth Method 2 — SuperGrok device-code (headless/VPS):**
1. Run `/connect`, select **xAI**
2. Select **xAI Grok OAuth (Headless/Remote/VPS)**
3. Visit the verification URL on another device and enter the displayed code

**Auth Method 3 — API key:**
1. Create API key at [console.x.ai](https://console.x.ai)
2. Run `/connect`, select **xAI**
3. Select **Manually enter API Key** and paste your key

**Available models:** Grok Beta and others.

### GitHub Copilot

Uses device code flow. Requires GitHub Copilot subscription (some models need Pro+).

**Setup:**
1. Run `/connect`, search for **GitHub Copilot**
2. Navigate to `github.com/login/device` and enter the displayed code
3. Wait for authorization
4. Run `/models` to select model

```
┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
└ Waiting for authorization...
```

### Google Vertex AI

Requires Google Cloud project with Vertex AI API enabled.

**Environment variables:**
```bash
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global  # optional, defaults to global
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
```

**Or authenticate with gcloud:**
```bash
gcloud auth application-default login
```

**Config example:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "google-vertex": {
      "options": {
        "baseURL": "https://global-aiplatform.googleapis.com"
      }
    }
  }
}
```

**Tip:** The `global` region improves availability at no extra cost. Use regional endpoints (e.g. `us-central1`) for data residency requirements.

### Amazon Bedrock

Supports multiple authentication methods with configurable precedence.

**Environment variables:**
```bash
# Option 1: AWS access keys
export AWS_ACCESS_KEY_ID=XXX
export AWS_SECRET_ACCESS_KEY=YYY

# Option 2: Named AWS profile
export AWS_PROFILE=my-profile

# Option 3: Bedrock bearer token
export AWS_BEARER_TOKEN_BEDROCK=XXX
```

**Config example:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}
```

**Available options:**
- `region` — AWS region (e.g. `us-east-1`, `eu-west-1`)
- `profile` — Named profile from `~/.aws/credentials`
- `endpoint` — Custom endpoint URL for VPC endpoints (alias for `baseURL`)

**Authentication methods:**
- `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` — IAM user access keys
- `AWS_PROFILE` — Named profiles from `~/.aws/credentials`
- `AWS_BEARER_TOKEN_BEDROCK` — Long-term API keys from Bedrock console
- `AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN` — EKS IRSA / Kubernetes OIDC

**Authentication precedence:**
1. Bearer Token (`AWS_BEARER_TOKEN_BEDROCK` or `/connect` token)
2. AWS Credential Chain (profile, access keys, shared credentials, IAM roles, Web Identity, instance metadata)

**Custom inference profiles:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "models": {
        "anthropic-claude-sonnet-4.5": {
          "id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
        }
      }
    }
  }
}
```

### Azure OpenAI

Requires Azure OpenAI resource and model deployment.

**Setup:**
1. Create Azure OpenAI resource in Azure portal
2. Deploy a model in Azure AI Foundry (deployment name must match model name)
3. Run `/connect`, search for **Azure**
4. Enter API key
5. Set resource name:
```bash
export AZURE_RESOURCE_NAME=XXX
```
6. Run `/models` to select deployed model

**Note:** If you see "I'm sorry, but I cannot assist with that request" errors, change the content filter from **DefaultV2** to **Default** in your Azure resource.

**Azure Cognitive Services** uses a separate provider with `AZURE_COGNITIVE_SERVICES_RESOURCE_NAME`.

### GitLab Duo

Requires GitLab Premium or Ultimate subscription. Supports OAuth and personal access token.

**Setup:**
1. Run `/connect`, select **GitLab**
2. Choose authentication method:
   - **OAuth (Recommended):** Browser opens for authorization
   - **Personal Access Token:** Generate at GitLab User Settings > Access Tokens (scopes: `api`, token starts with `glpat-`)
3. Run `/models` to select model

**Available models:**
- `duo-chat-haiku-4-5` (default) — Fast responses
- `duo-chat-sonnet-4-5` — Balanced performance
- `duo-chat-opus-4-5` — Most capable

**Self-hosted GitLab:**
```bash
export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...
export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com  # optional
```

**Compliance config (lock to self-hosted):**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "small_model": "gitlab/duo-chat-haiku-4-5",
  "share": "disabled"
}
```

**OAuth for self-hosted:** Create application with callback URL `http://127.0.0.1:8080/callback` and scopes `api`, `read_user`, `read_repository`. Set `GITLAB_OAUTH_CLIENT_ID` env var.

**GitLab API tools plugin:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["opencode-gitlab-plugin"]
}
```

---

## Cloud Providers

### Cloudflare AI Gateway

Unified endpoint for OpenAI, Anthropic, Workers AI, and more.

**Setup:**
1. Create gateway in Cloudflare dashboard > AI > AI Gateway
2. Run `/connect`, search for **Cloudflare AI Gateway**
3. Enter Account ID, Gateway ID, and API token

**Environment variables:**
```bash
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
export CLOUDFLARE_API_TOKEN=your-api-token
```

**Config:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cloudflare-ai-gateway": {
      "models": {
        "openai/gpt-4o": {},
        "anthropic/claude-sonnet-4": {}
      }
    }
  }
}
```

### Cloudflare Workers AI

Run AI models on Cloudflare's global network via REST API.

**Environment variables:**
```bash
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_API_KEY=your-api-token
```

### DigitalOcean

Supports OAuth (recommended) and Model Access Keys. Inference Routers route requests to optimal models.

**OAuth (recommended):**
1. Run `/connect`, select **DigitalOcean**, choose **Login with DigitalOcean**
2. Authorize in browser
3. Inference Routers appear as `router:` in model picker

**Model Access Key:**
```bash
export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key
```

**Note:** Inference Routers are only auto-discovered with OAuth, not with Model Access Keys.

### Vercel AI Gateway

Unified endpoint for OpenAI, Anthropic, Google, xAI, and more. Models at list price.

**Setup:**
1. Create API key in Vercel dashboard > AI Gateway tab
2. Run `/connect`, search for **Vercel AI Gateway**
3. Enter API key

**Routing options:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "vercel": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "order": ["anthropic", "vertex"],
            "only": ["anthropic"],
            "zeroDataRetention": false
          }
        }
      }
    }
  }
}
```

### SAP AI Core

Access 40+ models from OpenAI, Anthropic, Google, Amazon, Meta, Mistral, and AI21.

**Setup:**
1. Create service key in SAP BTP Cockpit
2. Run `/connect`, search for **SAP AI Core**
3. Enter service key JSON

**Environment variables:**
```bash
export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
export AICORE_DEPLOYMENT_ID=your-deployment-id  # optional
export AICORE_RESOURCE_GROUP=your-resource-group  # optional
```

---

## AI Platform Providers

### OpenRouter

Multi-provider gateway with many preloaded models.

**Setup:**
1. Create API key at [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys)
2. Run `/connect`, search for **OpenRouter**
3. Enter API key

**Config — add models and provider routing:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "moonshotai/kimi-k2": {
          "options": {
            "provider": {
              "order": ["baseten"],
              "allow_fallbacks": false
            }
          }
        }
      }
    }
  }
}
```

### Together AI

1. Create account at [api.together.ai](https://api.together.ai), click **Add Key**
2. Run `/connect`, search for **Together AI**, enter key
3. Run `/models` to select

### Fireworks AI

1. Create account at [app.fireworks.ai](https://app.fireworks.ai/), click **Create API Key**
2. Run `/connect`, search for **Fireworks AI**, enter key
3. Run `/models` to select

### Groq

1. Create account at [console.groq.com](https://console.groq.com/), click **Create API Key**
2. Run `/connect`, search for **Groq**, enter key
3. Run `/models` to select

### Cerebras

1. Create account at [inference.cerebras.ai](https://inference.cerebras.ai/), generate API key
2. Run `/connect`, search for **Cerebras**, enter key
3. Run `/models` to select (e.g. Qwen 3 Coder 480B)

### DeepSeek

1. Create account at [platform.deepseek.com](https://platform.deepseek.com/), create API key
2. Run `/connect`, search for **DeepSeek**, enter key
3. Run `/models` to select (e.g. DeepSeek V4 Pro)

### Hugging Face

Inference Providers access via 17+ providers.

1. Create token at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) with Inference Providers permission
2. Run `/connect`, search for **Hugging Face**, enter token
3. Run `/models` to select

### NVIDIA

Free access to Nemotron and open models via [build.nvidia.com](https://build.nvidia.com).

1. Create account at build.nvidia.com, generate API key
2. Run `/connect`, search for **NVIDIA**, enter key
3. Run `/models` to select

**Environment variable:**
```bash
export NVIDIA_API_KEY=nvapi-your-key-here
```

**On-prem / NIM:**
```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "options": {
        "baseURL": "http://localhost:8000/v1"
      }
    }
  }
}
```

### Nebius Token Factory

1. Create account at [tokenfactory.nebius.com](https://tokenfactory.nebius.com/), click **Add Key**
2. Run `/connect`, search for **Nebius Token Factory**, enter key
3. Run `/models` to select

### Baseten

1. Create account at [app.baseten.co](https://app.baseten.co/), generate API key
2. Run `/connect`, search for **Baseten**, enter key
3. Run `/models` to select

### Deep Infra

1. Create account at [deepinfra.com/dash](https://deepinfra.com/dash), generate API key
2. Run `/connect`, search for **Deep Infra**, enter key
3. Run `/models`

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Timmy6942025](https://github.com/Timmy6942025)
- **Source:** [Timmy6942025/opencode-builder-skill](https://github.com/Timmy6942025/opencode-builder-skill)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-timmy6942025-opencode-builder-skill-opencode-providers
- Seller: https://agentstack.voostack.com/s/timmy6942025
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.