opencode-cmd-provider 0.1.2 → 1.0.0

package/CHANGELOG.md

@@ -1,12 +1,31 @@
 # Changelog
 
+## 1.0.0 - 2026-08-16
+
+First stable release: API and behavior locked in, shipping now runs through a tag-driven pipeline.
+
+- Tag-driven release pipeline: pushing `vX.Y.Z` asserts the tag matches `package.json`, refreshes the bundled model-catalog snapshot (committing it and re-triggering itself if stale), builds, runs the full test suite, publishes to npm via OIDC trusted publishing with provenance, and creates the GitHub Release from the CHANGELOG section (ADR 0002).
+- Added the `release` skill documenting the pre-tag ritual and post-push verification; removed the run-map skill and the wayfinder-loop script.
+- Docs: spell the product name as OpenCode everywhere, list Command Code plans, credit pi-commandcode-provider, and note provenance requires a public repository.
+- The e2e test now uses the inherited PATH instead of a hardcoded home directory.
+
+## 0.1.3 - 2026-08-16
+
+Feature: zero-config install via auto-registration from a bundled model snapshot.
+
+- The plugin now bundles a snapshot of the Command Code model catalog (`src/catalog/snapshot.ts`, 55 models) and auto-registers the `commandcode` provider — npm, name, `env`, and every model — during its `config` hook. Installing the plugin is enough: all Command Code models appear in `/models` with the `[CMD]` display-name prefix, no `provider.commandcode` block or `models` map required. No network access is ever needed at runtime.
+- Declared config wins: provider-level keys are filled only when unset, declared models are never modified or removed, models that left the catalog stay usable, and `whitelist`/`blacklist` still filter auto-registered models.
+- The snapshot is regenerated from the live catalog at every release via `npm run refresh:snapshot` (`scripts/refresh-snapshot.mjs`); newly published models appear after a plugin update.
+- Deleted the now-dead network machinery: live catalog fetch and cache (`loadCommandCodeModels`, cache file), the `provider.models` hook, `catalogToOpenCodeModels`, and the `COMMANDCODE_MODELS_*` env vars.
+- `COMMANDCODE_API_BASE` now actually overrides the runtime API base (injected as `options.baseURL` when the user declares no `baseURL` of their own).
+
 ## 0.1.2 - 2026-08-15
 
-Fix: tool-call history round-trip and reasoning effort. Live probes against the Command Code API with opencode confirmed the AI SDK v3 shapes differ from what the converters expected:
+Fix: tool-call history round-trip and reasoning effort. Live probes against the Command Code API with OpenCode confirmed the AI SDK v3 shapes differ from what the converters expected:
 
 - Assistant tool-call parts carry arguments under `input`, not `args`/`arguments` — the converter read the legacy fields, so every prior tool call was re-sent with empty `{}` arguments, corrupting multi-turn context.
 - Tool-result outputs use the v3 `{ type: "text" | "error-text" | "json" | "content", ... }` shapes — `resultText` stringified the wrapper, double-encoding results in history. Replaced with `unwrapToolResult`.
-- `reasoning_effort` was silently dropped: opencode passes `providerOptions` namespaced per provider (`{ commandcode: { reasoningEffort } }`), but the model read the top-level keys. Added `resolveProviderReasoning` (namespaced + top-level fallback) so the configured thinking level actually reaches the API.
+- `reasoning_effort` was silently dropped: OpenCode passes `providerOptions` namespaced per provider (`{ commandcode: { reasoningEffort } }`), but the model read the top-level keys. Added `resolveProviderReasoning` (namespaced + top-level fallback) so the configured thinking level actually reaches the API.
 
 Also: remove duplicated README disclaimer; bump `@ai-sdk/provider` to 4.x and `@types/node` to 26.x.
 
@@ -16,9 +35,9 @@ Fix: emit `text-start`/`text-end` and `reasoning-start`/`reasoning-end` stream p
 
 ## 0.1.0 - 2026-08-15
 
-Initial release: Command Code provider + plugin for opencode. Published to npm as `opencode-cmd-provider@0.1.0` (`latest`), tagged `v0.1.0`.
+Initial release: Command Code provider + plugin for OpenCode. Published to npm as `opencode-cmd-provider@0.1.0` (`latest`), tagged `v0.1.0`.
 
-- `createCommandCode(options)` AI SDK provider (LanguageModelV3) + `default` V1 opencode plugin module in one package.
+- `createCommandCode(options)` AI SDK provider (LanguageModelV3) + `default` V1 OpenCode plugin module in one package.
 - `/connect` browser auth flow, `COMMANDCODE_API_KEY` env var, and legacy auth file support (`~/.commandcode/auth.json`, `~/.omp/agent/auth.json`, `~/.pi/agent/auth.json`).
 - Model catalog fetch, parse, and cache with offline fallback; pricing/cost display; image input; reasoning effort.
-- Config-declared `models` map required under `provider.commandcode` until `commandcode` lands in opencode's models.dev catalog.
+- Config-declared `models` map required under `provider.commandcode` until `commandcode` lands in OpenCode's models.dev catalog.

package/README.md

@@ -3,52 +3,44 @@
 [![CI](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml/badge.svg)](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/opencode-cmd-provider)](https://www.npmjs.com/package/opencode-cmd-provider)
 
-A provider and plugin for [opencode](https://opencode.ai) that connects to the [Command Code](https://commandcode.ai) Provider API.
+A provider and plugin for [OpenCode](https://opencode.ai) that connects to the [Command Code](https://commandcode.ai) Provider API. This enables you to use ALL Command Code plans — Go, GOAT, Pro, Max 10×, Max 20×, Provider, Team, and Enterprise — with OpenCode.
 
 > **Disclaimer:** This is an unofficial, community-maintained integration. It is not affiliated with, endorsed by, or supported by Command Code. You need your own Command Code account and API key or subscription. Command Code's terms, availability, and pricing apply.
 
 ## Install
 
-Add the package to your opencode configuration:
+Add the package to your OpenCode configuration:
 
 ```jsonc
 // opencode.json
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": ["opencode-cmd-provider"],
-  "provider": {
-    "commandcode": {
-      "npm": "opencode-cmd-provider",
-      "name": "Command Code",
-      "options": { "baseURL": "https://api.commandcode.ai" },
-      "models": {
-        "claude-sonnet-5": {
-          "name": "Claude Sonnet 5",
-          "limit": { "context": 200000, "output": 65536 },
-        },
-        "deepseek/deepseek-v4-flash": {
-          "name": "DeepSeek V4 Flash",
-        },
-      },
-    },
-  },
 }
 ```
 
-> **The `models` map is required, and each key must be the model's full Command
-> Code catalog ID.** opencode only fires a provider's `models` discovery hook for
-> providers already in its [models.dev](https://models.dev) catalog, and
-> `commandcode` is not in that catalog yet — so you must declare the models you
-> want. The keys are passed straight to the Command Code API, so use the exact
-> catalog IDs (some are prefixed, e.g. `deepseek/deepseek-v4-flash`,
-> `google/gemini-3.5-flash`, `xai/grok-4.5`). List the current catalog from the
-> terminal with `opencode run --model commandcode/... "hi"` after connecting, or
-> hit `https://api.commandcode.ai/provider/v1/models`. An unprefixed or wrong ID
-> fails with a `403 Model/provider not recognized` error. When `commandcode`
-> lands in the models.dev catalog, this map becomes optional and discovery works
-> via the plugin's `provider.models` hook.
-
-Start or reload opencode, then authenticate:
+That's it. The plugin bundles a snapshot of the Command Code model catalog and
+auto-registers the `commandcode` provider — npm package, name, API key env var,
+and every model — when OpenCode loads. No `provider.commandcode` block, no
+`models` map, no network access needed. All Command Code models appear in
+`/models` with the `[CMD]` display-name prefix (e.g. `[CMD] Claude Sonnet 5`) so
+they aren't confused with same-named models from other providers.
+
+You can still declare your own `provider.commandcode` entry to customize
+behavior; your declarations always win and the snapshot fills in only what's
+missing:
+
+- Declared provider-level settings (`name`, `options`, `baseURL`, `env`) are
+  kept as you wrote them.
+- Declared models stay exactly as you wrote them — the snapshot never modifies
+  or removes them, and models that left the catalog remain usable.
+- `whitelist`/`blacklist` on a declared entry filter the auto-registered models
+  too, keeping the picker uncluttered.
+
+The catalog snapshot is refreshed at every release; newly published Command
+Code models appear after a plugin update.
+
+Start or reload OpenCode, then authenticate:
 
 ```txt
 /connect
@@ -60,7 +52,7 @@ Select **Command Code**, complete the browser flow, and pick a model with `/mode
 
 ### Browser login
 
-Run `/connect` in opencode and select **Command Code**. The browser flow stores the returned credential in opencode's auth store.
+Run `/connect` in OpenCode and select **Command Code**. The browser flow stores the returned credential in OpenCode's auth store.
 
 If automatic transfer from the browser fails, copy the API key shown by Command Code and export it as `COMMANDCODE_API_KEY` (see below).
 
@@ -109,34 +101,30 @@ Pick a model with `/models`, or run non-interactively:
 opencode run --model commandcode/claude-sonnet-5 "hello"
 ```
 
-Model availability changes over time and is refreshed from the Command Code catalog when opencode loads.
-
-### Reasoning support
-
-Reasoning metadata is enriched only for models whose Command Code effort support is known. Supported levels are sent as the documented `reasoning_effort` request field; `off`, unsupported levels, and newly discovered models without metadata do not add reasoning fields to the request. No prompt instructions are injected.
-
-Reasoning blocks from completed assistant turns are not replayed to Command Code in later requests; only the user-visible text and completed tool calls are sent back as history. This prevents prior private reasoning traces from interfering with reasoning on follow-up turns.
-
 ## Model discovery and offline behavior
 
-The provider fetches the current model catalog from:
+The plugin ships a snapshot of the Command Code model catalog (`src/catalog/snapshot.ts`)
+and auto-registers every model into OpenCode's config at startup. Model
+availability changes when the package is updated: the snapshot is regenerated
+from the live catalog at every release via `npm run refresh:snapshot`.
 
-```txt
-https://api.commandcode.ai/provider/v1/models
-```
+Auto-registration adds no network latency to OpenCode startup — the snapshot is
+bundled, and the plugin never contacts the Command Code API to list models. The
+plugin works fully offline; model availability never depends on the catalog
+endpoint being reachable.
 
-The last successful catalog is cached at `<data-dir>/commandcode-models.json`, where `<data-dir>` is opencode's XDG data directory (default `~/.local/share/opencode`).
+The following environment variable is intended for tests, local mocks, and
+compatible API endpoints:
 
-If the endpoint is temporarily unavailable, the provider uses the cached catalog. On a first offline start without a cache, opencode still starts cleanly, but Command Code models remain unavailable until the connection is restored.
+| Variable               | Purpose                                |
+| ---------------------- | -------------------------------------- |
+| `COMMANDCODE_API_BASE` | Override the Command Code API base URL |
 
-The following environment variables are intended for tests, local mocks, and compatible API endpoints:
+### Reasoning support
 
-| Variable                        | Purpose                                                                                        |
-| ------------------------------- | ---------------------------------------------------------------------------------------------- |
-| `COMMANDCODE_API_BASE`          | Override the Command Code API base URL                                                         |
-| `COMMANDCODE_MODELS_URL`        | Override the model catalog endpoint                                                            |
-| `COMMANDCODE_MODELS_CACHE`      | Override the model cache file path                                                             |
-| `COMMANDCODE_MODELS_TIMEOUT_MS` | Catalog fetch timeout (defaults to 10 seconds; invalid or non-positive values use the default) |
+Reasoning metadata is enriched only for models whose Command Code effort support is known. Supported levels are sent as the documented `reasoning_effort` request field; `off`, unsupported levels, and newly discovered models without metadata do not add reasoning fields to the request. No prompt instructions are injected.
+
+Reasoning blocks from completed assistant turns are not replayed to Command Code in later requests; only the user-visible text and completed tool calls are sent back as history. This prevents prior private reasoning traces from interfering with reasoning on follow-up turns.
 
 ## Image input
 
@@ -146,13 +134,13 @@ For vision-capable models, image blocks from user messages and tool results are
 
 ## Pricing display
 
-The Command Code Provider API does not currently include prices in its model catalog. This provider keeps a static table for models with known prices so opencode can display estimated request costs.
+The Command Code Provider API does not currently include prices in its model catalog. This provider keeps a static table for models with known prices so OpenCode can display estimated request costs.
 
-Models missing from that table display zero cost in opencode. This does **not** mean Command Code will bill the request at zero. Check the current [Command Code pricing](https://commandcode.ai/docs/resources/pricing-limits) before relying on the displayed value.
+Models missing from that table display zero cost in OpenCode. This does **not** mean Command Code will bill the request at zero. Check the current [Command Code pricing](https://commandcode.ai/docs/resources/pricing-limits) before relying on the displayed value.
 
 ## Update and remove
 
-Update the installed package, or remove it from the `plugin` array and the `provider.commandcode` block in your `opencode.json`. The npm package is cached under opencode's plugin cache (`~/.cache/opencode/packages/`); remove the cached directory to fully uninstall.
+Update the installed package, or remove it from the `plugin` array in your `opencode.json` (the auto-registered `provider.commandcode` entry is injected by the plugin, so there is no config block to remove). The npm package is cached under OpenCode's plugin cache (`~/.cache/opencode/packages/`); remove the cached directory to fully uninstall.
 
 ## Development
 
@@ -165,16 +153,20 @@ npm test
 npm run format:check
 ```
 
-The headless end-to-end test runs the real opencode CLI against a mock Command Code server through the built package:
+The headless end-to-end test runs the real OpenCode CLI against a mock Command Code server through the built package:
 
 ```sh
 npm run build && npm run test:e2e
 ```
 
-`scripts/opencode-fixture.mjs` writes a throwaway `opencode.json` wiring the local build to the mock endpoints. `test:e2e` is a local dev gate (it needs the real `opencode` binary on PATH) and is excluded from `npm test`.
+`scripts/opencode-fixture.mjs` writes a throwaway `opencode.json` wiring only the local build as a plugin — no declared provider or models — so `opencode models` proves auto-registration against a real opencode binary. `test:e2e` is a local dev gate (it needs the real `opencode` binary on PATH) and is excluded from `npm test`.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup and tests. See [RELEASE.md](RELEASE.md) for the release process.
 
+## Credits
+
+Inspired by [pi-commandcode-provider](https://github.com/patlux/pi-commandcode-provider).
+
 ## License
 
 MIT

package/dist/index.js

@@ -2,6 +2,6 @@
 // Dual export: opencode's provider loader scans for the first export whose name
 // starts with "create"; its plugin loader early-returns on a V1 default module.
 // Exactly one create* export + a { id, server } default keeps both loaders safe
-// (see DESIGN.md §4). Enforced by tests/contract.test.ts.
+// (verified loader behavior; see ADR-0001). Enforced by tests/contract.test.ts.
 export { createCommandCode } from "./src/provider/index.js";
 export { default } from "./src/plugin/index.js";

package/dist/src/catalog/snapshot.d.ts

@@ -0,0 +1,6 @@
+export interface CatalogModel {
+    readonly id: string;
+    readonly name: string;
+    readonly contextLength: number;
+}
+export declare const MODEL_SNAPSHOT: readonly CatalogModel[];

package/dist/src/catalog/snapshot.js

@@ -0,0 +1,62 @@
+// src/catalog/snapshot.ts — GENERATED by scripts/refresh-snapshot.mjs. Do not edit.
+//
+// A copy of the Command Code model catalog (id, name, context length) bundled
+// in the package so the plugin can auto-register every model without network
+// access at runtime. Regenerate with `npm run refresh:snapshot`.
+export const MODEL_SNAPSHOT = [
+    { id: "claude-sonnet-5", name: "Claude Sonnet 5", contextLength: 1000000 },
+    { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", contextLength: 1000000 },
+    { id: "claude-fable-5", name: "Claude Fable 5", contextLength: 1000000 },
+    { id: "claude-opus-5", name: "Claude Opus 5", contextLength: 1000000 },
+    { id: "claude-opus-4-8", name: "Claude Opus 4.8", contextLength: 1000000 },
+    { id: "claude-opus-4-7", name: "Claude Opus 4.7", contextLength: 1000000 },
+    { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", contextLength: 200000 },
+    { id: "gpt-5.6-sol", name: "GPT-5.6 Sol", contextLength: 1050000 },
+    { id: "gpt-5.6-terra", name: "GPT-5.6 Terra", contextLength: 1050000 },
+    { id: "gpt-5.6-luna", name: "GPT-5.6 Luna", contextLength: 1050000 },
+    { id: "gpt-5.5", name: "GPT-5.5", contextLength: 200000 },
+    { id: "gpt-5.4", name: "GPT-5.4", contextLength: 400000 },
+    { id: "gpt-5.3-codex", name: "GPT-5.3 Codex", contextLength: 400000 },
+    { id: "gpt-5.4-mini", name: "GPT-5.4 Mini", contextLength: 400000 },
+    { id: "deepseek/deepseek-v4-pro", name: "DeepSeek V4 Pro (latest)", contextLength: 1000000 },
+    { id: "deepseek/deepseek-v4-flash", name: "DeepSeek V4 Flash (latest)", contextLength: 1000000 },
+    { id: "moonshotai/Kimi-K3", name: "Kimi K3", contextLength: 1000000 },
+    { id: "moonshotai/Kimi-K2.7-Code", name: "Kimi K2.7 Code", contextLength: 256000 },
+    { id: "moonshotai/Kimi-K2.7-Code-Highspeed", name: "Kimi K2.7 Code HighSpeed", contextLength: 262000 },
+    { id: "moonshotai/Kimi-K2.6", name: "Kimi K2.6", contextLength: 256000 },
+    { id: "moonshotai/Kimi-K2.5", name: "Kimi K2.5", contextLength: 256000 },
+    { id: "zai-org/GLM-5.3", name: "GLM-5.3", contextLength: 1000000 },
+    { id: "zai-org/GLM-5.2", name: "GLM-5.2", contextLength: 1000000 },
+    { id: "zai-org/GLM-5.2-Fast", name: "GLM-5.2 Fast", contextLength: 1000000 },
+    { id: "zai-org/GLM-5.1", name: "GLM-5.1", contextLength: 200000 },
+    { id: "zai-org/GLM-5", name: "GLM-5", contextLength: 200000 },
+    { id: "MiniMaxAI/MiniMax-M3", name: "MiniMax M3", contextLength: 1000000 },
+    { id: "MiniMaxAI/MiniMax-M2.7", name: "MiniMax M2.7", contextLength: 200000 },
+    { id: "MiniMaxAI/MiniMax-M2.5", name: "MiniMax M2.5", contextLength: 200000 },
+    { id: "xiaomi/mimo-v2.5-pro", name: "MiMo V2.5 Pro", contextLength: 1000000 },
+    { id: "xiaomi/mimo-v2.5", name: "MiMo V2.5", contextLength: 1000000 },
+    { id: "Qwen/Qwen3.8-Max", name: "Qwen 3.8 Max", contextLength: 1000000 },
+    { id: "Qwen/Qwen3.7-Max", name: "Qwen 3.7 Max", contextLength: 1000000 },
+    { id: "Qwen/Qwen3.7-Plus", name: "Qwen 3.7 Plus", contextLength: 1000000 },
+    { id: "Qwen/Qwen3.7-Flash", name: "Qwen 3.7 Flash", contextLength: 1000000 },
+    { id: "Qwen/Qwen3.6-Max-Preview", name: "Qwen 3.6 Max Preview", contextLength: 200000 },
+    { id: "Qwen/Qwen3.6-Plus", name: "Qwen 3.6 Plus", contextLength: 200000 },
+    { id: "stepfun/Step-3.7-Flash", name: "Step 3.7 Flash", contextLength: 256000 },
+    { id: "stepfun/Step-3.5-Flash", name: "Step 3.5 Flash", contextLength: 1000000 },
+    { id: "tencent/hy3-paid", name: "Tencent Hy3", contextLength: 262144 },
+    { id: "google/gemini-3.7-flash", name: "Gemini 3.7 Flash", contextLength: 1048576 },
+    { id: "google/gemini-3.6-flash", name: "Gemini 3.6 Flash", contextLength: 1000000 },
+    { id: "google/gemini-3.5-flash", name: "Gemini 3.5 Flash", contextLength: 1000000 },
+    { id: "google/gemini-3.5-flash-lite", name: "Gemini 3.5 Flash Lite", contextLength: 1000000 },
+    { id: "google/gemini-3.1-flash-lite", name: "Gemini 3.1 Flash Lite", contextLength: 1000000 },
+    { id: "sakana/fugu-ultra", name: "Fugu Ultra", contextLength: 1000000 },
+    { id: "nvidia/nemotron-3-ultra-550b-a55b", name: "Nemotron 3 Ultra", contextLength: 1000000 },
+    { id: "thinkingmachines/inkling", name: "Inkling", contextLength: 256000 },
+    { id: "thinkingmachines/inkling-small", name: "Inkling Small", contextLength: 1000000 },
+    { id: "poolside/laguna-s-2.1-free", name: "Laguna S 2.1", contextLength: 256000 },
+    { id: "meta/muse-spark-1.1", name: "Muse Spark 1.1", contextLength: 1048576 },
+    { id: "meta/muse-spark-1.2", name: "Muse Spark 1.2", contextLength: 1048576 },
+    { id: "meta/muse-spark-1.2-contributor", name: "Muse Spark 1.2 Contributor", contextLength: 1048576 },
+    { id: "xai/grok-4.5", name: "Grok 4.5", contextLength: 500000 },
+    { id: "xai/grok-4.6", name: "Grok 4.6", contextLength: 500000 },
+];

package/dist/src/env.d.ts

@@ -1,7 +1,2 @@
 export declare const DEFAULT_API_BASE = "https://api.commandcode.ai";
-export declare const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
-export declare const DEFAULT_MODELS_TIMEOUT_MS = 10000;
 export declare function getApiBase(env?: NodeJS.ProcessEnv): string;
-export declare function getModelsUrl(env?: NodeJS.ProcessEnv): string;
-export declare function getModelsTimeoutMs(env?: NodeJS.ProcessEnv): number;
-export declare function getDataDir(env?: NodeJS.ProcessEnv, homeDir?: () => string): string;

package/dist/src/env.js

@@ -1,24 +1,5 @@
-// src/env.ts — COMMANDCODE_* environment overrides with safe defaults (PLAN #2 Part A)
-import { homedir } from "node:os";
+// src/env.ts — COMMANDCODE_* environment overrides with safe defaults
 export const DEFAULT_API_BASE = "https://api.commandcode.ai";
-export const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
-export const DEFAULT_MODELS_TIMEOUT_MS = 10_000;
 export function getApiBase(env = process.env) {
     return env.COMMANDCODE_API_BASE ?? DEFAULT_API_BASE;
 }
-export function getModelsUrl(env = process.env) {
-    return env.COMMANDCODE_MODELS_URL ?? DEFAULT_MODELS_URL;
-}
-export function getModelsTimeoutMs(env = process.env) {
-    const raw = env.COMMANDCODE_MODELS_TIMEOUT_MS;
-    if (!raw)
-        return DEFAULT_MODELS_TIMEOUT_MS;
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MODELS_TIMEOUT_MS;
-}
-export function getDataDir(env = process.env, homeDir = homedir) {
-    const xdg = env.XDG_DATA_HOME;
-    if (xdg)
-        return xdg;
-    return `${homeDir()}/.local/share/opencode`;
-}

package/dist/src/plugin/index.js

@@ -1,12 +1,18 @@
-// src/plugin/index.ts — V1 opencode plugin module (PLAN #11)
-import { getApiBase, getModelsUrl, getModelsTimeoutMs, getDataDir } from "../env.js";
-import { loadCommandCodeModels } from "../provider/models.js";
-import { catalogToOpenCodeModels } from "./models.js";
+// src/plugin/index.ts — V1 opencode plugin module
+import { MODEL_SNAPSHOT } from "../catalog/snapshot.js";
+import { getApiBase } from "../env.js";
+import { augmentConfigCommandCodeModels, autoRegister } from "./models.js";
 import { runAuthFlow } from "./auth.js";
-import { join } from "node:path";
-import { mkdirSync } from "node:fs";
 const server = async () => {
     return {
+        config: async (config) => {
+            autoRegister(config, MODEL_SNAPSHOT, {
+                npm: "opencode-cmd-provider",
+                name: "Command Code",
+                baseURL: getApiBase(),
+            });
+            augmentConfigCommandCodeModels(config);
+        },
         auth: {
             provider: "commandcode",
             methods: [
@@ -17,23 +23,6 @@ const server = async () => {
                 },
             ],
         },
-        provider: {
-            id: "commandcode",
-            models: async () => {
-                const cacheDir = getDataDir();
-                mkdirSync(cacheDir, { recursive: true });
-                const cachePath = process.env.COMMANDCODE_MODELS_CACHE ?? join(cacheDir, "commandcode-models.json");
-                const loaded = await loadCommandCodeModels({
-                    url: getModelsUrl(),
-                    cachePath,
-                    timeoutMs: getModelsTimeoutMs(),
-                });
-                return catalogToOpenCodeModels(loaded.models, {
-                    npm: "opencode-cmd-provider",
-                    url: getApiBase(),
-                });
-            },
-        },
     };
 };
 export default { id: "commandcode", server };

package/dist/src/plugin/models.d.ts

@@ -1,7 +1,35 @@
-import type { Model } from "@opencode-ai/sdk/v2";
-import type { CommandCodeModel } from "../provider/models.js";
-export interface CatalogMappingOptions {
+import type { Config } from "@opencode-ai/sdk/v2";
+import type { CatalogModel } from "../catalog/snapshot.js";
+export interface AutoRegisterOptions {
     npm: string;
-    url: string;
+    name: string;
+    baseURL: string;
 }
-export declare function catalogToOpenCodeModels(models: readonly CommandCodeModel[], options: CatalogMappingOptions): Record<string, Model>;
+/**
+ * Registers the `commandcode` provider entry into opencode's config so every
+ * snapshot model is available without any user declaration.
+ *
+ * opencode only invokes a plugin's `provider.models` hook for providers that
+ * already exist in its models.dev catalog; `commandcode` is not in that
+ * catalog, so models reach the session through the config-declared
+ * `provider.commandcode.models` map. The `config` hook runs before opencode
+ * reads `config.provider` and honors in-place mutation (ADR-0001), which makes
+ * this the only zero-declaration mechanism available today.
+ *
+ * Pure function: takes a config and a snapshot, mutates and returns the config.
+ * Merge semantics — the user's declared entry always wins:
+ * - provider-level keys (`npm`, `name`, `env`, `options.baseURL`) are filled
+ *   only when unset;
+ * - snapshot models are added only when no declared model claims the id (by
+ *   config key or by the entry's `id`);
+ * - declared models are never modified, and declared models that left the
+ *   catalog stay usable.
+ */
+export declare function autoRegister(config: Config, snapshot: readonly CatalogModel[], options: AutoRegisterOptions): Config;
+/**
+ * Augments config-declared commandcode models with reasoning metadata and
+ * variants so opencode's `ctrl+t` can cycle reasoning effort.
+ *
+ * In-place mutation of the config object (the plugin `config` hook contract).
+ */
+export declare function augmentConfigCommandCodeModels(config: Config): void;

package/dist/src/plugin/models.js

@@ -1,50 +1,94 @@
 import { MODEL_COSTS, ZERO_MODEL_COST } from "../provider/pricing.js";
-import { isReasoningModel, thinkingMetadataForModel } from "../provider/reasoning.js";
+import { reasoningVariantsForModel } from "../provider/reasoning.js";
 import { inputModalitiesForModel } from "../provider/modalities.js";
 const DEFAULT_MAX_OUTPUT_TOKENS = 65_536;
-export function catalogToOpenCodeModels(models, options) {
-    const out = {};
-    for (const model of models) {
-        const costs = MODEL_COSTS[model.id] ?? ZERO_MODEL_COST;
-        const modalities = inputModalitiesForModel(model.id);
-        out[model.id] = {
-            id: model.id,
-            providerID: "commandcode",
-            api: { id: model.id, url: options.url, npm: options.npm },
-            name: model.name,
-            capabilities: {
-                temperature: false,
-                reasoning: isReasoningModel(model.id),
-                attachment: modalities.includes("image"),
-                toolcall: true,
-                input: {
-                    text: true,
-                    image: modalities.includes("image"),
-                    audio: false,
-                    video: false,
-                    pdf: false,
-                },
-                output: { text: true, audio: false, image: false, video: false, pdf: false },
-                interleaved: false,
-            },
-            cost: {
-                input: costs.input,
-                output: costs.output,
-                cache: { read: costs.cacheRead, write: costs.cacheWrite },
-            },
-            limit: {
-                context: model.contextWindow,
-                output: Math.min(model.contextWindow, DEFAULT_MAX_OUTPUT_TOKENS),
-            },
-            status: "active",
-            options: {
-                ...(thinkingMetadataForModel(model.id)
-                    ? { thinking: thinkingMetadataForModel(model.id) }
-                    : {}),
-            },
-            headers: {},
-            release_date: "",
-        };
+/**
+ * Registers the `commandcode` provider entry into opencode's config so every
+ * snapshot model is available without any user declaration.
+ *
+ * opencode only invokes a plugin's `provider.models` hook for providers that
+ * already exist in its models.dev catalog; `commandcode` is not in that
+ * catalog, so models reach the session through the config-declared
+ * `provider.commandcode.models` map. The `config` hook runs before opencode
+ * reads `config.provider` and honors in-place mutation (ADR-0001), which makes
+ * this the only zero-declaration mechanism available today.
+ *
+ * Pure function: takes a config and a snapshot, mutates and returns the config.
+ * Merge semantics — the user's declared entry always wins:
+ * - provider-level keys (`npm`, `name`, `env`, `options.baseURL`) are filled
+ *   only when unset;
+ * - snapshot models are added only when no declared model claims the id (by
+ *   config key or by the entry's `id`);
+ * - declared models are never modified, and declared models that left the
+ *   catalog stay usable.
+ */
+export function autoRegister(config, snapshot, options) {
+    if (snapshot.length === 0)
+        return config;
+    const provider = (config.provider ??= {});
+    const entry = (provider["commandcode"] ??= {});
+    entry.npm ??= options.npm;
+    entry.name ??= options.name;
+    entry.env ??= ["COMMANDCODE_API_KEY"];
+    entry.options ??= {};
+    entry.options.baseURL ??= options.baseURL;
+    entry.models ??= {};
+    const declaredById = new Set(Object.values(entry.models)
+        .map((model) => model?.id)
+        .filter((id) => typeof id === "string"));
+    for (const model of snapshot) {
+        if (entry.models[model.id] !== undefined || declaredById.has(model.id))
+            continue;
+        entry.models[model.id] = configModelFor(model);
     }
-    return out;
+    return config;
+}
+/**
+ * Augments config-declared commandcode models with reasoning metadata and
+ * variants so opencode's `ctrl+t` can cycle reasoning effort.
+ *
+ * In-place mutation of the config object (the plugin `config` hook contract).
+ */
+export function augmentConfigCommandCodeModels(config) {
+    const provider = config.provider?.["commandcode"];
+    if (!provider?.models)
+        return;
+    for (const [modelId, model] of Object.entries(provider.models)) {
+        if (!model)
+            continue;
+        const variants = reasoningVariantsForModel(modelId);
+        if (variants) {
+            model.reasoning = true;
+            model.variants = variants;
+        }
+    }
+}
+/**
+ * Config-schema model entry (not the SDK `Model` shape) for a snapshot model:
+ * `[CMD]`-prefixed display name, context/output limits with output capped at
+ * 65_536, and metadata enriched from the reasoning, modality, and pricing
+ * tables.
+ */
+function configModelFor(model) {
+    const variants = reasoningVariantsForModel(model.id);
+    const costs = MODEL_COSTS[model.id] ?? ZERO_MODEL_COST;
+    return {
+        name: `[CMD] ${model.name}`,
+        limit: {
+            context: model.contextLength,
+            output: Math.min(model.contextLength, DEFAULT_MAX_OUTPUT_TOKENS),
+        },
+        reasoning: variants ? true : undefined,
+        variants: variants,
+        modalities: {
+            input: [...inputModalitiesForModel(model.id)],
+        },
+        cost: {
+            input: costs.input,
+            output: costs.output,
+            cache_read: costs.cacheRead,
+            cache_write: costs.cacheWrite,
+        },
+        status: "active",
+    };
 }

package/dist/src/provider/reasoning.d.ts

@@ -20,6 +20,17 @@ export interface ThinkingMetadata {
 }
 export declare function thinkingMetadataForModel(modelId: string): ThinkingMetadata | undefined;
 export declare function isReasoningModel(modelId: string): boolean;
+/**
+ * opencode model `variants` for the Command Code model: one entry per supported
+ * reasoning effort, keyed by the effort name. Each variant carries
+ * `{ reasoningEffort: effort }`, which opencode merges into the request
+ * `providerOptions` when the user cycles reasoning with `ctrl+t`. Without a
+ * non-empty `variants` map (and `capabilities.reasoning: true`), opencode has
+ * nothing to cycle and the effort is never surfaced.
+ */
+export declare function reasoningVariantsForModel(modelId: string): Record<string, {
+    reasoningEffort: string;
+}> | undefined;
 export declare function mappedReasoningEffort(model: {
     reasoning: boolean;
     thinkingLevelMap?: Partial<Record<PiThinkingLevel, string | null>>;

package/dist/src/provider/reasoning.js

@@ -65,6 +65,20 @@ export function thinkingMetadataForModel(modelId) {
 export function isReasoningModel(modelId) {
     return MODEL_EFFORTS[modelId] !== undefined;
 }
+/**
+ * opencode model `variants` for the Command Code model: one entry per supported
+ * reasoning effort, keyed by the effort name. Each variant carries
+ * `{ reasoningEffort: effort }`, which opencode merges into the request
+ * `providerOptions` when the user cycles reasoning with `ctrl+t`. Without a
+ * non-empty `variants` map (and `capabilities.reasoning: true`), opencode has
+ * nothing to cycle and the effort is never surfaced.
+ */
+export function reasoningVariantsForModel(modelId) {
+    const efforts = MODEL_EFFORTS[modelId];
+    if (!efforts)
+        return undefined;
+    return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]));
+}
 export function mappedReasoningEffort(model, options) {
     const level = options?.reasoning;
     if (!level || level === "off" || !model.reasoning)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cmd-provider",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "Command Code provider + plugin for opencode",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,8 +17,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",
+    "refresh:snapshot": "node scripts/refresh-snapshot.mjs",
     "test": "npm run typecheck && npm run test:unit && npm run test:integration && npm run test:contract && npm run format:check",
-    "test:unit": "tsx tests/env.test.ts && tsx tests/auth-key.test.ts && tsx tests/converters.test.ts && tsx tests/stream.test.ts && tsx tests/redact.test.ts && tsx tests/cost.test.ts && tsx tests/retry.test.ts && tsx tests/reasoning.test.ts && tsx tests/modalities.test.ts && tsx tests/models.test.ts && tsx tests/oauth.test.ts && tsx tests/plugin-models.test.ts",
+    "test:unit": "tsx tests/env.test.ts && tsx tests/auth-key.test.ts && tsx tests/converters.test.ts && tsx tests/stream.test.ts && tsx tests/redact.test.ts && tsx tests/cost.test.ts && tsx tests/retry.test.ts && tsx tests/reasoning.test.ts && tsx tests/modalities.test.ts && tsx tests/snapshot.test.ts && tsx tests/refresh-snapshot.test.ts && tsx tests/oauth.test.ts && tsx tests/plugin-models.test.ts",
     "test:integration": "tsx tests/integration-do-stream.test.ts && tsx tests/integration-do-generate.test.ts",
     "test:contract": "tsx tests/contract.test.ts",
     "test:e2e": "node tests/e2e-opencode.mjs",

package/dist/src/provider/models.d.ts

@@ -1,29 +0,0 @@
-export declare const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
-export declare const DEFAULT_MODELS_TIMEOUT_MS = 10000;
-export interface CommandCodeModel {
-    id: string;
-    name: string;
-    reasoning: boolean;
-    contextWindow: number;
-    maxTokens: number;
-}
-interface FetchCommandCodeModelsOptions {
-    url?: string;
-    fetchImpl?: typeof fetch;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}
-interface LoadCommandCodeModelsOptions extends FetchCommandCodeModelsOptions {
-    cachePath: string;
-}
-export interface LoadCommandCodeModelsResult {
-    models: readonly CommandCodeModel[];
-    source: "live" | "cache" | "empty";
-    warning?: string;
-}
-export declare function getModelsTimeoutMs(env?: NodeJS.ProcessEnv): number;
-export declare function commandCodeModelsFromApiResponse(value: unknown): readonly CommandCodeModel[];
-export declare function commandCodeModelsFromCache(value: unknown): readonly CommandCodeModel[];
-export declare function fetchCommandCodeModels(options?: FetchCommandCodeModelsOptions): Promise<readonly CommandCodeModel[]>;
-export declare function loadCommandCodeModels(options: LoadCommandCodeModelsOptions): Promise<LoadCommandCodeModelsResult>;
-export {};

package/dist/src/provider/models.js

@@ -1,229 +0,0 @@
-// src/provider/models.ts — model catalog fetch, parse, cache with offline
-// fallback (PLAN #7, port of pi's models.ts)
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { isReasoningModel } from "./reasoning.js";
-export const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
-export const DEFAULT_MODELS_TIMEOUT_MS = 10_000;
-const DEFAULT_MAX_OUTPUT_TOKENS = 65_536;
-const MODEL_CACHE_VERSION = 1;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringField(record, key) {
-    const value = record[key];
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(`Expected ${key} to be a non-empty string`);
-    }
-    return value;
-}
-function booleanField(record, key) {
-    const value = record[key];
-    if (typeof value !== "boolean")
-        throw new Error(`Expected ${key} to be a boolean`);
-    return value;
-}
-function positiveNumberField(record, key) {
-    const value = record[key];
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        throw new Error(`Expected ${key} to be a positive number`);
-    }
-    return value;
-}
-function parseApiModel(value) {
-    if (!isRecord(value))
-        throw new Error("Expected model entry to be an object");
-    return {
-        id: stringField(value, "id"),
-        name: stringField(value, "name"),
-        contextLength: positiveNumberField(value, "context_length"),
-    };
-}
-function parseCachedModel(value) {
-    if (!isRecord(value))
-        throw new Error("Expected cached model entry to be an object");
-    const id = stringField(value, "id");
-    booleanField(value, "reasoning");
-    return {
-        id,
-        name: stringField(value, "name"),
-        reasoning: isReasoningModel(id),
-        contextWindow: positiveNumberField(value, "contextWindow"),
-        maxTokens: positiveNumberField(value, "maxTokens"),
-    };
-}
-function requireModels(models) {
-    if (models.length === 0)
-        throw new Error("Command Code returned an empty model catalog");
-    return models;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function abortError(reason) {
-    if (reason instanceof Error)
-        return reason;
-    return new DOMException("The operation was aborted", "AbortError");
-}
-function configuredTimeoutMs(timeoutMs) {
-    return timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs > 0
-        ? timeoutMs
-        : DEFAULT_MODELS_TIMEOUT_MS;
-}
-export function getModelsTimeoutMs(env = process.env) {
-    const raw = env.COMMANDCODE_MODELS_TIMEOUT_MS;
-    if (!raw)
-        return DEFAULT_MODELS_TIMEOUT_MS;
-    const parsed = Number(raw);
-    return configuredTimeoutMs(parsed);
-}
-class ModelDiscoveryTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super(`Command Code model discovery timed out after ${timeoutMs}ms`);
-        this.name = "ModelDiscoveryTimeoutError";
-    }
-}
-function runWithTimeout(operation, timeoutMs, externalSignal) {
-    const controller = new AbortController();
-    let timer;
-    let settled = false;
-    let onExternalAbort;
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            if (timer !== undefined)
-                clearTimeout(timer);
-            if (onExternalAbort && externalSignal) {
-                externalSignal.removeEventListener("abort", onExternalAbort);
-            }
-        };
-        const resolveOnce = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(value);
-        };
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error);
-        };
-        const abort = (reason) => {
-            const error = abortError(reason);
-            controller.abort(error);
-            rejectOnce(error);
-        };
-        if (externalSignal?.aborted) {
-            abort(externalSignal.reason);
-            return;
-        }
-        onExternalAbort = () => abort(externalSignal?.reason);
-        externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
-        timer = setTimeout(() => abort(new ModelDiscoveryTimeoutError(timeoutMs)), timeoutMs);
-        Promise.resolve()
-            .then(() => operation(controller.signal))
-            .then(resolveOnce, rejectOnce);
-    });
-}
-export function commandCodeModelsFromApiResponse(value) {
-    if (!isRecord(value))
-        throw new Error("Expected models response to be an object");
-    if (value.object !== "list")
-        throw new Error("Expected models response object to be 'list'");
-    const data = value.data;
-    if (!Array.isArray(data))
-        throw new Error("Expected models response data to be an array");
-    return data.map(parseApiModel).map((model) => ({
-        id: model.id,
-        name: `${model.name} (CC)`,
-        reasoning: isReasoningModel(model.id),
-        contextWindow: model.contextLength,
-        maxTokens: Math.min(model.contextLength, DEFAULT_MAX_OUTPUT_TOKENS),
-    }));
-}
-export function commandCodeModelsFromCache(value) {
-    if (!isRecord(value))
-        throw new Error("Expected model cache to be an object");
-    if (value.version !== MODEL_CACHE_VERSION) {
-        throw new Error(`Expected model cache version ${MODEL_CACHE_VERSION}`);
-    }
-    if (!Array.isArray(value.models))
-        throw new Error("Expected cached models to be an array");
-    return requireModels(value.models.map(parseCachedModel));
-}
-export async function fetchCommandCodeModels(options = {}) {
-    const url = options.url ?? DEFAULT_MODELS_URL;
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const body = await runWithTimeout(async (signal) => {
-        const response = await fetchImpl(url, {
-            headers: {
-                accept: "application/json",
-            },
-            signal,
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch Command Code models: ${response.status} ${response.statusText}`);
-        }
-        return await response.json();
-    }, configuredTimeoutMs(options.timeoutMs), options.signal);
-    return requireModels(commandCodeModelsFromApiResponse(body));
-}
-async function readCommandCodeModelsCache(cachePath) {
-    const contents = await readFile(cachePath, "utf-8");
-    const parsed = JSON.parse(contents);
-    return commandCodeModelsFromCache(parsed);
-}
-async function writeCommandCodeModelsCache(cachePath, models) {
-    await mkdir(dirname(cachePath), { recursive: true });
-    const temporaryPath = `${cachePath}.${process.pid}.tmp`;
-    try {
-        await writeFile(temporaryPath, `${JSON.stringify({ version: MODEL_CACHE_VERSION, models }, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
-        await rename(temporaryPath, cachePath);
-    }
-    finally {
-        try {
-            await rm(temporaryPath, { force: true });
-        }
-        catch {
-            // Best-effort cleanup must not hide the original cache write error.
-        }
-    }
-}
-export async function loadCommandCodeModels(options) {
-    const cachePath = options.cachePath;
-    try {
-        const models = await fetchCommandCodeModels(options);
-        try {
-            await writeCommandCodeModelsCache(cachePath, models);
-            return { models, source: "live" };
-        }
-        catch (error) {
-            return {
-                models,
-                source: "live",
-                warning: `Loaded the live Command Code model catalog but could not update ${cachePath}: ${errorMessage(error)}`,
-            };
-        }
-    }
-    catch (liveError) {
-        if (options.signal?.aborted)
-            throw abortError(options.signal.reason ?? liveError);
-        try {
-            const models = await readCommandCodeModelsCache(cachePath);
-            return {
-                models,
-                source: "cache",
-                warning: `Could not refresh the Command Code model catalog (${errorMessage(liveError)}). Using the cached catalog from ${cachePath}.`,
-            };
-        }
-        catch (cacheError) {
-            return {
-                models: [],
-                source: "empty",
-                warning: `Could not refresh the Command Code model catalog (${errorMessage(liveError)}), and no valid cached catalog is available at ${cachePath} (${errorMessage(cacheError)}). Command Code models will remain unavailable until /commandcode-refresh succeeds.`,
-            };
-        }
-    }
-}