pennyrouter 0.3.0 → 0.3.2

package/src/cli.test.js

@@ -0,0 +1,196 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { harnessFundingChanged, main } from "./cli.js";
+
+// --config lets a GUI installer (the macOS DMG) answer install questions up front instead of
+// over a TTY. These tests drive it through `main()` in --dry-run, which prints its plan and
+// returns before any network call or filesystem write, so no mocking is needed.
+
+function withConfigFile(config, run) {
+  const dir = mkdtempSync(join(tmpdir(), "pennyrouter-config-"));
+  const path = join(dir, "penny_install.json");
+  writeFileSync(path, JSON.stringify(config));
+  try {
+    return run(path);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function captureLogs(run) {
+  const original = console.log;
+  const lines = [];
+  console.log = (...args) => lines.push(args.join(" "));
+  return run().finally(() => { console.log = original; }).then(() => lines);
+}
+
+test("--config selects harnesses without prompting", async () => {
+  await withConfigFile({ harnesses: ["claude-code"] }, async (path) => {
+    const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+    assert.ok(lines.some((line) => line.includes("Claude Code")));
+    assert.ok(!lines.some((line) => line.includes("Codex")));
+  });
+});
+
+test("--config with claudeFunding subscription sets --anthropic-auth", async () => {
+  await withConfigFile(
+    { harnesses: ["claude-code"], claudeFunding: ["subscription"] },
+    async (path) => {
+      const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+      assert.ok(lines.some((line) => line.includes("Claude Code provider picker")));
+    },
+  );
+});
+
+test("--config rejects an unreadable file", async () => {
+  await assert.rejects(
+    () => main(["install", "--config", "/nonexistent/penny_install.json", "--dry-run"]),
+    /Could not read --config file/,
+  );
+});
+
+test("explicit --harness overrides --config harnesses", async () => {
+  await withConfigFile({ harnesses: ["codex"] }, async (path) => {
+    const lines = await captureLogs(
+      () => main(["install", "--harness", "claude-code", "--config", path, "--dry-run"]),
+    );
+    assert.ok(lines.some((line) => line.includes("Claude Code")));
+    assert.ok(!lines.some((line) => line.includes("Codex")));
+  });
+});
+
+// harnessFundingChanged decides whether a --config re-run needs to re-open the account-claim
+// and subscription-auth popups for a harness, or can treat it like `update` (skip both). This
+// only kicks in on --config re-runs against an existing manifest; a live end-to-end run against
+// a real account confirmed the same three cases these unit tests cover.
+
+const claudeHarness = { id: "claude-code" };
+const codexHarness = { id: "codex" };
+
+test("harnessFundingChanged: brand new harness always needs auth", () => {
+  const manifest = { installations: [] };
+  assert.equal(harnessFundingChanged({}, claudeHarness, manifest), true);
+});
+
+test("harnessFundingChanged: claude subscription unchanged", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const flags = { configClaudeFunding: new Set(["subscription"]) };
+  assert.equal(harnessFundingChanged(flags, claudeHarness, manifest), false);
+});
+
+test("harnessFundingChanged: claude subscription to anthropic-api is a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const flags = { configClaudeFunding: new Set(["anthropic-api"]) };
+  assert.equal(harnessFundingChanged(flags, claudeHarness, manifest), true);
+});
+
+test("harnessFundingChanged: codex subscription unchanged (openai_subscription_auth flag)", () => {
+  const manifest = {
+    installations: [{
+      harness: "codex",
+      user_funded_provider: "chatgpt-subscription",
+      openai_subscription_auth: true,
+    }],
+  };
+  const flags = { configCodexFunding: new Set(["subscription"]) };
+  assert.equal(harnessFundingChanged(flags, codexHarness, manifest), false);
+});
+
+test("harnessFundingChanged: codex openrouter unchanged", () => {
+  const manifest = {
+    installations: [{
+      harness: "codex",
+      user_funded_provider: "openrouter",
+      openai_subscription_auth: false,
+    }],
+  };
+  const flags = { configCodexFunding: new Set(["openrouter"]) };
+  assert.equal(harnessFundingChanged(flags, codexHarness, manifest), false);
+});
+
+test("harnessFundingChanged: no requested funding for an existing harness is not a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  assert.equal(harnessFundingChanged({}, claudeHarness, manifest), false);
+});
+
+// --- Other proxy (user-supplied Anthropic-compatible base URL) ----------------
+
+test("--proxy-base-url and --proxy-api-key parse in both forms", async () => {
+  for (const args of [
+    ["--proxy-base-url", "https://proxy.example.com", "--proxy-api-key", "k"],
+    ["--proxy-base-url=https://proxy.example.com", "--proxy-api-key=k"],
+  ]) {
+    const lines = await captureLogs(() => main([
+      "install", "--harness", "claude-code", "--dry-run", ...args,
+    ]));
+    assert.ok(lines.length > 0);
+  }
+});
+
+test("--config maps anthropic-proxy funding to the proxy flags", async () => {
+  await withConfigFile(
+    {
+      harnesses: ["claude-code"],
+      claudeFunding: ["anthropic-proxy"],
+      proxyBaseUrl: "https://proxy.example.com",
+      proxyApiKey: "secret-key",
+    },
+    async (path) => {
+      const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+      assert.ok(lines.some((line) => line.includes("Claude Code")));
+      // The key must never be echoed to the terminal.
+      assert.ok(!lines.some((line) => line.includes("secret-key")));
+    },
+  );
+});
+
+test("harnessFundingChanged sees a switch to the proxy as a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const changed = harnessFundingChanged(
+    { configClaudeFunding: new Set(["anthropic-proxy"]) },
+    { id: "claude-code" },
+    manifest,
+  );
+  assert.equal(changed, true);
+});
+
+test("harnessFundingChanged sees an unchanged proxy install as unchanged", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "anthropic-proxy" }],
+  };
+  const changed = harnessFundingChanged(
+    { configClaudeFunding: new Set(["anthropic-proxy"]) },
+    { id: "claude-code" },
+    manifest,
+  );
+  assert.equal(changed, false);
+});
+
+test("auth anthropic --forget targets the installed gateway, not prod", async () => {
+  // Regression: this defaulted to https://api.pennyrouter.com even when the machine was
+  // installed against a local gateway, silently deleting the wrong account's token.
+  const lines = await captureLogs(() => main([
+    "auth", "anthropic", "--forget", "--dry-run",
+    "--penny-key", "pr-test", "--gateway-base-url", "http://localhost:8400",
+  ]));
+  assert.ok(lines.some((line) => line.includes("http://localhost:8400")));
+  assert.ok(!lines.some((line) => line.includes("api.pennyrouter.com")));
+});
+
+test("auth anthropic --forget honors --local", async () => {
+  const lines = await captureLogs(() => main([
+    "auth", "anthropic", "--forget", "--dry-run", "--local", "--penny-key", "pr-test",
+  ]));
+  assert.ok(lines.some((line) => line.includes("localhost:8400")));
+});

package/src/harnesses/claude-code.js

@@ -4,25 +4,37 @@ import { configureClaudeCodeStatusline, restoreClaudeCodeStatusline } from "../s
 const CONFIG_PATH = "~/.claude/settings.json";
 const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
 const CONNECTOR_SETTING = "disableClaudeAiConnectors";
-// Values written into Claude Code's four model slots. CC displays a slot's VALUE verbatim in
-// its /model menu AND sends it as the request `model`, so each value is both the menu label
-// and the gateway's routing key. The three concrete Claude slots carry friendly PINNED labels
-// ("Opus 5/Sonnet 5/Haiku 4.5/Fable 5 (PennyRouter)") that the gateway maps to that exact
-// model — the user's pick runs on the model they chose, no dynamic tier switching on the
-// trunk (background/utility calls still route cheap, which is where the savings come from).
-// Named "<Model> (PennyRouter)" rather than "Penny <Model>" so CC's own generated "Custom ...
-// model" subtext still reads as a real Claude model routed through Penny, not a distinct
-// custom model. The separate Fable slot is pinned to Fable; the DYNAMIC "Penny Custom" option
-// lets PennyRouter cost-route. Legacy "Penny Speed/Core/Power/Opus/Sonnet/Haiku/Fable"
-// installs (dynamic bundles, or the pre-rename pinned labels) are still recognized for
-// uninstall (see isPennyRouterModelValue).
+// The slot values remain genuine Anthropic ids so Claude Code recognizes them and sends the
+// native id on the wire. Claude Code separately supports *_MODEL_NAME and *_MODEL_DESCRIPTION
+// for the picker, so Penny can present a friendly alias without sacrificing model recognition.
+//
+// The 1M-context variant is a `[1m]` suffix on the id — Claude Code does NOT infer a 1M window
+// from a bare id, so a bare `claude-sonnet-5` gets 200K and auto-compacts around 150K. The
+// suffix rides the wire; the gateway strips it for the upstream model and turns it into the
+// `context-1m` beta header. Haiku has no 1M variant, so it stays bare.
 export const CLAUDE_CODE_MODELS = {
-  haiku: "Haiku 4.5 (PennyRouter)",   // -> pinned anthropic/claude-haiku-4-5-20251001
-  sonnet: "Sonnet 5 (PennyRouter)",   // -> pinned anthropic/claude-sonnet-5
-  opus: "Opus 5 (PennyRouter)",       // -> pinned anthropic/claude-opus-5
-  fable: "Fable 5 (PennyRouter)",     // -> pinned anthropic/claude-fable-5
-  custom: "Penny Custom",             // -> dynamic (PennyRouter cost-routing)
+  haiku: "claude-haiku-4-5-20251001",
+  sonnet: "claude-sonnet-5[1m]",
+  opus: "claude-opus-5[1m]",
+  fable: "claude-fable-5[1m]",
 };
+const CLAUDE_CODE_MODEL_PRESENTATION = {
+  haiku: { name: "Haiku 4.5", description: "Fast, economical Claude model · 200K context" },
+  sonnet: { name: "Sonnet 5", description: "Balanced Claude model · 1M context" },
+  opus: { name: "Opus 5", description: "Most capable Claude model · 1M context" },
+  fable: { name: "Fable 5", description: "Claude model · 1M context" },
+};
+const LEGACY_PINNED_MODEL_IDS = {
+  "Haiku 4.5": CLAUDE_CODE_MODELS.haiku,
+  "Sonnet 5": CLAUDE_CODE_MODELS.sonnet,
+  "Opus 5": CLAUDE_CODE_MODELS.opus,
+  "Fable 5": CLAUDE_CODE_MODELS.fable,
+  "Haiku 4.5 (PennyRouter)": CLAUDE_CODE_MODELS.haiku,
+  "Sonnet 5 (PennyRouter)": CLAUDE_CODE_MODELS.sonnet,
+  "Opus 5 (PennyRouter)": CLAUDE_CODE_MODELS.opus,
+  "Fable 5 (PennyRouter)": CLAUDE_CODE_MODELS.fable,
+};
+const LEGACY_PINNED_MODEL_LABELS = Object.keys(LEGACY_PINNED_MODEL_IDS);
 // Retired dynamic-bundle labels (pre-pinned-trunk) and the pre-rename pinned labels. Not
 // written by a fresh install; matched only so uninstall/detect still recognize and clean up
 // an older install.
@@ -31,6 +43,22 @@ const LEGACY_PENNY_LABELS = [
   "Penny Opus", "Penny Sonnet", "Penny Haiku", "Penny Fable",
 ];
 
+// Used both for globally-installed Claude Code and `penny claude`, whose isolated
+// launch environment otherwise bypasses ~/.claude/settings.json entirely.
+export function writeClaudeCodeModelPresentation(env) {
+  for (const [slot, { name, description }] of Object.entries(CLAUDE_CODE_MODEL_PRESENTATION)) {
+    const prefix = `ANTHROPIC_DEFAULT_${slot.toUpperCase()}_MODEL`;
+    env[`${prefix}_NAME`] = name;
+    env[`${prefix}_DESCRIPTION`] = description;
+  }
+}
+
+const CLAUDE_CODE_MODEL_PRESENTATION_KEYS = Object.keys(CLAUDE_CODE_MODEL_PRESENTATION)
+  .flatMap((slot) => {
+    const prefix = `ANTHROPIC_DEFAULT_${slot.toUpperCase()}_MODEL`;
+    return [`${prefix}_NAME`, `${prefix}_DESCRIPTION`];
+  });
+
 export const claudeCodeHarness = {
   id: "claude-code",
   name: "Claude Code",
@@ -61,16 +89,20 @@ export const claudeCodeHarness = {
     // Anthropic API key. Clear any stale key so it doesn't take precedence.
     current.env.ANTHROPIC_AUTH_TOKEN = apiKey;
     delete current.env.ANTHROPIC_API_KEY;
+    current.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     // Claude Code displays these env values directly in its model picker; the
     // gateway decodes the friendly labels into bundle/profile overrides.
     current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.opus;
     current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.sonnet;
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.fable;
-    // The pinned labels above aren't real Anthropic model ids, so CC can't infer their
-    // context window from the name and falls back to a conservative 200K default. Tell it
-    // directly: every pinned slot is a Claude model with the 1M-context beta enabled upstream.
-    current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = "1000000";
+    writeClaudeCodeModelPresentation(current.env);
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+    // This is global, not per-model. Leave it unset so Claude Code uses each native id's
+    // real context limit instead of incorrectly giving Haiku a 1M window.
+    delete current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
 
     const statusline = await configureClaudeCodeStatusline(current);
 
@@ -93,7 +125,7 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_SONNET_MODEL",
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
           "ANTHROPIC_DEFAULT_FABLE_MODEL",
-          "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+          ...CLAUDE_CODE_MODEL_PRESENTATION_KEYS,
         ],
       },
     };
@@ -113,14 +145,18 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_AUTH_TOKEN = apiKey;
     // Single credential only: no stale api key, no separate Anthropic bearer.
     delete current.env.ANTHROPIC_API_KEY;
+    current.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.opus;
     current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.sonnet;
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.fable;
-    // The pinned labels above aren't real Anthropic model ids, so CC can't infer their
-    // context window from the name and falls back to a conservative 200K default. Tell it
-    // directly: every pinned slot is a Claude model with the 1M-context beta enabled upstream.
-    current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = "1000000";
+    writeClaudeCodeModelPresentation(current.env);
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+    // This is global, not per-model. Leave it unset so Claude Code uses each native id's
+    // real context limit instead of incorrectly giving Haiku a 1M window.
+    delete current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
 
     const statusline = await configureClaudeCodeStatusline(current);
 
@@ -143,7 +179,7 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_SONNET_MODEL",
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
           "ANTHROPIC_DEFAULT_FABLE_MODEL",
-          "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+          ...CLAUDE_CODE_MODEL_PRESENTATION_KEYS,
         ],
       },
     };
@@ -159,14 +195,18 @@ export const claudeCodeHarness = {
     // Authorization bearer token is forwarded by the gateway to Anthropic.
     current.env.ANTHROPIC_API_KEY = pennyKey;
     current.env.ANTHROPIC_AUTH_TOKEN = anthropicAuthToken;
+    current.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.opus;
     current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.sonnet;
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.fable;
-    // The pinned labels above aren't real Anthropic model ids, so CC can't infer their
-    // context window from the name and falls back to a conservative 200K default. Tell it
-    // directly: every pinned slot is a Claude model with the 1M-context beta enabled upstream.
-    current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = "1000000";
+    writeClaudeCodeModelPresentation(current.env);
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+    // This is global, not per-model. Leave it unset so Claude Code uses each native id's
+    // real context limit instead of incorrectly giving Haiku a 1M window.
+    delete current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
 
     const statusline = await configureClaudeCodeStatusline(current);
 
@@ -189,7 +229,7 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_SONNET_MODEL",
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
           "ANTHROPIC_DEFAULT_FABLE_MODEL",
-          "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+          ...CLAUDE_CODE_MODEL_PRESENTATION_KEYS,
         ],
       },
     };
@@ -224,6 +264,7 @@ export const claudeCodeHarness = {
       ]) {
         if (current.env[k] === LEGACY_MODEL_LABEL || isPennyRouterModelValue(current.env[k])) delete current.env[k];
       }
+      for (const k of CLAUDE_CODE_MODEL_PRESENTATION_KEYS) delete current.env[k];
       delete current.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
     }
     restoreClaudeAiConnectors(current, record);
@@ -293,10 +334,18 @@ function isPennyRouterModelValue(value) {
     value === CLAUDE_CODE_MODELS.opus ||
     value === CLAUDE_CODE_MODELS.fable ||
     value === CLAUDE_CODE_MODELS.custom ||
+    LEGACY_PINNED_MODEL_LABELS.includes(value) ||
     LEGACY_PENNY_LABELS.includes(value)
   );
 }
 
+// `penny claude` can launch using a local Penny config written by an earlier CLI
+// version. Translate only our previous friendly labels; a user-supplied model id
+// remains untouched.
+export function upgradeClaudeCodeModelValue(value) {
+  return LEGACY_PINNED_MODEL_IDS[value] || value;
+}
+
 export async function readClaudeCodePennyRouterKey() {
   const current = (await readJsonFile(CONFIG_PATH, null)) || {};
   const env = current.env || {};

package/src/harnesses/opencode.js

@@ -8,11 +8,24 @@ import {
   readText,
   writeJsonFile,
 } from "../state.js";
-import { PENNYROUTER_MODEL_CHOICES } from "./shared.js";
-
 const JSONC_PATH = "~/.config/opencode/opencode.jsonc";
 const JSON_PATH = "~/.config/opencode/opencode.json";
 const MODEL_STATE_PATH = "~/.local/state/opencode/model.json";
+export const OPENCODE_MODEL_CHOICES = [
+  { id: "pennyrouter/penny-core:premium", name: "Penny Core" },
+  { id: "pennyrouter/penny-speed:standard", name: "Penny Speed" },
+  { id: "pennyrouter/penny-power:premium", name: "Penny Power" },
+  { id: "pennyrouter/auto", name: "PennyRouter Auto" },
+  { id: "claude-penny-deepseek-v4-flash", name: "DeepSeek V4 Flash" },
+  { id: "claude-penny-glm-5-3", name: "GLM 5.3" },
+  { id: "claude-penny-gpt-5-6-luna", name: "GPT-5.6 Luna" },
+  { id: "claude-penny-grok-4-6", name: "Grok 4.6" },
+  { id: "claude-penny-kimi-k3", name: "Kimi K3" },
+  { id: "claude-penny-ling-3-flash", name: "Ling-3.0 Flash" },
+  { id: "claude-penny-minimax-m3", name: "MiniMax M3" },
+  { id: "claude-penny-nemotron-ultra-free", name: "Nemotron 3 Ultra (free)" },
+  { id: "claude-penny-solar-pro4", name: "Solar Pro 4" },
+];
 
 export const opencodeHarness = {
   id: "opencode",
@@ -29,33 +42,50 @@ export const opencodeHarness = {
       summary: [
         `write ${configPath}`,
         "merge PennyRouter provider without replacing existing providers",
-        "publish the four Penny model choices",
+        "publish the curated Penny bundles and individual model pins",
         `reset ${MODEL_STATE_PATH} so opencode rediscovers configured models`,
       ],
     };
   },
 
-  async install({ apiKey, gatewayBaseUrl, plan }) {
+  async install({ apiKey, gatewayBaseUrl, plan, models }) {
     const configPath = compactHome(plan.configPath);
     const backupPath = await backupFile(configPath, "opencode");
     const current = await readConfig(configPath);
     current.provider ||= {};
+    current.enabled_providers = Array.isArray(current.enabled_providers)
+      ? current.enabled_providers
+      : [];
+    if (!current.enabled_providers.includes("pennyrouter")) {
+      current.enabled_providers.push("pennyrouter");
+    }
     current.provider.pennyrouter = {
       npm: "@ai-sdk/openai-compatible",
       name: "PennyRouter",
       options: {
-        baseURL: `${gatewayBaseUrl}/v1`,
+        baseURL: `${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1`,
         apiKey,
       },
       models: Object.fromEntries(
-        PENNYROUTER_MODEL_CHOICES.map((model) => [model.id, { name: model.name }]),
+        (models || OPENCODE_MODEL_CHOICES).map((model) => [
+          opencodeModelId(model.id),
+          { name: model.name, ...(model.description ? { description: model.description } : {}) },
+        ]),
       ),
     };
 
     await atomicWrite(configPath, `${JSON.stringify(current, null, 2)}\n`);
 
     const modelBackupPath = await backupFile(MODEL_STATE_PATH, "opencode-model");
-    await writeJsonFile(MODEL_STATE_PATH, { recent: [], favorite: [], variant: {} });
+    const model = (await readJsonFile(MODEL_STATE_PATH, null)) || {};
+    model.recent = removePennyRouterModels(model.recent);
+    model.favorite = removePennyRouterModels(model.favorite);
+    if (model.variant && typeof model.variant === "object") {
+      for (const [key, value] of Object.entries(model.variant)) {
+        if (isPennyRouterModel(key) || isPennyRouterModel(value)) delete model.variant[key];
+      }
+    }
+    await writeJsonFile(MODEL_STATE_PATH, model);
 
     return {
       harness: "opencode",
@@ -73,6 +103,12 @@ export const opencodeHarness = {
 
   async uninstall(record) {
     const current = await readConfig(record.config_path);
+    if (Array.isArray(current.enabled_providers)) {
+      current.enabled_providers = current.enabled_providers.filter(
+        (provider) => provider !== "pennyrouter",
+      );
+      if (current.enabled_providers.length === 0) delete current.enabled_providers;
+    }
     if (current.provider?.pennyrouter) delete current.provider.pennyrouter;
     if (current.provider && Object.keys(current.provider).length === 0) delete current.provider;
     await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
@@ -136,7 +172,45 @@ function stripJsonComments(text) {
     result += char;
   }
 
-  return result;
+  return result.replace(/,\s*([}\]])/g, "$1");
+}
+
+export function opencodeModelId(modelId) {
+  return modelId;
+}
+
+export async function fetchOpenCodeModels(gatewayBaseUrl) {
+  try {
+    const response = await fetch(`${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1/models`);
+    if (!response.ok) throw new Error(`model catalog returned ${response.status}`);
+    const payload = await response.json();
+    const catalog = new Map(
+      Array.isArray(payload?.data)
+        ? payload.data
+          .filter((model) => typeof model?.id === "string")
+          .map((model) => [model.id, model])
+        : [],
+    );
+    const models = OPENCODE_MODEL_CHOICES.map((choice) => {
+      const model = catalog.get(choice.id);
+      return {
+        ...choice,
+        ...(model?.description ? { description: model.description } : {}),
+      };
+    });
+    if (models.length > 0) return models;
+  } catch {}
+  return OPENCODE_MODEL_CHOICES;
+}
+
+function openCodeModelName(modelId) {
+  const suffix = opencodeModelId(modelId);
+  if (suffix === "auto") return "PennyRouter Auto";
+  return `PennyRouter ${suffix
+    .split(/[-:]/)
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join(" ")}`;
 }
 
 function removePennyRouterModels(value) {

package/src/harnesses/opencode.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { opencodeHarness, opencodeModelId, OPENCODE_MODEL_CHOICES } from "./opencode.js";
+
+const ENV_KEYS = ["HOME", "XDG_STATE_HOME"];
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-opencode-test-"));
+  const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  const home = path.join(root, "home");
+  const configPath = path.join(home, ".config", "opencode", "opencode.jsonc");
+  const modelStatePath = path.join(home, ".local", "state", "opencode", "model.json");
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.mkdirSync(path.dirname(modelStatePath), { recursive: true });
+  fs.writeFileSync(configPath, [
+    "{",
+    '  "$schema": "https://opencode.ai/config.json",',
+    '  "enabled_providers": ["custom"],',
+    '  "provider": {',
+    '    "custom": { "models": { "model-a": {} } },',
+    "  },",
+    "}",
+    "",
+  ].join("\n"));
+  fs.writeFileSync(modelStatePath, JSON.stringify({
+    recent: ["pennyrouter/old", "custom/model-a"],
+    favorite: ["pennyrouter/old"],
+    variant: { "pennyrouter/old": { value: "pennyrouter/old" }, "custom/model-a": {} },
+  }));
+  Object.assign(process.env, { HOME: home, XDG_STATE_HOME: path.join(home, ".local", "state") });
+
+  try {
+    assert.equal(opencodeModelId("pennyrouter/auto"), "pennyrouter/auto");
+    assert.equal(opencodeModelId("custom/model-a"), "custom/model-a");
+    const plan = await opencodeHarness.planInstall();
+    const record = await opencodeHarness.install({
+      apiKey: "pr-test",
+      gatewayBaseUrl: "https://api.pennyrouter.com/",
+      plan,
+      models: OPENCODE_MODEL_CHOICES,
+    });
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(config.provider.custom.models["model-a"] !== undefined, true);
+    assert.deepEqual(config.enabled_providers, ["custom", "pennyrouter"]);
+    assert.deepEqual(Object.keys(config.provider.pennyrouter.models), OPENCODE_MODEL_CHOICES.map((model) => model.id));
+    assert.equal(config.provider.pennyrouter.options.baseURL, "https://api.pennyrouter.com/v1");
+    assert.deepEqual(JSON.parse(fs.readFileSync(modelStatePath, "utf8")).recent, ["custom/model-a"]);
+
+    await opencodeHarness.uninstall(record);
+    const restored = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(restored.provider.pennyrouter, undefined);
+    assert.deepEqual(restored.enabled_providers, ["custom"]);
+    assert.deepEqual(restored.provider.custom.models, { "model-a": {} });
+    const model = JSON.parse(fs.readFileSync(modelStatePath, "utf8"));
+    assert.deepEqual(model.recent, ["custom/model-a"]);
+    assert.deepEqual(model.favorite, []);
+    assert.deepEqual(model.variant, { "custom/model-a": {} });
+  } finally {
+    for (const key of ENV_KEYS) {
+      if (previous[key] === undefined) delete process.env[key];
+      else process.env[key] = previous[key];
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log("opencode.test.js: all checks passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});