@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/__tests__/provider-model-discovery.test.js

@@ -0,0 +1,1071 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { collapseCursorDiscoveredModelIds } from "@alan-ai/shared/runtime-discovered-models";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as cli from "../cli-executable.js";
+import { applyZenEntitlement, discoverProviderModelDetails, discoverProviderModels, extractClaudeModelIdsFromExecutable, extractCodexDiscoveredModelIdsFromDebugJson, extractCodexModelSlugsFromDebugJson, extractGrokModelIdsFromModelsOutput, extractModelIdsFromJson, extractModelIdsFromLabeledList, extractOpenCodeDiscoveredModelIdsFromVerboseOutput, extractOpenCodeModelBillingFromVerboseOutput, extractOpenCodeModelCapabilitiesFromVerboseOutput, filterClaudeDatedModelIds, filterClaudePrefixModelIds, getCatalogModelIds, isValidClaudeModelId, readConfiguredOpenCodeProviders, } from "../provider-model-discovery.js";
+// Captured from a live `grok models` run against grok 1.0.3 (2026-08-14).
+const GROK_MODELS_FIXTURE = `You are logged in with grok.com.
+
+Default model: grok-4.6
+
+Available models:
+  * grok-4.6 (default)
+  - grok-4.5
+`;
+// big-pickle and deepseek-v4-flash-free blocks are trimmed but otherwise verbatim
+// captures from a real `opencode models --verbose` (opencode 1.17.18) run — see
+// notes/opencode-cli-reverse-engineering.md. some-non-reasoning-model is synthetic
+// (no reasoning:false model was visible in the live capture, only free zen models
+// were) but follows the exact same schema, to cover the "skip entirely" path.
+const OPENCODE_VERBOSE_FIXTURE = `opencode/big-pickle
+{
+  "id": "big-pickle",
+  "providerID": "opencode",
+  "name": "Big Pickle",
+  "capabilities": {
+    "temperature": true,
+    "reasoning": true,
+    "attachment": false,
+    "toolcall": true
+  },
+  "release_date": "2025-10-17",
+  "variants": {}
+}
+opencode/deepseek-v4-flash-free
+{
+  "id": "deepseek-v4-flash-free",
+  "providerID": "opencode",
+  "name": "DeepSeek V4 Flash Free",
+  "capabilities": {
+    "temperature": true,
+    "reasoning": true,
+    "attachment": false,
+    "toolcall": true
+  },
+  "release_date": "2026-04-24",
+  "variants": {
+    "low": { "reasoningEffort": "low" },
+    "medium": { "reasoningEffort": "medium" },
+    "high": { "reasoningEffort": "high" },
+    "max": { "reasoningEffort": "max" }
+  }
+}
+opencode/some-non-reasoning-model
+{
+  "id": "some-non-reasoning-model",
+  "providerID": "opencode",
+  "name": "Some Non Reasoning Model",
+  "capabilities": {
+    "temperature": true,
+    "reasoning": false,
+    "attachment": false,
+    "toolcall": true
+  },
+  "release_date": "2026-01-01",
+  "variants": {}
+}
+`;
+/**
+ * Discovery also hydrates missing metadata from `$XDG_CACHE_HOME/opencode/models.json`.
+ * Passing an empty env would fall back to `~/.cache`, so on a machine that has actually
+ * run opencode these tests would read the developer's real 94-model catalogue and their
+ * exact-equality assertions would depend on whoever ran them. Point every case at a
+ * directory that does not exist.
+ */
+const NO_CACHE_ENV = { XDG_CACHE_HOME: join(tmpdir(), `opencode-no-cache-${randomUUID()}`) };
+// OpenCode discovery also asks Zen which models the credential can dispatch. Default
+// every test to offline so the CLI-scan cases assert the raw scan and no test can
+// silently depend on opencode.ai; the entitlement cases stub `fetch` explicitly.
+beforeEach(() => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe("provider-model-discovery", () => {
+    it("extracts model ids from JSON arrays and envelopes", () => {
+        expect(extractModelIdsFromJson([{ id: "gpt-5.5" }, { model: "claude-sonnet-5" }])).toEqual([
+            "gpt-5.5",
+            "claude-sonnet-5",
+        ]);
+        expect(extractModelIdsFromJson({ models: [{ id: "opencode/big-pickle" }] })).toEqual([
+            "opencode/big-pickle",
+        ]);
+    });
+    it("keeps OpenCode model ids separate from their native variants", () => {
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(OPENCODE_VERBOSE_FIXTURE)).toEqual([
+            "opencode/big-pickle",
+            "opencode/deepseek-v4-flash-free",
+            "opencode/some-non-reasoning-model",
+        ]);
+    });
+    it("reads OpenCode billing from live cost data, not model names", () => {
+        const text = [
+            "opencode/big-pickle",
+            "{",
+            '  "cost": { "input": 0, "output": 0 },',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": {}',
+            "}",
+            "opencode/future-model-without-a-free-suffix",
+            "{",
+            '  "cost": { "input": 0.25, "output": 0.5 },',
+            '  "capabilities": { "reasoning": false },',
+            '  "variants": {}',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeModelBillingFromVerboseOutput(text)).toEqual({
+            "opencode/big-pickle": "free",
+            "opencode/future-model-without-a-free-suffix": "paid",
+        });
+    });
+    it("carries verbose OpenCode billing alongside the discovered ids", async () => {
+        const probe = vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: [
+                "opencode/big-pickle",
+                "{",
+                '  "cost": { "input": 0, "output": 0 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": { "none": {}, "extended-thinking": {} }',
+                "}",
+            ].join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+        try {
+            await expect(discoverProviderModelDetails("opencode_cli", "/bin/opencode", NO_CACHE_ENV)).resolves.toEqual({
+                models: ["opencode/big-pickle"],
+                modelVariants: { "opencode/big-pickle": ["none", "extended-thinking"] },
+                modelBilling: { "opencode/big-pickle": "free" },
+            });
+        }
+        finally {
+            probe.mockRestore();
+        }
+    });
+    it("is not confused by a brace inside a JSON string value", () => {
+        const text = [
+            "opencode/weird-name",
+            "{",
+            '  "id": "weird-name",',
+            '  "name": "Uses a { brace } in its name",',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "high": { "reasoningEffort": "high" } }',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text)).toEqual([
+            "opencode/weird-name",
+        ]);
+        expect(extractOpenCodeModelCapabilitiesFromVerboseOutput(text)).toEqual([
+            { id: "opencode/weird-name", variants: ["high"] },
+        ]);
+    });
+    it("retains a provider-defined variant without corrupting the base id", () => {
+        const text = [
+            "opencode/future-model",
+            "{",
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "extreme": { "reasoningEffort": "extreme" } }',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text)).toEqual([
+            "opencode/future-model",
+        ]);
+        expect(extractOpenCodeModelCapabilitiesFromVerboseOutput(text)).toEqual([
+            { id: "opencode/future-model", variants: ["extreme"] },
+        ]);
+    });
+    it("parses codex debug models JSON slugs", () => {
+        expect(extractCodexModelSlugsFromDebugJson({
+            models: [
+                { slug: "gpt-5.5", visibility: "list" },
+                { slug: "codex-auto-review", visibility: "hidden" },
+                { slug: "gpt-5.4-mini", visibility: "hide" },
+            ],
+        })).toEqual(["gpt-5.5"]);
+    });
+    it("expands codex supported reasoning levels into effort-suffixed scan ids", () => {
+        expect(extractCodexDiscoveredModelIdsFromDebugJson({
+            models: [
+                {
+                    slug: "gpt-5.6-sol",
+                    visibility: "list",
+                    supported_reasoning_levels: [
+                        { effort: "low" },
+                        { effort: "medium" },
+                        { effort: "high" },
+                        { effort: "xhigh" },
+                        { effort: "max" },
+                        { effort: "ultra" },
+                    ],
+                },
+                {
+                    slug: "gpt-5.6-luna",
+                    visibility: "list",
+                    supported_reasoning_levels: [{ effort: "low" }, { effort: "high" }],
+                },
+            ],
+        })).toEqual([
+            "gpt-5.6-sol-low",
+            "gpt-5.6-sol-medium",
+            "gpt-5.6-sol-high",
+            "gpt-5.6-sol-xhigh",
+            "gpt-5.6-sol-max",
+            "gpt-5.6-sol-ultra",
+            "gpt-5.6-luna-low",
+            "gpt-5.6-luna-high",
+        ]);
+    });
+    it("parses cursor-agent style labeled model lists", () => {
+        const stdout = [
+            "Available models",
+            "",
+            "auto - Auto (current, default)",
+            "gpt-5.3-codex - Codex 5.3",
+            "composer-2.5-fast - Composer 2.5 Fast",
+            "Tip: use --model <id> to switch.",
+        ].join("\n");
+        expect(extractModelIdsFromLabeledList(stdout)).toEqual([
+            "auto",
+            "gpt-5.3-codex",
+            "composer-2.5-fast",
+        ]);
+    });
+    it("parses grok models text without treating the login banner as a model id", () => {
+        expect(extractGrokModelIdsFromModelsOutput(GROK_MODELS_FIXTURE)).toEqual([
+            "grok-4.6",
+            "grok-4.5",
+        ]);
+    });
+    it("falls back to Default model when the bullet list is missing", () => {
+        expect(extractGrokModelIdsFromModelsOutput("You are logged in with grok.com.\n\nDefault model: grok-4.6\n")).toEqual(["grok-4.6"]);
+    });
+    it("parses tab-separated agy model rows without keeping display labels", () => {
+        const stdout = [
+            "Fetching available models...",
+            "gemini-3.6-flash-high\tGemini 3.6 Flash (High)",
+            "claude-sonnet-4-6\tClaude Sonnet 4.6 (Thinking)",
+        ].join("\n");
+        expect(extractModelIdsFromLabeledList(stdout)).toEqual([
+            "gemini-3.6-flash-high",
+            "claude-sonnet-4-6",
+        ]);
+    });
+    it("drops short claude id prefixes when a longer sibling exists", () => {
+        expect(filterClaudePrefixModelIds(["claude-opus-4", "claude-opus-4-6", "claude-sonnet-4-6"])).toEqual(["claude-opus-4-6", "claude-sonnet-4-6"]);
+    });
+    it("rejects invalid claude scrape tokens", () => {
+        expect(isValidClaudeModelId("claude-fable-5.md")).toBe(false);
+        expect(isValidClaudeModelId("claude-sonnet-4.6")).toBe(false);
+        expect(isValidClaudeModelId("claude-opus-4-6-20251101")).toBe(false);
+        expect(isValidClaudeModelId("claude-opus-4-8")).toBe(true);
+        expect(isValidClaudeModelId("sonnet")).toBe(true);
+    });
+    it("rejects internal binary codenames scraped across hyphens", () => {
+        // The greedy scrape regex ran into an internal string in the Claude binary and
+        // produced "claude-fable-5-mythos-5", which then evicted the real "claude-fable-5".
+        expect(isValidClaudeModelId("claude-fable-5-mythos-5")).toBe(false);
+        // Known non-numeric qualifiers stay valid.
+        expect(isValidClaudeModelId("claude-opus-4-6-fast")).toBe(true);
+        expect(isValidClaudeModelId("claude-sonnet-5-thinking")).toBe(true);
+        // A real base model survives.
+        expect(isValidClaudeModelId("claude-fable-5")).toBe(true);
+    });
+    it("never evicts a curated catalogue id via the prefix filter", () => {
+        // Even if a bogus longer sibling slips through, a shipped catalogue model must remain.
+        const result = filterClaudePrefixModelIds(["claude-fable-5", "claude-fable-5-mythos-5"]);
+        expect(result).toContain("claude-fable-5");
+    });
+    it("drops dated claude ids when an undated sibling exists", () => {
+        expect(filterClaudeDatedModelIds([
+            "claude-opus-4-6",
+            "claude-opus-4-6-20251101",
+            "claude-sonnet-4-5-20250929",
+        ])).toEqual(["claude-opus-4-6", "claude-sonnet-4-5-20250929"]);
+    });
+    it("extracts claude model ids embedded in the executable", () => {
+        const tmp = join(tmpdir(), `claude-exe-${randomUUID()}`);
+        writeFileSync(tmp, Buffer.from("prefix claude-sonnet-4-6 middle claude-opus-4 claude-opus-4-8 claude-fable-5.md suffix", "latin1"));
+        try {
+            expect(extractClaudeModelIdsFromExecutable(tmp)).toEqual(expect.arrayContaining([
+                "claude-sonnet-4-6",
+                "claude-opus-4-8",
+                "sonnet",
+                "opus",
+                "haiku",
+                "fable",
+            ]));
+            expect(extractClaudeModelIdsFromExecutable(tmp)).not.toEqual(expect.arrayContaining(["claude-fable-5.md", "claude-opus-4"]));
+        }
+        finally {
+            unlinkSync(tmp);
+        }
+    });
+    it("returns seed catalog ids for known providers", () => {
+        expect(getCatalogModelIds("claude_cli")).toEqual([""]);
+        expect(getCatalogModelIds("codex_app_server")).toEqual([]);
+        expect(getCatalogModelIds("antigravity_cli")).toEqual([""]);
+        expect(getCatalogModelIds("droid_cli").length).toBeGreaterThan(0);
+        expect(getCatalogModelIds("copilot_cli").length).toBeGreaterThan(0);
+    });
+});
+describe("discoverProviderModels droid", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("uses catalog models without probing the interactive TUI", async () => {
+        const probe = vi.spyOn(cli, "runCliProbeAsync");
+        const models = await discoverProviderModels("droid_cli", "/bin/droid", {});
+        expect(models).toEqual(getCatalogModelIds("droid_cli"));
+        expect(probe).not.toHaveBeenCalled();
+    });
+});
+describe("discoverProviderModels copilot", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("uses catalog models without probing — Copilot CLI 1.0.75 has no non-interactive model list", async () => {
+        const probe = vi.spyOn(cli, "runCliProbeAsync");
+        const models = await discoverProviderModels("copilot_cli", "/opt/homebrew/bin/copilot", {});
+        expect(models).toEqual(getCatalogModelIds("copilot_cli"));
+        expect(probe).not.toHaveBeenCalled();
+    });
+});
+describe("discoverProviderModels", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("probes codex debug models and expands reasoning levels for effort merge", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: JSON.stringify({
+                models: [
+                    {
+                        slug: "gpt-5.6-sol",
+                        visibility: "list",
+                        supported_reasoning_levels: [{ effort: "low" }, { effort: "high" }],
+                    },
+                    { slug: "gpt-5.3-codex-spark", visibility: "list" },
+                ],
+            }),
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("codex_app_server", "/bin/codex", {});
+        expect(models).toEqual(["gpt-5.6-sol-low", "gpt-5.6-sol-high", "gpt-5.3-codex-spark"]);
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/codex", expect.objectContaining({ TERM: "xterm-256color" }), ["debug", "models"], 8_000, { maxOutputChars: 1024 * 1024 });
+    });
+    it("does not offer a truncated Codex JSON document as a model", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: `{"models":[{"slug":"gpt-5.6-sol","description":"${"x".repeat(200)}`,
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("codex_app_server", "/bin/codex", {});
+        expect(models).toEqual(getCatalogModelIds("codex_app_server"));
+    });
+    it("probes antigravity with stdin closed", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: [
+                "gemini-3.6-flash-medium\tGemini 3.6 Flash (Medium)",
+                "claude-sonnet-4-6\tClaude Sonnet 4.6 (Thinking)",
+            ].join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("antigravity_cli", "/bin/agy", {});
+        expect(models).toEqual(["gemini-3.6-flash-medium", "claude-sonnet-4-6"]);
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/agy", expect.any(Object), ["models"], 12_000, { closeStdin: true });
+    });
+    it("probes opencode models --verbose and returns dispatchable base ids", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: OPENCODE_VERBOSE_FIXTURE,
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(models).toEqual([
+            "opencode/big-pickle",
+            "opencode/deepseek-v4-flash-free",
+            "opencode/some-non-reasoning-model",
+        ]);
+        // The real working command — NOT the `--json`/`list --json` shapes this backend
+        // used to (wrongly) probe, which exit 1 against the real CLI.
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/opencode", expect.any(Object), ["models", "--verbose"], 8_000);
+    });
+    it("reuses the OpenCode model scan for opencode_serve", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: OPENCODE_VERBOSE_FIXTURE,
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("opencode_serve", "/bin/opencode", NO_CACHE_ENV);
+        expect(models).toEqual(expect.arrayContaining(["opencode/big-pickle"]));
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/opencode", expect.any(Object), ["models", "--verbose"], 8_000);
+    });
+    it("falls back to the static OpenCode catalog when the CLI probe fails entirely", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 1,
+            stdout: "",
+            stderr: "unknown flag",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(models.length).toBeGreaterThan(0);
+        expect(models).toEqual(expect.arrayContaining(["opencode/big-pickle"]));
+    });
+    it("probes grok models text and returns live ids including grok-4.6", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: GROK_MODELS_FIXTURE,
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("grok_cli", "/bin/grok", {});
+        expect(models).toEqual(["grok-4.6", "grok-4.5"]);
+        // Real command only — `models --json` is not supported by grok 1.0.3.
+        expect(cli.runCliProbeAsync).toHaveBeenCalledTimes(1);
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/grok", expect.objectContaining({ TERM: "xterm-256color" }), ["models"], 8_000);
+    });
+    it("falls back to the static Grok catalog when the CLI probe fails", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 1,
+            stdout: "",
+            stderr: "not logged in",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("grok_cli", "/bin/grok", {});
+        expect(models).toEqual(getCatalogModelIds("grok_cli"));
+        expect(models).toEqual(expect.arrayContaining(["grok-4.6", "grok-4.5"]));
+    });
+    it("falls back to executable scrape when claude CLI has no model list", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 1,
+            stdout: "",
+            stderr: "unknown option",
+            error: undefined,
+        });
+        const tmp = join(tmpdir(), `claude-exe-${randomUUID()}`);
+        writeFileSync(tmp, Buffer.from("claude-sonnet-4-6 claude-opus-4-8", "latin1"));
+        try {
+            const models = await discoverProviderModels("claude_cli", tmp, {});
+            expect(models).toEqual(expect.arrayContaining(["claude-sonnet-4-6", "claude-opus-4-8", "sonnet", "opus"]));
+        }
+        finally {
+            unlinkSync(tmp);
+        }
+    });
+    it("returns raw cursor-agent models without collapsing at discovery time", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: [
+                "gpt-5.3-codex-low - Codex 5.3 Low",
+                "gpt-5.3-codex-high - Codex 5.3 High",
+                "composer-2.5-fast - Composer 2.5 Fast",
+            ].join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("cursor_agent_cli", "/bin/cursor-agent", {});
+        expect(models).toEqual(["gpt-5.3-codex-low", "gpt-5.3-codex-high", "composer-2.5-fast"]);
+        expect(models).not.toEqual(collapseCursorDiscoveredModelIds([
+            "gpt-5.3-codex-low",
+            "gpt-5.3-codex-high",
+            "composer-2.5-fast",
+        ]));
+    });
+    it("carries every model's native variants from the verbose scan", async () => {
+        const fixture = [
+            "opencode/big-pickle",
+            "{",
+            '  "id": "big-pickle",',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": {}',
+            "}",
+            "opencode/deepseek-v4-flash-free",
+            "{",
+            '  "id": "deepseek-v4-flash-free",',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "high": { "reasoningEffort": "high" }, "max": { "reasoningEffort": "max" } }',
+            "}",
+            "opencode/north-mini-code-free",
+            "{",
+            '  "id": "north-mini-code-free",',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "none": {}, "high": {} }',
+            "}",
+            "opencode/claude-sonnet-5",
+            "{",
+            '  "id": "claude-sonnet-5",',
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "low": {}, "medium": {}, "high": {} }',
+            "}",
+        ].join("\n");
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: fixture,
+            stderr: "",
+            error: undefined,
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery).toEqual({
+            models: [
+                "opencode/big-pickle",
+                "opencode/deepseek-v4-flash-free",
+                "opencode/north-mini-code-free",
+                "opencode/claude-sonnet-5",
+            ],
+            modelVariants: {
+                "opencode/big-pickle": [],
+                "opencode/deepseek-v4-flash-free": ["high", "max"],
+                "opencode/north-mini-code-free": ["none", "high"],
+                "opencode/claude-sonnet-5": ["low", "medium", "high"],
+            },
+        });
+        expect(cli.runCliProbeAsync).toHaveBeenCalledWith("/bin/opencode", expect.any(Object), ["models", "--verbose"], 8_000);
+    });
+    it("falls back to the static OpenCode catalog when the CLI probe fails entirely", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 1,
+            stdout: "",
+            stderr: "unknown flag",
+            error: undefined,
+        });
+        const models = await discoverProviderModels("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(models.length).toBeGreaterThan(0);
+        expect(models).toEqual(expect.arrayContaining(["opencode/big-pickle"]));
+    });
+});
+describe("extractOpenCodeDiscoveredModelIdsFromVerboseOutput", () => {
+    it("retains provider-defined variants in the structured capability result", () => {
+        const capabilities = extractOpenCodeModelCapabilitiesFromVerboseOutput([
+            "opencode/custom-model",
+            "{",
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "extended-thinking": {}, "vendor_x": {} }',
+            "}",
+        ].join("\n"));
+        expect(capabilities).toEqual([
+            { id: "opencode/custom-model", variants: ["extended-thinking", "vendor_x"] },
+        ]);
+    });
+    it("does not encode reasoning variants into model ids", () => {
+        const text = [
+            "opencode/deepseek-v4-flash-free",
+            "{",
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "high": {}, "max": {} }',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text)).toEqual([
+            "opencode/deepseek-v4-flash-free",
+        ]);
+    });
+    it("emits bare id for reasoning model with no recognized variants", () => {
+        const text = [
+            "opencode/big-pickle",
+            "{",
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": {}',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text)).toEqual([
+            "opencode/big-pickle",
+        ]);
+    });
+    it("emits bare id for non-reasoning model (no variants emitted)", () => {
+        const text = [
+            "opencode/some-model",
+            "{",
+            '  "capabilities": { "reasoning": false },',
+            '  "variants": { "high": {} }',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text)).toEqual([
+            "opencode/some-model",
+        ]);
+    });
+    it("preserves OpenCode's none variant instead of renaming it minimal", () => {
+        const text = [
+            "opencode/north-mini-code-free",
+            "{",
+            '  "capabilities": { "reasoning": true },',
+            '  "variants": { "none": {}, "high": {} }',
+            "}",
+        ].join("\n");
+        expect(extractOpenCodeModelCapabilitiesFromVerboseOutput(text)).toEqual([
+            { id: "opencode/north-mini-code-free", variants: ["none", "high"] },
+        ]);
+    });
+});
+// Live evidence (2026-09-01, opencode 1.18.23): `opencode models opencode` lists 61
+// models for a key whose workspace has no payment method, while Zen's own
+// GET /zen/v1/models returns 5 for that same key. The other 56 answer
+// `401 CreditsError` on dispatch — the catalogue is not the entitlement.
+describe("OpenCode Zen entitlement", () => {
+    const zenResponse = (ids) => ({ ok: true, json: async () => ({ data: ids.map((id) => ({ id })) }) });
+    const scan = (stdout) => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout,
+            stderr: "",
+            error: undefined,
+        });
+    };
+    const verbose = (ids) => ids
+        .map((id) => [
+        id,
+        "{",
+        `  "id": "${id.split("/").slice(1).join("/")}",`,
+        '  "cost": { "input": 0, "output": 0 },',
+        '  "capabilities": { "reasoning": true },',
+        '  "variants": { "high": {} }',
+        "}",
+    ].join("\n"))
+        .join("\n");
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("drops scanned Zen models the credential cannot dispatch", () => {
+        expect(applyZenEntitlement({ models: ["opencode/big-pickle", "opencode/claude-opus-5"] }, new Set(["big-pickle"]))).toEqual({
+            models: ["opencode/big-pickle"],
+            catalogModels: ["opencode/big-pickle", "opencode/claude-opus-5"],
+        });
+    });
+    // opencode-go's list endpoint returns the same 33 models with and without a key, and
+    // BYOK ids belong to the user's own provider credentials — neither is Zen's to filter.
+    it("leaves opencode-go and BYOK namespaces untouched", () => {
+        expect(applyZenEntitlement({
+            models: ["opencode-go/glm-5.3", "anthropic/claude-opus-5", "opencode/claude-opus-5"],
+            modelVariants: { "opencode-go/glm-5.3": ["low", "high", "max"] },
+        }, new Set(["big-pickle"]))).toEqual({
+            models: ["opencode-go/glm-5.3", "anthropic/claude-opus-5", "opencode/big-pickle"],
+            catalogModels: [
+                "opencode-go/glm-5.3",
+                "anthropic/claude-opus-5",
+                "opencode/claude-opus-5",
+                "opencode/big-pickle",
+            ],
+            modelVariants: { "opencode-go/glm-5.3": ["low", "high", "max"] },
+        });
+    });
+    // `opencode/laguna-s-2.1-free` dispatches on a free key yet never appears in
+    // `opencode models --verbose`, so intersecting would hide a model that works.
+    it("adds back an entitled model the CLI scan never reported", () => {
+        const merged = applyZenEntitlement({ models: ["opencode/big-pickle"], modelBilling: { "opencode/big-pickle": "free" } }, new Set(["big-pickle", "laguna-s-2.1-free"]));
+        expect(merged.models).toEqual(["opencode/big-pickle", "opencode/laguna-s-2.1-free"]);
+        expect(merged.modelBilling).toEqual({ "opencode/big-pickle": "free" });
+    });
+    // The shared catalogue is fed from catalogModels, so a key entitled to 1 of 2 models
+    // must still report both — otherwise one unpaid key shrinks the catalogue for everyone.
+    it("keeps the unfiltered list and its metadata for the catalogue feed", () => {
+        expect(applyZenEntitlement({
+            models: ["opencode/big-pickle", "opencode/claude-opus-5"],
+            modelVariants: { "opencode/big-pickle": ["high"], "opencode/claude-opus-5": ["max"] },
+            modelBilling: { "opencode/big-pickle": "free", "opencode/claude-opus-5": "paid" },
+        }, new Set(["big-pickle"]))).toEqual({
+            models: ["opencode/big-pickle"],
+            catalogModels: ["opencode/big-pickle", "opencode/claude-opus-5"],
+            modelVariants: { "opencode/big-pickle": ["high"], "opencode/claude-opus-5": ["max"] },
+            modelBilling: { "opencode/big-pickle": "free", "opencode/claude-opus-5": "paid" },
+        });
+    });
+    it("carries an entitled-but-unscanned model into the catalogue feed too", () => {
+        expect(applyZenEntitlement({ models: ["opencode/big-pickle"] }, new Set(["big-pickle", "laguna-s-2.1-free"])).catalogModels).toEqual(["opencode/big-pickle", "opencode/laguna-s-2.1-free"]);
+    });
+    it("filters the scan with the key from the runtime env", async () => {
+        scan(verbose(["opencode/big-pickle", "opencode/claude-opus-5"]));
+        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(zenResponse(["big-pickle"]));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle"]);
+        expect(fetchSpy).toHaveBeenCalledWith("https://opencode.ai/zen/v1/models", expect.objectContaining({ headers: { Authorization: "Bearer sk-live" } }));
+    });
+    // A local runtime has no injected env — the user ran `opencode auth login`, which
+    // writes the same document the cloud passes as OPENCODE_AUTH_CONTENT.
+    it("reads the credential out of an auth.json document", async () => {
+        scan(verbose(["opencode/big-pickle", "opencode/claude-opus-5"]));
+        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(zenResponse(["big-pickle"]));
+        await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_AUTH_CONTENT: JSON.stringify({ opencode: { type: "api", key: "sk-from-file" } }),
+        });
+        expect(fetchSpy).toHaveBeenCalledWith("https://opencode.ai/zen/v1/models", expect.objectContaining({ headers: { Authorization: "Bearer sk-from-file" } }));
+    });
+    // Unauthenticated the endpoint serves the full public catalogue, so the no-credential
+    // case needs no branch — and must not send an empty bearer.
+    it("asks anonymously when there is no credential anywhere", async () => {
+        scan(verbose(["opencode/big-pickle"]));
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(zenResponse(["big-pickle", "claude-opus-5"]));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            XDG_DATA_HOME: join(tmpdir(), `no-opencode-auth-${randomUUID()}`),
+        });
+        // The anonymous union still asks Zen, but paid ids it returns are dropped: without
+        // a credential they all 401 at dispatch. big-pickle survives on its free billing.
+        expect(discovery.models).toEqual(["opencode/big-pickle"]);
+        expect(discovery.catalogModels).toContain("opencode/claude-opus-5");
+        expect(fetchSpy).toHaveBeenCalledWith("https://opencode.ai/zen/v1/models", expect.objectContaining({ headers: {} }));
+    });
+    it("keeps the unfiltered scan when Zen is unreachable", async () => {
+        scan(verbose(["opencode/big-pickle", "opencode/claude-opus-5"]));
+        vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("ENOTFOUND"));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle", "opencode/claude-opus-5"]);
+    });
+    it("keeps the unfiltered scan when Zen answers with an error status", async () => {
+        scan(verbose(["opencode/big-pickle", "opencode/claude-opus-5"]));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue({ ok: false, status: 500 });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            ...NO_CACHE_ENV,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle", "opencode/claude-opus-5"]);
+    });
+});
+// `opencode models --verbose` prints only what the current credential can serve — six
+// models unauthenticated, sixty-one with a key — while the CLI has already downloaded the
+// full catalogue to ~/.cache/opencode/models.json and is just filtering its own output.
+// Reading that file recovers the hidden effort tiers with no extra network call.
+describe("OpenCode catalogue cache hydration", () => {
+    let cacheHome;
+    const writeCache = (payload) => {
+        mkdirSync(join(cacheHome, "opencode"), { recursive: true });
+        writeFileSync(join(cacheHome, "opencode", "models.json"), JSON.stringify(payload));
+    };
+    const scan = (stdout) => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout,
+            stderr: "",
+            error: undefined,
+        });
+    };
+    const verboseEntry = (id, variants) => [
+        id,
+        "{",
+        `  "id": "${id.split("/").slice(1).join("/")}",`,
+        '  "cost": { "input": 0, "output": 0 },',
+        '  "capabilities": { "reasoning": true },',
+        `  "variants": { ${variants.map((v) => `"${v}": {}`).join(", ")} }`,
+        "}",
+    ].join("\n");
+    const zen = (ids) => ({ ok: true, json: async () => ({ data: ids.map((id) => ({ id })) }) });
+    beforeEach(() => {
+        cacheHome = join(tmpdir(), `opencode-cache-${randomUUID()}`);
+    });
+    afterEach(() => {
+        rmSync(cacheHome, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it("fills effort tiers and billing for models the CLI never printed", async () => {
+        scan(verboseEntry("opencode/big-pickle", []));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["big-pickle", "claude-opus-4-8"]));
+        writeCache({
+            opencode: {
+                models: {
+                    "claude-opus-4-8": {
+                        reasoning_options: [{ type: "effort", values: ["low", "high", "max"] }],
+                        cost: { input: 5, output: 25 },
+                    },
+                },
+            },
+        });
+        // Keyed: without a credential the anonymous free-only rule would hide this paid id.
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toContain("opencode/claude-opus-4-8");
+        expect(discovery.modelVariants?.["opencode/claude-opus-4-8"]).toEqual(["low", "high", "max"]);
+        expect(discovery.modelBilling?.["opencode/claude-opus-4-8"]).toBe("paid");
+    });
+    // Live 2026-09-01: for claude-haiku-4-5, claude-sonnet-4/4-5, qwen3.5/3.6-plus and
+    // ling-3.0-flash-fin-free the CLI reports tiers the cache does not describe as efforts.
+    // Letting the cache win would delete effort levels that currently work.
+    it("keeps the live scan's tiers when the cache disagrees", async () => {
+        scan(verboseEntry("opencode/claude-haiku-4-5", ["high", "max"]));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["claude-haiku-4-5"]));
+        writeCache({
+            opencode: {
+                models: {
+                    "claude-haiku-4-5": {
+                        reasoning_options: [{ type: "effort", values: ["low", "medium"] }],
+                        cost: { input: 1, output: 5 },
+                    },
+                },
+            },
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+        });
+        expect(discovery.modelVariants?.["opencode/claude-haiku-4-5"]).toEqual(["high", "max"]);
+    });
+    // Nineteen OpenCode models express reasoning as `budget_tokens`, and the CLI synthesises
+    // high/max from them by a mapping that lives in its binary. Recording `[]` would assert
+    // "no effort tiers" and override a catalogue entry that is more correct than we are.
+    it("contributes nothing for a budget_tokens-only model rather than asserting none", async () => {
+        scan(verboseEntry("opencode/big-pickle", []));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["big-pickle", "claude-sonnet-4"]));
+        writeCache({
+            opencode: {
+                models: {
+                    "claude-sonnet-4": {
+                        reasoning_options: [{ type: "budget_tokens", min: 1024 }],
+                        cost: { input: 3, output: 15 },
+                    },
+                },
+            },
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toContain("opencode/claude-sonnet-4");
+        expect(discovery.modelVariants?.["opencode/claude-sonnet-4"]).toBeUndefined();
+        expect(discovery.modelBilling?.["opencode/claude-sonnet-4"]).toBe("paid");
+    });
+    it("hydrates the opencode-go namespace too", async () => {
+        scan(verboseEntry("opencode-go/glm-5.3", []));
+        vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
+        writeCache({
+            "opencode-go": {
+                models: {
+                    "qwen3.8-max": {
+                        reasoning_options: [{ type: "effort", values: ["low", "medium", "xhigh"] }],
+                        cost: { input: 2, output: 6 },
+                    },
+                },
+            },
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+        });
+        // Not offered (the scan never saw it), but metadata is ready if a later scan does.
+        expect(discovery.modelVariants?.["opencode-go/qwen3.8-max"]).toBeUndefined();
+    });
+    // Zen serves a deprecated model for a grace period, during which it appears in the
+    // anonymous /models yet fails for anonymous callers (live: deepseek-v4-flash-free).
+    it("hides cache-deprecated models from the credential-less picker", async () => {
+        scan(verboseEntry("opencode/big-pickle", []));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["big-pickle", "deepseek-v4-flash-free"]));
+        writeCache({
+            opencode: {
+                models: {
+                    "deepseek-v4-flash-free": { status: "deprecated", cost: { input: 0, output: 0 } },
+                },
+            },
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+            XDG_DATA_HOME: join(tmpdir(), `no-auth-${randomUUID()}`),
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle"]);
+        // The catalogue feed keeps it: Zen still serves it, so removal must not fire.
+        expect(discovery.catalogModels).toContain("opencode/deepseek-v4-flash-free");
+    });
+    // laguna-s-2.1-free is deprecated AND entitled AND dispatches on a real key. The
+    // entitlement is the stronger signal — a key's own list must never be second-guessed.
+    it("keeps a deprecated model the credential is entitled to", async () => {
+        scan(verboseEntry("opencode/big-pickle", []));
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["big-pickle", "laguna-s-2.1-free"]));
+        writeCache({
+            opencode: {
+                models: {
+                    "laguna-s-2.1-free": { status: "deprecated", cost: { input: 0, output: 0 } },
+                },
+            },
+        });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+            OPENCODE_API_KEY: "sk-live",
+        });
+        expect(discovery.models).toContain("opencode/laguna-s-2.1-free");
+    });
+    it("survives a missing cache file", async () => {
+        scan(verboseEntry("opencode/big-pickle", ["high"]));
+        vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: join(cacheHome, "does-not-exist"),
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle"]);
+        expect(discovery.modelVariants?.["opencode/big-pickle"]).toEqual(["high"]);
+    });
+    it("survives a corrupt cache file", async () => {
+        scan(verboseEntry("opencode/big-pickle", ["high"]));
+        vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
+        mkdirSync(join(cacheHome, "opencode"), { recursive: true });
+        writeFileSync(join(cacheHome, "opencode", "models.json"), "{ not json");
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_CACHE_HOME: cacheHome,
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle"]);
+    });
+});
+// OpenCode auto-detects ambient cloud credential chains — a `~/.aws` configured for
+// unrelated tooling made it list 79 Bedrock models for a user who never connected
+// Bedrock to OpenCode. Only providers explicitly configured inside OpenCode (an
+// auth.json entry or a provider API-key env var) may contribute models.
+describe("OpenCode configured-provider filter", () => {
+    let dataHome;
+    const writeAuth = (doc) => {
+        mkdirSync(join(dataHome, "opencode"), { recursive: true });
+        writeFileSync(join(dataHome, "opencode", "auth.json"), JSON.stringify(doc));
+    };
+    const scanWith = (ids) => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: ids
+                .map((id) => [
+                id,
+                "{",
+                `  "id": "${id.split("/").slice(1).join("/")}",`,
+                '  "cost": { "input": 0, "output": 0 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": {}',
+                "}",
+            ].join("\n"))
+                .join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+    };
+    beforeEach(() => {
+        dataHome = join(tmpdir(), `opencode-auth-${randomUUID()}`);
+    });
+    afterEach(() => {
+        rmSync(dataHome, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it("drops ambient-credential providers and keeps auth.json ones", async () => {
+        scanWith([
+            "opencode/big-pickle",
+            "openrouter/z-ai/glm-latest",
+            "amazon-bedrock/anthropic.claude-opus-5",
+        ]);
+        writeAuth({ openrouter: { type: "api", key: "sk-or" } });
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_DATA_HOME: dataHome,
+            XDG_CACHE_HOME: join(tmpdir(), `no-cache-${randomUUID()}`),
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle", "openrouter/z-ai/glm-latest"]);
+    });
+    it("admits a provider configured through its explicit env key", () => {
+        const configured = readConfiguredOpenCodeProviders({
+            XDG_DATA_HOME: join(tmpdir(), `no-auth-${randomUUID()}`),
+            OPENROUTER_API_KEY: "sk-or",
+        });
+        expect(configured.has("openrouter")).toBe(true);
+        expect(configured.has("amazon-bedrock")).toBe(false);
+        // Zen's namespaces are always in scope; entitlement governs them downstream.
+        expect(configured.has("opencode")).toBe(true);
+        expect(configured.has("opencode-go")).toBe(true);
+    });
+    it("reads providers from an injected OPENCODE_AUTH_CONTENT document", () => {
+        const configured = readConfiguredOpenCodeProviders({
+            XDG_DATA_HOME: join(tmpdir(), `no-auth-${randomUUID()}`),
+            OPENCODE_AUTH_CONTENT: JSON.stringify({
+                opencode: { type: "api", key: "sk" },
+                "amazon-bedrock": { type: "api", key: "explicit" },
+            }),
+        });
+        // Explicitly configured Bedrock is a decision, not an ambient chain — allowed.
+        expect(configured.has("amazon-bedrock")).toBe(true);
+    });
+});
+// Without a credential every paid Zen model answers 401 CreditsError at dispatch, so
+// the anonymous picker carries only the free tier — same list `opencode models` itself
+// prints when unauthenticated. BYOK namespaces keep their own key and are untouched.
+describe("OpenCode anonymous free-tier filter", () => {
+    const zen = (ids) => ({ ok: true, json: async () => ({ data: ids.map((id) => ({ id })) }) });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("hides paid Zen models when no credential exists anywhere", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: [
+                "opencode/big-pickle",
+                "{",
+                '  "cost": { "input": 0, "output": 0 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": {}',
+                "}",
+                "opencode/claude-opus-5",
+                "{",
+                '  "cost": { "input": 5, "output": 25 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": {}',
+                "}",
+                "openrouter/z-ai/glm-latest",
+                "{",
+                '  "cost": { "input": 1, "output": 3 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": {}',
+                "}",
+            ].join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["big-pickle", "claude-opus-5"]));
+        const dataHome = join(tmpdir(), `anon-auth-${randomUUID()}`);
+        mkdirSync(join(dataHome, "opencode"), { recursive: true });
+        writeFileSync(join(dataHome, "opencode", "auth.json"), JSON.stringify({ openrouter: { type: "api", key: "sk-or" } }));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            XDG_DATA_HOME: dataHome,
+            XDG_CACHE_HOME: join(tmpdir(), `no-cache-${randomUUID()}`),
+        });
+        expect(discovery.models).toEqual(["opencode/big-pickle", "openrouter/z-ai/glm-latest"]);
+        // The catalogue feed still carries the paid ids — global state, not this machine's.
+        expect(discovery.catalogModels).toContain("opencode/claude-opus-5");
+    });
+    it("keeps paid Zen models when a key is present — entitlement governs, not billing", async () => {
+        vi.spyOn(cli, "runCliProbeAsync").mockResolvedValue({
+            status: 0,
+            stdout: [
+                "opencode/muse-spark-1.2",
+                "{",
+                '  "cost": { "input": 1.25, "output": 4.25 },',
+                '  "capabilities": { "reasoning": true },',
+                '  "variants": {}',
+                "}",
+            ].join("\n"),
+            stderr: "",
+            error: undefined,
+        });
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(zen(["muse-spark-1.2"]));
+        const discovery = await discoverProviderModelDetails("opencode_cli", "/bin/opencode", {
+            OPENCODE_API_KEY: "sk-live",
+            XDG_CACHE_HOME: join(tmpdir(), `no-cache-${randomUUID()}`),
+        });
+        expect(discovery.models).toEqual(["opencode/muse-spark-1.2"]);
+    });
+});
+//# sourceMappingURL=provider-model-discovery.test.js.map