---
title: opencode()
description: >-
  The OpenCode 2 harness on any provider whose key reeval can broker, its
  options and id, the providers it runs on and refuses, the tokens it reports,
  its settings, web search and MCP servers.
---
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reeval.ai/llms.txt
> Use this file to discover all available pages before exploring further.

`opencode()` runs [OpenCode](https://opencode.ai) 2 in the Docker sandbox over its ACP server (`opencode acp`), on the model's provider: Google, Anthropic, OpenAI, OpenRouter and nearly 200 more. `model` is required, and its provider picks the key.

```ts title="reeval.config.ts"
import { defineConfig } from '{{ pkg }}'
import { opencode } from '{{ pkg }}/harness'

export default defineConfig({
  harness: [
    opencode({ model: 'google/gemini-3.8-flash' }),
    opencode({ model: 'anthropic/claude-haiku-4-5' }),
    opencode({ model: 'openai/gpt-5.4-mini' }),
  ],
})
```

## Options

<Property name="model" type="string">
  OpenCode's model id, `<provider>/<model>`, such as `google/gemini-3.8-flash`, `anthropic/claude-haiku-4-5` or `cerebras/gpt-oss-120b`. The provider, before the first `/`, picks the key: only that provider's key is needed and brokered. A bare id with no provider, or a provider reeval can't broker ([below](#refused-providers)), exits 2 at plan time. Required.
</Property>

<Property name="effort" type="string" optional>
  Reasoning effort for that provider: `options.reasoningEffort` on OpenAI, `options.thinking` on Anthropic. Values are whatever that provider takes (`high`, or a token budget). It isn't the measured [effort](/concepts/lift#effort-next-to-lift).
</Property>

<Property name="id" type="string" optional>
  The harness's id in cell keys, filters and the record. Default `opencode:<model>`, with the model's last segment: `opencode:claude-haiku-4-5`, or `opencode:<model>[effort=<value>]` when `effort` is set. Two cells whose models end the same, on different providers, need an `id` each.
</Property>

<Property name="gateway" type="'direct' | Gateway" optional>
  The gateway this harness's model calls go through, by name or helper, such as `direct()`. It skips the config's `gateway` fallback: the plan refuses a gateway that isn't listed or can't serve this harness. See [Gateways](/reference/gateway#pinning-a-harness).
</Property>

<Property name="maxConcurrent" type="number" optional>
  The most OpenCode attempts at once across the run, for example for your key's rate limits.
</Property>

<Property name="startTimeout" type="Duration" optional>
  How long its session may take to become ready (bootstrap and session start) before the attempt is an infra error, such as `'3m'`. Default `'90s'`. A start that times out is aborted and started once more; a second timeout fails the attempt with `opencode: session did not become ready within 90s (tried twice)`, and the record's `startRetries` notes a retried start.
</Property>

## At a glance

| | |
|---|---|
| Import | `'{{ pkg }}/harness'` |
| Credential | The model's provider's, such as `GOOGLE_GENERATIVE_AI_API_KEY` for `google/…` ([every provider](#supported-providers)) |
| Adapter | `@reeval/harness-opencode` 0.2.8 (over `@ai-sdk/harness-acp`), bundled with reeval |
| CLI | `@opencode/cli` 2.1.4 |
| Sandbox | `docker()` only |
| Image | `reeval-sandbox:opencode-0.2.10` |
| Rules file | `AGENTS.md` |
| Skills (default placement) | `~/.config/opencode/skills` |
| Skills (`placement: 'workspace'`) | `.opencode/skills` in the workspace |
| Plugins | Skills, subagents, commands and MCP servers ([below](#plugins)) |
| Egress hosts added | The provider's API hosts, such as `api.anthropic.com`, and `mcp.exa.ai` (web search) |
| Tokens | Reported per turn (below) |

Build its image once with `reeval image build` in a project whose config uses `opencode()`.

## The key

```text title="reeval run -v"
broker    ANTHROPIC_API_KEY stays on the host · the gateway swaps it in on POST api.anthropic.com/v1/messages
…
gateway   POST https://api.anthropic.com/v1/messages → 200 · allowed · … · substituted ANTHROPIC_API_KEY (x-api-key)
```

reeval reads the model's provider's key from the host, passes it to the adapter explicitly, and it never enters the container. The container gets only that provider's variable, holding a placeholder, so OpenCode can't reach another provider with another key. The gateway swaps the key in on the requests OpenCode 2.0.18 sends it on, in the header it uses:

| Provider | Header | Endpoint |
|---|---|---|
| `google` | `x-goog-api-key` | `POST generativelanguage.googleapis.com/v1beta/models/<model>:streamGenerateContent` |
| `anthropic` | `x-api-key` | `POST api.anthropic.com/v1/messages` |
| `openai` | `Authorization: Bearer` | `POST api.openai.com/v1/responses` |

Each provider's hosts, paths and headers come from running the pinned OpenCode against a mock server, once per provider and model API, and are listed [below](#supported-providers). A request that carries the placeholder anywhere else gets a 403 from the gateway, and the adapter refuses to run in a sandbox that can't broker the key.

`@ai-sdk/harness-opencode` brokers only a few providers' keys, for OpenCode 1, so reeval uses its own thin config over `@ai-sdk/harness-acp` instead.

## Served model

```json title="record (turn)"
{ "model": "gpt-5.4-mini-2026-03-17[effort=none]", … }
```

OpenCode's ACP server names no model, so each turn records the one the gateway saw serve its last model call. Gemini's API names it in the URL; every other provider's response body does, as its first `"model"` field, with the reasoning effort when the response reports one (OpenAI's Responses API).

reeval runs the provider's calls over HTTP (`transport: 'http'`, below): OpenCode's default for OpenAI and xAI is a WebSocket, whose frames the gateway doesn't read.

## On Vercel AI Gateway

```ts title="reeval.config.ts"
harness: opencode({ model: 'google/gemini-3.8-flash' }),
gateway: [vercel(), direct()],
```

With [`vercel()`](/reference/gateway#vercel-ai-gateway) in the config's `gateway`, OpenCode runs on its own `vercel` provider, as `vercel/<model>`, on `vercel()`'s key. Write the model as its provider's id: a `vercel/…` id would skip the gateway list, so it exits 2 at plan time. On Vercel any `<provider>/<model>` Vercel serves runs; the provider table below gates `direct()` only, where a provider reeval can't run stops the plan with exit 2. `effort` isn't taken on `vercel()` yet: nothing checks the model gets it, so such a cell falls through to the next gateway.

## On OpenRouter

```ts title="reeval.config.ts"
harness: opencode({ model: 'google/gemini-3.8-flash' }),
gateway: [openrouter(), direct()],
```

With [`openrouter()`](/reference/gateway#openrouter) in the config's `gateway`, OpenCode runs on its own `openrouter` provider, as `openrouter/<model>`, on `OPENROUTER_API_KEY`, brokered on `POST openrouter.ai/api/v1/chat/completions`. Write the model as its provider's id: an `openrouter/…` id would skip the gateway list, so it exits 2 at plan time. Each call records the upstream provider OpenRouter says served it, and its cost. `effort` isn't taken on `openrouter()` yet, so such a cell falls through to the next gateway.

## Amazon Bedrock

```bash title=".env.local"
AWS_BEARER_TOKEN_BEDROCK=...   # a Bedrock API key
AWS_REGION=eu-west-1           # optional; default us-east-1
```

```ts title="reeval.config.ts"
harness: opencode({
  model: 'amazon-bedrock/global.anthropic.claude-haiku-4-5',
}),
```

Bedrock runs on a Bedrock API key, which OpenCode sends as `Authorization: Bearer` and the gateway swaps in. reeval never passes AWS access keys, profiles or session tokens, which sign each request (SigV4) and can't be brokered. `AWS_REGION` isn't secret: reeval passes it into the sandbox as it is, and its region's hosts, `bedrock-runtime.<region>.amazonaws.com` and `bedrock-mantle.<region>.api.aws`, are the automatic egress hosts.

<Warning>
Bedrock's hosts, header and served model are checked with OpenCode against a mock server, and through reeval's gateway with a made-up key (which AWS refuses). It hasn't yet run against real Bedrock with a real key.
</Warning>

## Tokens

| ACP message | Used for |
|---|---|
| `PromptResponse.usage` | The turn's tokens: uncached input, output, and thought or cache tokens when the model reports them. Since OpenCode [#52467](https://github.com/anomalyco/opencode/pull/52467) it sums every model call in the turn |
| `usage_update` | Nothing: `used` is the last step's context size and `cost` the whole session's |

The summary totals the tokens on its `Tokens` line, and the record keeps them per turn, per attempt and for the run.

## Settings

reeval starts OpenCode with this config in `OPENCODE_CONFIG_CONTENT`, plus `OPENCODE_DISABLE_AUTOUPDATE=1` and `OPENCODE_DISABLE_MODELS_FETCH=1`. The CLI stays the image's, and its model catalogue is the one it shipped with:

```json
{
  "update": "disable",
  "share": "disabled",
  "permissions": [
    { "action": "question", "resource": "*", "effect": "deny" },
    { "action": "browser", "resource": "*", "effect": "deny" }
  ],
  "websearch": { "provider": "exa" },
  "agents": { "title": { "model": "<provider>/<model>" } },
  "providers": { "<provider>": { "settings": { "transport": "http" } } },
  "mcp": { "servers": { "<name>": { "…": "…", "codemode": false } } }
}
```

| Setting | Why |
|---|---|
| `update`, `share` | No self-update and no share links. |
| `question` denied | It waits for a person to answer. |
| `browser` denied | Its tools drive a desktop browser. |
| `websearch` | Web search on Exa, below. |
| `agents.title.model` | Session titles run on your model. OpenCode's default is a second, small one, such as `gemini-flash-lite-latest`. |
| `providers.<provider>.settings.transport` | Model calls go over HTTP, where the gateway reads the served model, not a WebSocket. |
| `mcp.servers` | The environment's MCP servers, below. |

Every other tool runs without asking, as on every harness: reeval answers OpenCode's permission requests with allow.

## Your own opencode.jsonc

```jsonc title="opencode.jsonc (in the eval's files)"
{
  "agents": { "title": { "model": "google/gemini-2.5-flash" } },
  "permissions": [
    { "action": "webfetch", "resource": "*", "effect": "deny" }
  ],
  "mcp": {
    "servers": {
      "files": { "type": "local", "command": ["node", "files.mjs"] }
    }
  }
}
```

OpenCode loads `~/.config/opencode`, then the workspace's `opencode.json(c)`, then reeval's config last. With the file above, session titles still run on your cell's model (a key both set is reeval's), `files` loads beside the environment's MCP servers (objects merge, servers by name), and `webfetch` is off.

Permission rules append, the last match winning, so reeval's rules only deny: your own denies stand.

OpenCode reads `AGENTS.md`, not `CLAUDE.md`. Besides its own skill directories, it also reads `.claude/skills` and `.agents/skills` in the workspace and the home directory, and nothing turns that off, so keep other agents' skills out of an OpenCode eval's files.

## Web search

```json title="transcript.jsonl"
{"type":"web-search","toolCallId":"call_782405","query":"anomalyco opencode github","references":8,…}
```

OpenCode's `websearch` tool calls a search service it's configured with; with none, it asks the user to pick one, which in an eval ends "Web search cancelled". reeval points it at Exa's hosted MCP server (`https://mcp.exa.ai/mcp`), which answers without a key.

The search runs from the sandbox, so `mcp.exa.ai` is one of OpenCode's automatic hosts and works under `egress: 'deny-all'`.

Exa's free tier is rate-limited. OpenCode sends an Exa key as a URL parameter, which the gateway can't swap in, so reeval uses none rather than put a key in the container.

## MCP servers

```json title="transcript.jsonl"
{"type":"tool","toolCallId":"call_451616","tool":"mcp__stamp__house_stamp","input":{},"output":{"metadata":{"truncated":false},"output":"STAMP-7Q"},"ok":true,…}
```

The environment's MCP servers go in OpenCode's config (`mcp.servers`), `stdio` as `local` and `http` as `remote`, with `codemode: false`, so the model calls their tools directly and the transcript has each call's input and output. Over ACP's `session/new`, OpenCode would offer them only through Code Mode, its `execute` tool.

An `sse` server is refused at plan time (exit 2).

OpenCode connects config MCP servers in the background once the session exists. reeval runs `opencode acp` behind a small gate that holds the first prompt until each server has connected or failed (at most 30 seconds), so the first step has their tools.

## Plugins

```text title="reeval run -v"
env       plugin house → ~/.reeval/plugins/house/ (6 files; skills, agents, commands, mcp)
env       plugin part → .opencode/agents/reviewer.md (unpacked for the agent)
env       plugin part → .opencode/commands/ship.md (unpacked for the agent)
```

OpenCode loads a plugin's skills, subagents, commands and MCP servers. reeval unpacks the subagents and commands into the workspace's `.opencode/` before the snapshot, so the diff leaves them out and `context` lists them. OpenCode's own plugins (JavaScript modules) aren't Claude Code plugins and aren't used.

| Part | Where it goes |
|---|---|
| `skills/` | `~/.config/opencode/skills`, with the environment's own skills |
| `agents/<name>.md` | `.opencode/agents/<name>.md`, a subagent (`mode: subagent`) |
| `commands/<name>.md` | `.opencode/commands/<name>.md` |
| `.mcp.json` | OpenCode's config (`mcp.servers`), as `<plugin>:<server>` |

OpenCode silently skips a subagent or command whose frontmatter it doesn't take, and Claude Code's `tools: Read, Grep`, `model: sonnet` and `color` are among those, so reeval keeps only `description`:

```md title="agents/reviewer.md (in the plugin)"
---
name: reviewer
description: Reviews a change against the house style.
tools: Read, Grep
model: sonnet
---
```

```md title=".opencode/agents/reviewer.md (unpacked)"
---
description: Reviews a change against the house style.
mode: subagent
---
```

Items are flat, not namespaced, so two plugins' subagents or commands with the same name clash. A plugin's `hooks/` or `rules/` exit 2 at plan time; `only` leaves them out (see [Errors](#errors)).

## Errors

| Situation | Message |
|---|---|
| No model | `opencode(): needs a model, <provider>/<model>, e.g. opencode({ model: 'google/gemini-3.8-flash' }) (got …)` |
| A model without a provider (at plan time, exit 2) | `opencode(): an OpenCode model id names its provider, <provider>/<model>, such as 'google/gemini-3.8-flash' or 'anthropic/claude-haiku-4-5' (got "gemini-3.8-flash")` |
| A provider OpenCode doesn't know, on `direct()` (exit 2) | `evaluate("<eval>") on opencode:<model>: no gateway in the list can serve it (direct: OpenCode has no provider "…" (in "…"); a model id is <provider>/<model>, such as 'google/gemini-3.8-flash'). Add vercel() to gateway.` |
| A `vercel/…` model (exit 2) | `opencode(): a vercel/… id would bypass the config's gateway list: write the model as 'anthropic/claude-haiku-4.5' and add vercel() to gateway (got "vercel/anthropic/claude-haiku-4.5")` |
| An `openrouter/…` model (exit 2) | `opencode(): an openrouter/… id would bypass the config's gateway list: write the model as 'anthropic/claude-haiku-4.5' and add openrouter() to gateway (got "openrouter/anthropic/claude-haiku-4.5")` |
| A provider reeval refuses, on `direct()` (exit 2) | `… (direct: reeval can't run OpenCode on Vertex (google-vertex): it takes a service account (Vertex refuses API keys for most models), not a key in a header, so the gateway can't keep its key out of the sandbox). …` |
| A malformed `AWS_REGION` on Bedrock, on `direct()` (exit 2) | `… (direct: AWS_REGION is "…", which isn't one Amazon Bedrock (amazon-bedrock) takes: OpenCode builds its API's host from it, so it must match /^[a-z]{2}(-[a-z]+)+-\d{1,2}$/, such as "us-east-1"). …` |
| No key for the run's providers | `Missing credentials: ANTHROPIC_API_KEY. Set them in the environment or .env.local.` |
| A non-Docker sandbox | `The OpenCode harness needs the Docker sandbox: set sandbox: docker() …` |
| An `mcp.sse` server (at plan time, exit 2) | `evaluate("<eval>") on opencode:<model>: OpenCode has no SSE MCP transport, so it can't use the <name> server (mcp.sse): use mcp.http or mcp.stdio` |
| A plugin with hooks or rules (at plan time, exit 2) | `evaluate("<eval>") on opencode:<model>: OpenCode can't load the <plugin> plugin's rules (rules/): use only: ['skills', 'agents', 'commands', 'mcp'], or leave the plugin out of this cell` |
| OpenCode doesn't start | `OpenCode harness failed to start: …` |
| A model OpenCode's catalogue doesn't have | The turn fails with `Invalid params: model not found: <provider>/<model>` |
| A key the API rejects | The turn fails with `The API rejected GOOGLE_GENERATIVE_AI_API_KEY: set a valid key in the environment or .env.local. ACP prompt update stream failed: Internal error: API key not valid. …`, naming the provider's variable |

## Supported providers

Every provider OpenCode 2.1.4 knows whose key it sends in a header on known hosts. A provider whose models use several APIs (OpenCode Zen, ZenMux, ofox and others) has a header for each.

[//]: # (generated:opencode-providers)

| Provider | Model ids | Key | Header | Hosts |
|---|---|---|---|---|
| 302.AI | `302ai/…` | `302AI_API_KEY` | `Authorization: Bearer` | `api.302.ai` |
| Abacus | `abacus/…` | `ABACUS_API_KEY` | `Authorization: Bearer` | `routellm.abacus.ai` |
| abliteration.ai | `abliteration-ai/…` | `ABLIT_KEY` | `Authorization: Bearer` | `api.abliteration.ai` |
| above.dev | `above/…` | `ABOVE_API_KEY` | `Authorization: Bearer` | `api.above.dev` |
| AgentRouter | `agentrouter/…` | `AGENTROUTER_API_KEY` | `Authorization: Bearer`, `x-api-key` | `agentrouter.org` |
| Agnes AI | `agnes/…` | `AGNES_API_KEY` | `Authorization: Bearer` | `apihub.agnes-ai.com` |
| AI-ROUTER | `ai-router/…` | `AI_ROUTER_API_KEY` | `Authorization: Bearer` | `api.ai-router.dev` |
| AI21 Labs | `ai21/…` | `AI21_API_KEY` | `Authorization: Bearer` | `api.ai21.com` |
| ai& | `aiand/…` | `AIAND_API_KEY` | `Authorization: Bearer` | `api.aiand.com` |
| AI/ML API | `aimlapi/…` | `AIMLAPI_API_KEY` | `Authorization: Bearer` | `api.aimlapi.com` |
| ainetcafe | `ainetcafe/…` | `AINETCAFE_API_KEY` | `Authorization: Bearer` | `microquickjs.com` |
| Aixy | `aixy/…` | `AIXY_API_KEY` | `Authorization: Bearer`, `x-api-key` | `api.aixy-gateway.com` |
| AKI.IO | `aki-io/…` | `AKI_IO_API_KEY` | `Authorization: Bearer` | `aki.io` |
| Alibaba | `alibaba/…` | `DASHSCOPE_API_KEY` | `Authorization: Bearer` | `dashscope-intl.aliyuncs.com` |
| Alibaba (China) | `alibaba-cn/…` | `DASHSCOPE_API_KEY` | `Authorization: Bearer` | `dashscope.aliyuncs.com` |
| Alibaba Coding Plan | `alibaba-coding-plan/…` | `ALIBABA_CODING_PLAN_API_KEY` | `Authorization: Bearer` | `coding-intl.dashscope.aliyuncs.com` |
| Alibaba Coding Plan (China) | `alibaba-coding-plan-cn/…` | `ALIBABA_CODING_PLAN_API_KEY` | `Authorization: Bearer` | `coding.dashscope.aliyuncs.com` |
| Alibaba Token Plan | `alibaba-token-plan/…` | `ALIBABA_TOKEN_PLAN_API_KEY` | `Authorization: Bearer` | `token-plan.ap-southeast-1.maas.aliyuncs.com` |
| Alibaba Token Plan (China) | `alibaba-token-plan-cn/…` | `ALIBABA_TOKEN_PLAN_API_KEY` | `Authorization: Bearer` | `token-plan.cn-beijing.maas.aliyuncs.com` |
| Amazon Bedrock | `amazon-bedrock/…` | `AWS_BEARER_TOKEN_BEDROCK` | `Authorization: Bearer` | `bedrock-mantle.{AWS_REGION}.api.aws`, `bedrock-runtime.{AWS_REGION}.amazonaws.com` |
| Ambient | `ambient/…` | `AMBIENT_API_KEY` | `Authorization: Bearer` | `api.ambient.xyz` |
| AMD | `amd/…` | `AMD_API_KEY` | `Authorization: Bearer` | `developer.amd.com.cn` |
| Anthropic | `anthropic/…` | `ANTHROPIC_API_KEY` | `x-api-key` | `api.anthropic.com` |
| AnyAPI | `anyapi/…` | `ANYAPI_API_KEY` | `Authorization: Bearer` | `api.anyapi.ai` |
| Arcee | `arcee/…` | `ARCEE_API_KEY` | `Authorization: Bearer` | `api.arcee.ai` |
| Auriko | `auriko/…` | `AURIKO_API_KEY` | `Authorization: Bearer` | `api.auriko.ai` |
| Bailing | `bailing/…` | `BAILING_API_TOKEN` | `Authorization: Bearer` | `api.tbox.cn` |
| Baseten | `baseten/…` | `BASETEN_API_KEY` | `Authorization: Bearer` | `inference.baseten.co` |
| Bee by HEOSSI | `bee/…` | `BEE_API_KEY` | `Authorization: Bearer` | `api.bee.heossi.com` |
| Berget.AI | `berget/…` | `BERGET_API_KEY` | `Authorization: Bearer` | `api.berget.ai` |
| Blue Claw | `blueclaw/…` | `BLUECLAW_API_KEY` | `Authorization: Bearer` | `openai.blueclaw.network` |
| Bothub | `bothub/…` | `BOTHUB_API_KEY` | `Authorization: Bearer` | `openai.bothub.ru` |
| Boundless | `boundless/…` | `BOUNDLESS_API_KEY` | `Authorization: Bearer` | `api.inference.boundless.network` |
| Cerebras | `cerebras/…` | `CEREBRAS_API_KEY` | `Authorization: Bearer` | `api.cerebras.ai` |
| Chutes | `chutes/…` | `CHUTES_API_KEY` | `Authorization: Bearer` | `llm.chutes.ai` |
| Clarifai | `clarifai/…` | `CLARIFAI_PAT` | `Authorization: Bearer` | `api.clarifai.com` |
| Claudinio | `claudinio/…` | `CLAUDINIO_API_KEY` | `Authorization: Bearer` | `api.claudin.io` |
| ClinePass | `cline-pass/…` | `CLINE_API_KEY` | `Authorization: Bearer` | `api.cline.bot` |
| CloudFerro Sherlock | `cloudferro-sherlock/…` | `CLOUDFERRO_SHERLOCK_API_KEY` | `Authorization: Bearer` | `api-sherlock.cloudferro.com` |
| Cohere | `cohere/…` | `COHERE_API_KEY` | `Authorization: Bearer` | `api.cohere.ai`, `api.cohere.com` |
| CommandCode | `commandcode/…` | `CMD_API_KEY` | `Authorization: Bearer`, `x-api-key` | `api.commandcode.ai` |
| CoralBricks | `coralbricks/…` | `CORAL_API_KEY` | `Authorization: Bearer` | `inference.coralbricks.ai` |
| Cortecs | `cortecs/…` | `CORTECS_API_KEY` | `Authorization: Bearer` | `api.cortecs.ai` |
| CrossModel | `crossmodel/…` | `CROSSMODEL_API_KEY` | `Authorization: Bearer` | `api.crossmodel.ai` |
| Crusoe | `crusoe/…` | `CRUSOE_API_KEY` | `Authorization: Bearer` | `api.inference.crusoecloud.com` |
| DaoXE | `daoxe/…` | `DAOXE_API_KEY` | `Authorization: Bearer` | `daoxe.com` |
| Deep Infra | `deepinfra/…` | `DEEPINFRA_API_KEY` | `Authorization: Bearer` | `api.deepinfra.com` |
| DeepSeek | `deepseek/…` | `DEEPSEEK_API_KEY` | `Authorization: Bearer` | `api.deepseek.com` |
| DigitalOcean | `digitalocean/…` | `DIGITALOCEAN_ACCESS_TOKEN` | `Authorization: Bearer` | `inference.do-ai.run` |
| DInference | `dinference/…` | `DINFERENCE_API_KEY` | `Authorization: Bearer` | `api.dinference.com` |
| D.Run (China) | `drun/…` | `DRUN_API_KEY` | `Authorization: Bearer` | `chat.d.run` |
| EBCloud | `ebcloud/…` | `EBCLOUD_API_KEY` | `Authorization: Bearer` | `maas-api.ebcloud.com` |
| Echo | `echo/…` | `ECHO_API_KEY` | `Authorization: Bearer` | `echo.tracerml.ai` |
| Eden AI | `edenai/…` | `EDENAI_API_KEY` | `Authorization: Bearer` | `api.edenai.run` |
| EmpirioLabs AI | `empiriolabs/…` | `EMPIRIOLABS_API_KEY` | `Authorization: Bearer` | `api.empiriolabs.ai` |
| engy | `engy/…` | `ENGY_API_KEY` | `Authorization: Bearer` | `api.engy.ai` |
| evroc | `evroc/…` | `EVROC_API_KEY` | `Authorization: Bearer` | `models.think.evroc.com` |
| FastRouter | `fastrouter/…` | `FASTROUTER_API_KEY` | `Authorization: Bearer` | `go.fastrouter.ai` |
| Fireworks AI | `fireworks-ai/…` | `FIREWORKS_API_KEY` | `Authorization: Bearer` | `api.fireworks.ai` |
| FreeModel | `freemodel/…` | `FREEMODEL_API_KEY` | `x-api-key`, `Authorization: Bearer` | `api.freemodel.dev`, `cc.freemodel.dev` |
| Friendli | `friendli/…` | `FRIENDLI_TOKEN` | `Authorization: Bearer` | `api.friendli.ai` |
| FrogBot | `frogbot/…` | `FROGBOT_API_KEY` | `Authorization: Bearer` | `app.frogbot.ai` |
| GMI Cloud | `gmicloud/…` | `GMICLOUD_API_KEY` | `Authorization: Bearer` | `api.gmi-serving.com` |
| Google | `google/…` | `GOOGLE_GENERATIVE_AI_API_KEY` | `x-goog-api-key` | `generativelanguage.googleapis.com` |
| GreenPT | `greenpt/…` | `GREENPT_API_KEY` | `Authorization: Bearer` | `api.greenpt.ai` |
| Groq | `groq/…` | `GROQ_API_KEY` | `Authorization: Bearer` | `api.groq.com` |
| Helicone | `helicone/…` | `HELICONE_API_KEY` | `Authorization: Bearer` | `ai-gateway.helicone.ai` |
| Hetzner | `hetzner/…` | `HETZNER_API_KEY` | `Authorization: Bearer` | `inference.hetzner.com` |
| HPC-AI | `hpc-ai/…` | `HPC_AI_API_KEY` | `Authorization: Bearer` | `api.hpc-ai.com` |
| Hugging Face | `huggingface/…` | `HF_TOKEN` | `Authorization: Bearer` | `router.huggingface.co` |
| Charm Hyper | `hyper/…` | `HYPER_API_KEY` | `Authorization: Bearer` | `hyper.charm.land` |
| Impossibl | `impossibl/…` | `IMPOSSIBL_API_KEY` | `Authorization: Bearer` | `api.impossibl.com` |
| Inception | `inception/…` | `INCEPTION_API_KEY` | `Authorization: Bearer` | `api.inceptionlabs.ai` |
| Inceptron | `inceptron/…` | `INCEPTRON_API_KEY` | `Authorization: Bearer` | `api.inceptron.io` |
| Inco | `inco/…` | `INCO_API_KEY` | `Authorization: Bearer` | `api.inco.ai` |
| Infer by Flow7 | `infer/…` | `INFER_API_KEY` | `Authorization: Bearer` | `infer.flow7.org` |
| Inference | `inference/…` | `INFERENCE_API_KEY` | `Authorization: Bearer` | `inference.net` |
| InferX | `inferx/…` | `INFERX_API_KEY` | `Authorization: Bearer` | `model.inferx.net` |
| IO.NET | `io-net/…` | `IOINTELLIGENCE_API_KEY` | `Authorization: Bearer` | `api.intelligence.io.solutions` |
| IteraCompute | `iteracompute/…` | `ITERACOMPUTE_API_KEY` | `Authorization: Bearer` | `api.iteracompute.com` |
| Jalapeno Cloud | `jalapeno/…` | `JALAPENO_API_KEY` | `Authorization: Bearer` | `api.jalapeno-cloud.ai` |
| Jiekou.AI | `jiekou/…` | `JIEKOU_API_KEY` | `Authorization: Bearer` | `api.jiekou.ai` |
| Kenari | `kenari/…` | `KENARI_API_KEY` | `Authorization: Bearer` | `kenari.id` |
| Kilo Gateway | `kilo/…` | `KILO_API_KEY` | `Authorization: Bearer` | `api.kilo.ai` |
| Kimi For Coding (kimi.com) | `kimi-code-plan-cn/…` | `KIMI_API_KEY` | `Authorization: Bearer` | `api.kimi.com` |
| Kimi For Coding (kimi.ai) | `kimi-code-plan-global/…` | `KIMI_API_KEY` | `Authorization: Bearer` | `api.kimi.ai` |
| klokintegration.se | `klokintegration/…` | `KLOKINTEGRATION_API_KEY` | `Authorization: Bearer` | `api-gw.klok.ipaas.se` |
| Kosmik Compute | `kosmik/…` | `KOSMIK_API_KEY` | `Authorization: Bearer` | `api.koscompute.com` |
| KUAE Cloud Coding Plan | `kuae-cloud-coding-plan/…` | `KUAE_API_KEY` | `Authorization: Bearer` | `coding-plan-endpoint.kuaecloud.net` |
| Liquid Inference | `liquid/…` | `LIQUID_API_KEY` | `Authorization: Bearer` | `router.inference.ai.exchange` |
| DevPass (LLM Gateway) | `llmgateway/…` | `LLMGATEWAY_API_KEY` | `Authorization: Bearer` | `api.llmgateway.io` |
| LLM Gateway | `llmgateway-providers/…` | `LLMGATEWAY_API_KEY` | `Authorization: Bearer` | `api.llmgateway.io` |
| LLM Tech | `llmtech/…` | `LLMTECH_API_KEY` | `Authorization: Bearer` | `api.llmtech.eu` |
| LLMTR | `llmtr/…` | `LLMTR_API_KEY` | `Authorization: Bearer` | `llmtr.com` |
| LongCat | `longcat/…` | `LONGCAT_API_KEY` | `Authorization: Bearer` | `api.longcat.chat` |
| LowRouter | `lowrouter/…` | `LOWROUTER_API_KEY` | `Authorization: Bearer` | `api.lowrouter.ai` |
| LucidQuery | `lucidquery/…` | `LUCIDQUERY_API_KEY` | `Authorization: Bearer` | `api.lucidquery.com` |
| Meganova | `meganova/…` | `MEGANOVA_API_KEY` | `Authorization: Bearer` | `api.meganova.ai` |
| Melious | `melious/…` | `MELIOUS_API_KEY` | `Authorization: Bearer` | `api.melious.ai` |
| Meta | `meta/…` | `META_MODEL_API_KEY` | `Authorization: Bearer` | `api.meta.ai` |
| MiniMax (minimax.io) | `minimax/…` | `MINIMAX_API_KEY` | `Authorization: Bearer` | `api.minimax.io` |
| MiniMax (minimax.cn) | `minimax-cn/…` | `MINIMAX_API_KEY` | `Authorization: Bearer` | `api.minimax.cn` |
| MiniMax Token Plan (minimax.cn) | `minimax-cn-coding-plan/…` | `MINIMAX_API_KEY` | `Authorization: Bearer` | `api.minimax.cn` |
| MiniMax Token Plan (minimax.io) | `minimax-coding-plan/…` | `MINIMAX_API_KEY` | `Authorization: Bearer` | `api.minimax.io` |
| Mistral | `mistral/…` | `MISTRAL_API_KEY` | `Authorization: Bearer` | `api.mistral.ai` |
| Mixlayer | `mixlayer/…` | `MIXLAYER_API_KEY` | `Authorization: Bearer` | `models.mixlayer.ai` |
| Moark | `moark/…` | `MOARK_API_KEY` | `Authorization: Bearer` | `moark.com` |
| Modal | `modal/…` | `MODAL_PROXY_TOKEN` | `Authorization: Bearer` | `inference.us-west.modal.direct` |
| Model Oracle AI | `model-oracle-ai/…` | `MODEL_ORACLE_API_KEY` | `Authorization: Bearer` | `api.modeloracle.com` |
| Modelis | `modelis/…` | `MODELIS_API_KEY` | `Authorization: Bearer` | `modelishub.com` |
| ModelScope | `modelscope/…` | `MODELSCOPE_API_KEY` | `Authorization: Bearer` | `api-inference.modelscope.cn` |
| Moonshot AI | `moonshotai/…` | `MOONSHOT_API_KEY` | `Authorization: Bearer` | `api.moonshot.ai` |
| Moonshot AI (China) | `moonshotai-cn/…` | `MOONSHOT_API_KEY` | `Authorization: Bearer` | `api.moonshot.cn` |
| NaN | `nan/…` | `NAN_API_KEY` | `Authorization: Bearer` | `api.nan.builders` |
| NanoGPT | `nano-gpt/…` | `NANO_GPT_API_KEY` | `Authorization: Bearer` | `nano-gpt.com` |
| NEAR AI Cloud | `nearai/…` | `NEARAI_API_KEY` | `Authorization: Bearer` | `cloud-api.near.ai` |
| Nebius Token Factory | `nebius/…` | `NEBIUS_API_KEY` | `Authorization: Bearer` | `api.tokenfactory.nebius.com` |
| NeoSmith | `neosmith/…` | `NEOSMITH_API_KEY` | `Authorization: Bearer` | `router.neosmith.ai` |
| Neuralwatt | `neuralwatt/…` | `NEURALWATT_API_KEY` | `Authorization: Bearer` | `api.neuralwatt.com` |
| Nova | `nova/…` | `NOVA_API_KEY` | `Authorization: Bearer` | `api.nova.amazon.com` |
| Novita AI | `novita-ai/…` | `NOVITA_API_KEY` | `Authorization: Bearer` | `api.novita.ai` |
| Nvidia | `nvidia/…` | `NVIDIA_API_KEY` | `Authorization: Bearer` | `integrate.api.nvidia.com` |
| OCI Generative AI | `oci/…` | `OCI_GENAI_API_KEY` | `Authorization: Bearer` | `inference.generativeai.us-chicago-1.oci.oraclecloud.com` |
| Ofox | `ofox/…` | `OFOX_API_KEY` | `Authorization: Bearer`, `x-goog-api-key`, `x-api-key` | `api.ofox.ai` |
| Ollama Cloud | `ollama-cloud/…` | `OLLAMA_API_KEY` | `Authorization: Bearer` | `ollama.com` |
| OpenAI | `openai/…` | `OPENAI_API_KEY` | `Authorization: Bearer` | `api.openai.com` |
| OpenCode Console | `opencode/…` | `OPENCODE_API_KEY` | `Authorization: Bearer`, `x-goog-api-key`, `x-api-key` | `opencode.ai` |
| OpenCode Go | `opencode-go/…` | `OPENCODE_API_KEY` | `Authorization: Bearer`, `x-goog-api-key`, `x-api-key` | `opencode.ai` |
| OpenReason | `openreason/…` | `OPENREASON_API_KEY` | `Authorization: Bearer` | `api.openreason.app` |
| OpenRouter | `openrouter/…` | `OPENROUTER_API_KEY` | `Authorization: Bearer` | `openrouter.ai` |
| Opper | `opper/…` | `OPPER_API_KEY` | `Authorization: Bearer` | `api.opper.ai` |
| OrcaRouter | `orcarouter/…` | `ORCAROUTER_API_KEY` | `Authorization: Bearer` | `api.orcarouter.ai` |
| OVHcloud AI Endpoints | `ovhcloud/…` | `OVHCLOUD_API_KEY` | `Authorization: Bearer` | `oai.endpoints.kepler.ai.cloud.ovh.net` |
| Pareto Inference | `pareto/…` | `PARETO_API_KEY` | `Authorization: Bearer` | `api.paretoinference.com` |
| Pendra | `pendra/…` | `PENDRA_API_KEY` | `Authorization: Bearer` | `api.pendra.ai` |
| Perplexity Agent | `perplexity-agent/…` | `PERPLEXITY_API_KEY` | `Authorization: Bearer` | `api.perplexity.ai` |
| Pioneer | `pioneer/…` | `PIONEER_API_KEY` | `Authorization: Bearer` | `api.fastino.ai` |
| Poe | `poe/…` | `POE_API_KEY` | `Authorization: Bearer` | `api.poe.com` |
| Poolside | `poolside/…` | `POOLSIDE_API_KEY` | `Authorization: Bearer` | `inference.poolside.ai` |
| Prime Inference | `prime/…` | `PRIME_API_KEY` | `Authorization: Bearer` | `api.pinference.ai` |
| QiHang | `qihang-ai/…` | `QIHANG_API_KEY` | `Authorization: Bearer` | `api.qhaigc.net` |
| Qiniu | `qiniu-ai/…` | `QINIU_API_KEY` | `Authorization: Bearer` | `api.qnaigc.com` |
| Reflection | `reflection/…` | `REFLECTION_API_KEY` | `Authorization: Bearer` | `api.reflection.ai` |
| Regolo AI | `regolo-ai/…` | `REGOLO_API_KEY` | `Authorization: Bearer` | `api.regolo.ai` |
| Requesty | `requesty/…` | `REQUESTY_API_KEY` | `Authorization: Bearer` | `router.requesty.ai` |
| routing.run | `routing-run/…` | `ROUTING_RUN_API_KEY` | `Authorization: Bearer` | `api.routing.run` |
| RunInfra | `runinfra/…` | `RUNINFRA_GATEWAY_KEY` | `Authorization: Bearer` | `api.runinfra.ai` |
| Sakana AI | `sakana/…` | `SAKANA_API_KEY` | `Authorization: Bearer` | `api.sakana.ai` |
| SambaNova | `sambanova/…` | `SAMBANOVA_API_KEY` | `Authorization: Bearer` | `api.sambanova.ai` |
| Sarvam AI | `sarvam/…` | `SARVAM_API_KEY` | `Authorization: Bearer` | `api.sarvam.ai` |
| Scaleway | `scaleway/…` | `SCALEWAY_API_KEY` | `Authorization: Bearer` | `api.scaleway.ai` |
| SCNet Token Plan | `scnet-token-plan/…` | `SCNET_API_KEY` | `Authorization: Bearer` | `api.scnet.cn` |
| SCX.ai | `scx-ai/…` | `SCX_API_KEY` | `Authorization: Bearer` | `api.scx.ai` |
| SenseNova (China) | `sensenova/…` | `SENSENOVA_API_KEY` | `Authorization: Bearer` | `token.sensenova.cn` |
| SiliconFlow | `siliconflow/…` | `SILICONFLOW_API_KEY` | `Authorization: Bearer` | `api.siliconflow.com` |
| SiliconFlow (China) | `siliconflow-cn/…` | `SILICONFLOW_CN_API_KEY` | `Authorization: Bearer` | `api.siliconflow.cn` |
| STACKIT | `stackit/…` | `STACKIT_API_KEY` | `Authorization: Bearer` | `api.openai-compat.model-serving.eu01.onstackit.cloud` |
| Standard Compute | `standardcompute/…` | `STANDARDCOMPUTE_API_KEY` | `Authorization: Bearer` | `api.stdcmpt.com` |
| StepFun (China) | `stepfun/…` | `STEPFUN_API_KEY` | `Authorization: Bearer` | `api.stepfun.com` |
| StepFun (Global) | `stepfun-ai/…` | `STEPFUN_API_KEY` | `Authorization: Bearer` | `api.stepfun.ai` |
| StepFun Step Plan (Global) | `stepfun-ai-step-plan/…` | `STEPFUN_API_KEY` | `Authorization: Bearer` | `api.stepfun.ai` |
| StepFun Step Plan (China) | `stepfun-step-plan/…` | `STEPFUN_API_KEY` | `Authorization: Bearer` | `api.stepfun.com` |
| Subconscious | `subconscious/…` | `SUBCONSCIOUS_API_KEY` | `x-api-key` | `api.subconscious.dev` |
| submodel | `submodel/…` | `SUBMODEL_INSTAGEN_ACCESS_KEY` | `Authorization: Bearer` | `llm.submodel.ai` |
| Synthetic | `synthetic/…` | `SYNTHETIC_API_KEY` | `Authorization: Bearer` | `api.synthetic.new` |
| Tempr Gateway | `tempr/…` | `TEMPR_API_KEY` | `Authorization: Bearer` | `api.temprhq.io` |
| Tencent Coding Plan (China) | `tencent-coding-plan/…` | `TENCENT_CODING_PLAN_API_KEY` | `Authorization: Bearer` | `api.lkeap.cloud.tencent.com` |
| Tencent Token Plan | `tencent-token-plan/…` | `TENCENT_TOKEN_PLAN_API_KEY` | `Authorization: Bearer` | `api.lkeap.cloud.tencent.com` |
| Tencent TokenHub | `tencent-tokenhub/…` | `TENCENT_TOKENHUB_API_KEY` | `Authorization: Bearer` | `tokenhub.tencentmaas.com` |
| TensorX | `tensorx/…` | `TENSORX_API_KEY` | `Authorization: Bearer` | `api.tensorx.ai` |
| The Grid AI | `the-grid-ai/…` | `THEGRID_API_KEY` | `Authorization: Bearer` | `api.thegrid.ai` |
| Thinking Machines | `thinkingmachines/…` | `TINKER_API_KEY` | `x-api-key` | `tinker.thinkingmachines.dev` |
| Tinfoil | `tinfoil/…` | `TINFOIL_API_KEY` | `Authorization: Bearer` | `inference.tinfoil.sh` |
| Together AI | `togetherai/…` | `TOGETHER_API_KEY` | `Authorization: Bearer` | `api.together.xyz` |
| TokenGo | `tokengo/…` | `TOKENGO_API_KEY` | `Authorization: Bearer` | `api.tokengo.com` |
| TokenRouter | `tokenrouter/…` | `TOKENROUTER_API_KEY` | `Authorization: Bearer` | `api.tokenrouter.com` |
| TrustedRouter | `trustedrouter/…` | `TRUSTEDROUTER_API_KEY` | `Authorization: Bearer` | `api.trustedrouter.com` |
| Umans AI | `umans-ai/…` | `UMANS_AI_API_KEY` | `Authorization: Bearer` | `api.code.umans.ai` |
| Umans AI Coding Plan | `umans-ai-coding-plan/…` | `UMANS_AI_CODING_PLAN_API_KEY` | `Authorization: Bearer` | `api.code.umans.ai` |
| UnoRouter | `unorouter/…` | `UNOROUTER_API_KEY` | `Authorization: Bearer` | `api.unorouter.com` |
| Upstage | `upstage/…` | `UPSTAGE_API_KEY` | `Authorization: Bearer` | `api.upstage.ai` |
| Vancine | `vancine/…` | `VANCINE_API_KEY` | `Authorization: Bearer` | `vancine.com` |
| Venice AI | `venice/…` | `VENICE_API_KEY` | `Authorization: Bearer` | `api.venice.ai` |
| Vercel AI Gateway | `vercel/…` | `AI_GATEWAY_API_KEY` | `Authorization: Bearer` | `ai-gateway.vercel.sh` |
| Vispark | `vispark/…` | `VISPARK_LAB_API_KEY` | `Authorization: Bearer` | `api.lab.vispark.in` |
| Vivgrid | `vivgrid/…` | `VIVGRID_API_KEY` | `x-api-key`, `Authorization: Bearer` | `api.vivgrid.com` |
| Volcengine Ark | `volcengine/…` | `ARK_API_KEY` | `Authorization: Bearer` | `ark.cn-beijing.volces.com` |
| Volcengine Ark Coding Plan | `volcengine-coding-plan/…` | `ARK_CODING_PLAN_API_KEY` | `Authorization: Bearer` | `ark.cn-beijing.volces.com` |
| Vultr | `vultr/…` | `VULTR_API_KEY` | `Authorization: Bearer` | `api.vultrinference.com` |
| Wafer | `wafer.ai/…` | `WAFER_API_KEY` | `Authorization: Bearer` | `pass.wafer.ai` |
| Wallaby | `wallaby/…` | `WALLABY_API_KEY` | `Authorization: Bearer` | `api.wallabytoken.com` |
| CoreWeave | `wandb/…` | `WANDB_API_KEY` | `Authorization: Bearer` | `api.inference.wandb.ai` |
| xAI | `xai/…` | `XAI_API_KEY` | `Authorization: Bearer` | `api.x.ai` |
| Xiaomi | `xiaomi/…` | `XIAOMI_API_KEY` | `Authorization: Bearer` | `api.xiaomimimo.com` |
| Xiaomi Token Plan (Europe) | `xiaomi-token-plan-ams/…` | `XIAOMI_API_KEY` | `Authorization: Bearer` | `token-plan-ams.xiaomimimo.com` |
| Xiaomi Token Plan (China) | `xiaomi-token-plan-cn/…` | `XIAOMI_API_KEY` | `Authorization: Bearer` | `token-plan-cn.xiaomimimo.com` |
| Xiaomi Token Plan (Singapore) | `xiaomi-token-plan-sgp/…` | `XIAOMI_API_KEY` | `Authorization: Bearer` | `token-plan-sgp.xiaomimimo.com` |
| Xpersona | `xpersona/…` | `XPERSONA_API_KEY` | `Authorization: Bearer` | `www.xpersona.co` |
| Z.AI | `zai/…` | `ZHIPU_API_KEY` | `Authorization: Bearer` | `api.z.ai` |
| Z.AI Coding Plan | `zai-coding-plan/…` | `ZHIPU_API_KEY` | `Authorization: Bearer` | `api.z.ai` |
| Zeldoc | `zeldoc/…` | `ZELDOC_API_KEY` | `Authorization: Bearer` | `api.zeldoc.ai` |
| Zenifra | `zenifra/…` | `ZENIFRA_AI_KEY` | `Authorization: Bearer` | `ai.zenifra.com` |
| ZenMux | `zenmux/…` | `ZENMUX_API_KEY` | `x-api-key`, `Authorization: Bearer` | `zenmux.ai` |
| Zhipu AI | `zhipuai/…` | `ZHIPU_API_KEY` | `Authorization: Bearer` | `open.bigmodel.cn` |
| Zhipu AI Coding Plan | `zhipuai-coding-plan/…` | `ZHIPU_API_KEY` | `Authorization: Bearer` | `open.bigmodel.cn` |

[//]: # (/generated:opencode-providers)

## Refused providers

The providers OpenCode knows whose key the gateway can't swap in, or that can't run an agent. An eval that runs OpenCode on one exits 2 at plan time, naming the provider and the reason.

[//]: # (generated:opencode-refused)

| Provider | Model ids | Why reeval refuses it |
|---|---|---|
| AIHubMix | `aihubmix/…` | OpenCode installs its provider package from npm when it starts, so where it sends the key is unknown. |
| Atomic Chat | `atomic-chat/…` | It runs on your machine, and the sandbox can't reach the host's localhost. |
| Azure | `azure/…` | Its API host is per account (AZURE_RESOURCE_NAME), which reeval doesn't pass. |
| Cloudflare AI Gateway | `cloudflare-ai-gateway/…` | Its API host is per account (CLOUDFLARE_ACCOUNT_ID, CLOUDFLARE_GATEWAY_ID), which reeval doesn't pass. |
| Cloudflare Workers AI | `cloudflare-workers-ai/…` | Its API host is per account (CLOUDFLARE_ACCOUNT_ID), which reeval doesn't pass. |
| Databricks | `databricks/…` | Its API host is per account (DATABRICKS_HOST), which reeval doesn't pass. |
| GitHub Copilot | `github-copilot/…` | It runs on a GitHub Copilot subscription, through a GitHub login. |
| GitLab Duo | `gitlab/…` | It runs on a GitLab Duo subscription, through a GitLab login. |
| Vertex | `google-vertex/…` | It takes a service account (Vertex refuses API keys for most models), not a key in a header. |
| Infomaniak | `infomaniak/…` | Its API host is per account (INFOMANIAK_PRODUCT_ID), which reeval doesn't pass. |
| Lilac | `lilac/…` | Every one of its models is deprecated, and OpenCode runs none of them. |
| LMStudio | `lmstudio/…` | It runs on your machine, and the sandbox can't reach the host's localhost. |
| Lynkr | `lynkr/…` | It runs on your machine, and the sandbox can't reach the host's localhost. |
| Merge Gateway | `merge-gateway/…` | OpenCode installs its provider package from npm when it starts, so where it sends the key is unknown. |
| Morph | `morph/…` | None of its models can call tools, so they can't run an agent. |
| Neon | `neon/…` | Its API host is per account (NEON_AI_GATEWAY_BASE_URL), which reeval doesn't pass. |
| Perplexity | `perplexity/…` | None of its models can call tools, so they can't run an agent. |
| Privatemode AI | `privatemode-ai/…` | It runs on your machine, and the sandbox can't reach the host's localhost. |
| QVAC | `qvac/…` | OpenCode installs its provider package from npm when it starts, so where it sends the key is unknown. |
| SaladCloud AI Gateway | `salad-cloud/…` | OpenCode installs its provider package from npm when it starts, so where it sends the key is unknown. |
| SAP AI Core | `sap-ai-core/…` | Its service key is JSON that OpenCode trades for OAuth tokens. |
| Snowflake Cortex | `snowflake-cortex/…` | Its API host is per account (SNOWFLAKE_ACCOUNT), which reeval doesn't pass. |
| watsonx.ai | `watsonx/…` | OpenCode installs its provider package from npm when it starts, so where it sends the key is unknown. |

[//]: # (/generated:opencode-refused)

## Related

- [Harnesses](/guide/harnesses)
- [Secrets and egress](/guide/secrets-and-egress)
- [Transcripts](/reference/transcript)