opencode-cmd-provider 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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:

package/README.md

@@ -16,37 +16,29 @@ Add the package to your opencode configuration:
 {
   "$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.
+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:
 
@@ -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
+
+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.
 
-| 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 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
 
@@ -152,7 +140,7 @@ Models missing from that table display zero cost in opencode. This does **not**
 
 ## 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
 
@@ -171,7 +159,7 @@ The headless end-to-end test runs the real opencode CLI against a mock Command C
 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.
 

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": "0.1.3",
   "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.`,
-            };
-        }
-    }
-}