pennyrouter 0.2.25 → 0.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/cli.js

@@ -26,6 +26,7 @@ import {
   APP_URL,
   createCliSession,
   forgetAnthropicToken,
+  forgetUpstreamCredential,
   maskKey,
   pollForKey,
   probeClaudeCodeGateway,
@@ -72,6 +73,7 @@ const CLAUDE_PROVIDER_OPTIONS = [
   { id: "subscription", name: "Claude subscription" },
   { id: "anthropic-api", name: "Anthropic API key" },
   { id: "openrouter", name: "OpenRouter API key" },
+  { id: "anthropic-proxy", name: "Other proxy (custom base URL)" },
 ];
 const CODEX_PROVIDER_OPTIONS = [
   { id: "subscription", name: "ChatGPT subscription" },
@@ -169,6 +171,10 @@ function parseArgs(argv) {
     else if (arg === "--openai-api-key") flags.openaiApiKey = rest[++i] || "";
     else if (arg.startsWith("--openai-api-key=")) flags.openaiApiKey = arg.slice("--openai-api-key=".length);
     else if (arg === "--openrouter-api-key") flags.openrouterApiKey = rest[++i] || "";
+    else if (arg === "--proxy-base-url") flags.proxyBaseUrl = rest[++i] || "";
+    else if (arg.startsWith("--proxy-base-url=")) flags.proxyBaseUrl = arg.slice("--proxy-base-url=".length);
+    else if (arg === "--proxy-api-key") flags.proxyApiKey = rest[++i] || "";
+    else if (arg.startsWith("--proxy-api-key=")) flags.proxyApiKey = arg.slice("--proxy-api-key=".length);
     else if (arg.startsWith("--openrouter-api-key=")) flags.openrouterApiKey = arg.slice("--openrouter-api-key=".length);
     else if (arg === "--harness") flags.harness = rest[++i] || "";
     else if (arg.startsWith("--harness=")) flags.harness = arg.slice("--harness=".length);
@@ -230,6 +236,10 @@ function applyConfigFile(flags) {
   if (codexFunding.has("openai-api") && flags.openaiApiKey === undefined) {
     flags.openaiApiKey = config.openaiApiKey || "";
   }
+  if (claudeFunding.has("anthropic-proxy")) {
+    if (flags.proxyBaseUrl === undefined) flags.proxyBaseUrl = config.proxyBaseUrl || "";
+    if (flags.proxyApiKey === undefined) flags.proxyApiKey = config.proxyApiKey || "";
+  }
 
   flags.yes = true;
   flags.fromConfig = true;
@@ -284,11 +294,21 @@ async function authProvider(flags) {
         "No PennyRouter key found in Claude Code settings. Pass `--penny-key pr-...`.",
       );
     }
-    const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || DEFAULT_GATEWAY_BASE_URL;
+    // Resolve against the INSTALLED config before falling back to the prod default.
+    // This is a destructive call against whichever gateway it reaches, so defaulting to
+    // production while the user is working against a local gateway would silently delete
+    // the wrong account's token (and leave the local one in place, looking like a no-op).
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const gatewayBaseUrl = flags.gatewayBaseUrl
+      || process.env.PENNYROUTER_GATEWAY_BASE_URL
+      || launchConfig.gateway_base_url
+      || globalAuth.gatewayBaseUrl
+      || DEFAULT_GATEWAY_BASE_URL;
     if (flags.dryRun) {
       console.log(`Will delete stored Anthropic token from gateway: ${gatewayBaseUrl}`);
       return;
     }
+    console.log(`Gateway: ${gatewayBaseUrl}`);
     const ok = await forgetAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey });
     if (ok) {
       console.log("Successfully forgot stored Anthropic token on server.");
@@ -579,6 +599,7 @@ export async function install(flags = {}) {
         apiKey: claim.api_key,
         provider: credential.provider,
         token: credential.token,
+        metadata: credential.metadata,
       });
     }
   }
@@ -669,6 +690,11 @@ export async function install(flags = {}) {
         record.user_funded_provider = harnessNeededAuth
           ? (funding.claudeCredentialProvider || existingRecord?.user_funded_provider)
           : existingRecord?.user_funded_provider;
+        // Host only, never the key — the key lives encrypted on the gateway.
+        const proxyBaseUrl = harnessNeededAuth
+          ? (funding.claudeProxyBaseUrl ?? existingRecord?.proxy_base_url ?? null)
+          : (existingRecord?.proxy_base_url ?? null);
+        if (proxyBaseUrl) record.proxy_base_url = proxyBaseUrl;
       }
       if (harness.id === "codex") {
         record.user_funded_provider = harnessNeededAuth
@@ -1055,14 +1081,19 @@ async function selectClaudeFundingProviders(flags, selected) {
       || process.env.ANTHROPIC_AUTH_TOKEN)) supplied.add("subscription");
   if (flags.anthropicApiKey || process.env.ANTHROPIC_API_KEY) supplied.add("anthropic-api");
   if (flags.openrouterApiKey || process.env.OPENROUTER_API_KEY) supplied.add("openrouter");
+  if ((flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL)
+      && (flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY)) {
+    supplied.add("anthropic-proxy");
+  }
 
   // Explicit flags are the automation selector. Interactive installs always default to the
   // subscription alone; environment keys are used if the user checks their provider.
   const explicit = flags.anthropicAuth || flags.noAnthropicAuth || flags.token
-    || flags.tokenCommand || flags.anthropicApiKey || flags.openrouterApiKey;
+    || flags.tokenCommand || flags.anthropicApiKey || flags.openrouterApiKey
+    || flags.proxyBaseUrl || flags.proxyApiKey;
   if (explicit || flags.yes || !input.isTTY || !output.isTTY) return supplied;
 
-  console.log("PennyRouter can use your Claude subscription, an Anthropic API key, or an OpenRouter API key to run Claude Code.");
+  console.log("PennyRouter can use your Claude subscription, an Anthropic API key, an OpenRouter API key, or your own Anthropic-compatible proxy to run Claude Code.");
   console.log("Choose one or more providers. PennyRouter will try them in order when available.");
   return promptFundingProviderCheckboxes(
     CLAUDE_PROVIDER_OPTIONS,
@@ -1165,6 +1196,12 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
   let openrouterApiKey = String(
     flags.openrouterApiKey || process.env.OPENROUTER_API_KEY || "",
   ).trim();
+  let proxyBaseUrl = String(
+    flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL || "",
+  ).trim();
+  let proxyApiKey = String(
+    flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY || "",
+  ).trim();
   const codexSubscriptionAuth = wantsCodex && codexProviders.has("subscription")
     ? await detectCodexChatgptAuth()
     : false;
@@ -1177,6 +1214,19 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     if (!interactive) throw new Error("OpenRouter was selected, but no key was provided.");
     openrouterApiKey = (await promptSecretish("OpenRouter API key: ")).trim();
   }
+  if (wantsClaude && claudeProviders.has("anthropic-proxy") && !(proxyBaseUrl && proxyApiKey)) {
+    if (!interactive) {
+      throw new Error(
+        "Other proxy was selected, but --proxy-base-url and --proxy-api-key were not both provided.",
+      );
+    }
+    // The URL is not a secret and is easy to mistype, so it echoes; the key does not.
+    if (!proxyBaseUrl) proxyBaseUrl = await promptText("Proxy base URL (e.g. https://proxy.example.com): ");
+    if (!proxyApiKey) proxyApiKey = (await promptSecretish("Proxy API key: ")).trim();
+    if (!proxyBaseUrl || !proxyApiKey) {
+      throw new Error("Other proxy requires both a base URL and an API key.");
+    }
+  }
   if (wantsCodex && codexProviders.has("subscription") && !codexSubscriptionAuth) {
     throw new Error(
       "ChatGPT subscription was selected, but Codex is not logged in. Run `codex login`, or select an API-key provider.",
@@ -1191,7 +1241,9 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     openrouterApiKey = (await promptSecretish("OpenRouter API key: ")).trim();
   }
 
-  if (wantsClaude && !claudeAnthropicAuth && !anthropicApiKey && !openrouterApiKey) {
+  const claudeProxyConfigured = Boolean(proxyBaseUrl && proxyApiKey);
+  if (wantsClaude && !claudeAnthropicAuth && !anthropicApiKey && !openrouterApiKey
+      && !claudeProxyConfigured) {
     if (!interactive) {
       throw new Error(
         "Claude Code requires a Claude subscription, --anthropic-api-key (or ANTHROPIC_API_KEY), "
@@ -1244,13 +1296,23 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
   if ((wantsClaude || wantsCodex) && openrouterApiKey) {
     credentials.push({ provider: "openrouter", token: openrouterApiKey });
   }
+  if (wantsClaude && claudeProxyConfigured) {
+    credentials.push({
+      provider: "anthropic_proxy",
+      token: proxyApiKey,
+      metadata: { base_url: proxyBaseUrl },
+    });
+  }
 
   return {
     credentials,
     codexSubscriptionAuth,
     claudeCredentialProvider: claudeAnthropicAuth
       ? "claude-subscription"
-      : anthropicApiKey ? "anthropic-api" : openrouterApiKey ? "openrouter" : null,
+      : anthropicApiKey ? "anthropic-api"
+      : claudeProxyConfigured ? "anthropic-proxy"
+      : openrouterApiKey ? "openrouter" : null,
+    claudeProxyBaseUrl: claudeProxyConfigured ? proxyBaseUrl : null,
     codexCredentialProvider: codexSubscriptionAuth
       ? "chatgpt-subscription"
       : openaiApiKey ? "openai-api" : openrouterApiKey ? "openrouter" : null,
@@ -1423,7 +1485,7 @@ async function uninstall(flags) {
     const ok = await runHarnessJob(failures, record.harness, "uninstall", async () => {
       if (flags.forgetToken) {
         await forgetStoredAnthropicToken(record);
-      } else if (record.anthropic_token_stored) {
+      } else if (record.anthropic_token_stored || record.proxy_base_url) {
         anthropicTokenNotice = true;
       }
       if (record.launch_available) await removePennyHarness(record.harness);
@@ -1443,7 +1505,7 @@ async function uninstall(flags) {
     await runHarnessJob(failures, record.harness, "uninstall", async () => {
       if (flags.forgetToken) {
         await forgetStoredAnthropicToken(record);
-      } else if (record.anthropic_token_stored) {
+      } else if (record.anthropic_token_stored || record.proxy_base_url) {
         anthropicTokenNotice = true;
       }
       if (record.launch_available) await removePennyHarness(record.harness);
@@ -1537,6 +1599,10 @@ async function status() {
     if (record.disabled_at) console.log(`  disabled: ${record.disabled_at}`);
     if (record.anthropic_oauth) console.log(`  Claude subscription auth: enabled (${record.token_source || "unknown"} token)`);
     if (record.openai_subscription_auth) console.log("  OpenAI subscription auth: enabled (Codex-managed login)");
+    if (record.proxy_base_url) {
+      const note = record.anthropic_oauth ? " (subscription takes precedence)" : "";
+      console.log(`  Upstream proxy: ${record.proxy_base_url}${note}`);
+    }
     if (record.launch_available) {
       const command = record.harness === "claude-code" ? "penny claude" : "penny codex";
       console.log(`  command: ${command}`);
@@ -1847,14 +1913,24 @@ function formatError(error) {
 // live config BEFORE harness.uninstall strips them. Never throws — a local uninstall
 // must not be blocked by a network hiccup; the record is going away regardless.
 async function forgetStoredAnthropicToken(record) {
-  if (record.harness !== "claude-code" || !record.anthropic_token_stored) return;
+  if (record.harness !== "claude-code") return;
+  if (!record.anthropic_token_stored && !record.proxy_base_url) return;
   try {
     const launchConfig = await loadPennyConfig();
     const globalAuth = await readClaudeCodeGatewayAuth();
     const gatewayBaseUrl = launchConfig.gateway_base_url || globalAuth.gatewayBaseUrl;
     const apiKey = launchConfig.api_key || globalAuth.apiKey;
     if (!gatewayBaseUrl || !apiKey) return;
-    await forgetAnthropicToken({ gatewayBaseUrl, apiKey });
+    if (record.anthropic_token_stored) {
+      await forgetAnthropicToken({ gatewayBaseUrl, apiKey });
+    }
+    // The proxy key is stored server-side exactly like the subscription token, so the
+    // same "forget my credentials" gesture has to clear it too.
+    if (record.proxy_base_url) {
+      await forgetUpstreamCredential({
+        gatewayBaseUrl, apiKey, provider: "anthropic_proxy",
+      });
+    }
   } catch {
     // swallow — see note above
   }
@@ -1867,6 +1943,15 @@ async function confirm(question) {
   return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
 }
 
+// Visible-echo input, for values that are not secrets. A mistyped proxy URL is a
+// confusing failure much later, so the user gets to see what they typed.
+async function promptText(question) {
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(question);
+  rl.close();
+  return answer.trim();
+}
+
 async function promptSecretish(question) {
   if (!input.isTTY || !output.isTTY) {
     const rl = createInterface({ input, output });
@@ -1986,7 +2071,7 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--local[=URL]|--prod] [--config PATH] [--allow-running-harnesses]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--proxy-base-url URL --proxy-api-key KEY] [--local[=URL]|--prod] [--config PATH] [--allow-running-harnesses]
   pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]|--prod] [--no-mcp] [--allow-running-harnesses]
   pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
@@ -2023,6 +2108,7 @@ Examples:
   npx pennyrouter install --harness claude-code --anthropic-auth --token <token>
   npx pennyrouter install --harness claude-code --anthropic-api-key <key>
   npx pennyrouter install --harness codex --openai-api-key <key>
+  npx pennyrouter install --harness claude-code --proxy-base-url https://proxy.example.com --proxy-api-key <key>
   npx pennyrouter install --openrouter-api-key <key>
   npx pennyrouter auth anthropic
   npx pennyrouter install --all

package/src/cli.test.js

@@ -121,3 +121,76 @@ test("harnessFundingChanged: no requested funding for an existing harness is not
   };
   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

@@ -17,15 +17,18 @@ export const CLAUDE_CODE_MODELS = {
   sonnet: "claude-sonnet-5[1m]",
   opus: "claude-opus-5[1m]",
   fable: "claude-fable-5[1m]",
-  custom: "Penny Custom",             // -> dynamic (PennyRouter cost-routing)
 };
 const CLAUDE_CODE_MODEL_PRESENTATION = {
-  haiku: { name: "Haiku 4.5 (PennyRouter)", description: "Fast, economical Claude model · 200K context" },
-  sonnet: { name: "Sonnet 5 (PennyRouter)", description: "Balanced Claude model · 1M context" },
-  opus: { name: "Opus 5 (PennyRouter)", description: "Most capable Claude model · 1M context" },
-  fable: { name: "Fable 5 (PennyRouter)", description: "Claude model · 1M context" },
+  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,
@@ -86,6 +89,7 @@ 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;
@@ -93,6 +97,9 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.fable;
     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;
@@ -138,11 +145,15 @@ 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;
     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;
@@ -184,11 +195,15 @@ 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;
     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;

package/src/launch.js

@@ -433,11 +433,17 @@ export function buildPennyInvocation(harness, args, config) {
     const models = item.models || {};
     env.ANTHROPIC_BASE_URL = config.gateway_base_url;
     env.ANTHROPIC_AUTH_TOKEN = config.api_key;
+    // Ask Claude Code to discover the gateway's model catalog at startup. The gateway
+    // advertises Penny-facing ids in /v1/models; this is separate from inference routing.
+    env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     delete env.ANTHROPIC_API_KEY;
     if (models.haiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = upgradeClaudeCodeModelValue(models.haiku);
     if (models.sonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = upgradeClaudeCodeModelValue(models.sonnet);
     if (models.opus) env.ANTHROPIC_DEFAULT_OPUS_MODEL = upgradeClaudeCodeModelValue(models.opus);
     if (models.fable) env.ANTHROPIC_DEFAULT_FABLE_MODEL = upgradeClaudeCodeModelValue(models.fable);
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
     writeClaudeCodeModelPresentation(env);
     // Per-model limits must come from Claude Code's recognized native model ids. This
     // global override would incorrectly give Haiku the 1M window.

package/src/launch.test.js

@@ -103,12 +103,13 @@ async function main() {
     assert.ok(!claude.args.includes("--plugin-dir"));
     assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
     assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
+    assert.equal(claude.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY, "1");
     // 1M-capable slots carry the `[1m]` suffix; Haiku has no 1M variant and stays bare.
     // Per-slot suffixes, not the global CLAUDE_CODE_MAX_CONTEXT_TOKENS override, which
     // would wrongly hand Haiku a 1M window too.
     assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5[1m]");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, "Haiku 4.5 (PennyRouter)");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, "Haiku 4.5");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, "Fast, economical Claude model · 200K context");
     assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
 

package/src/session.js

@@ -49,7 +49,7 @@ export function sleep(ms) {
 // Encrypt and store a user-owned upstream credential against the account server-side,
 // so the pr- key alone unlocks the selected harness and the provider secret is never
 // written to harness configuration.
-export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token }) {
+export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token, metadata }) {
   const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials`;
   const response = await fetch(url, {
     method: "POST",
@@ -57,7 +57,7 @@ export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider
       "content-type": "application/json",
       authorization: `Bearer ${apiKey}`,
     },
-    body: JSON.stringify({ provider, token }),
+    body: JSON.stringify({ provider, token, ...(metadata ? { metadata } : {}) }),
   });
   if (!response.ok) {
     let detail = "";
@@ -97,7 +97,7 @@ export async function probeClaudeCodeGateway({ gatewayBaseUrl, apiKey }) {
         "anthropic-beta": "compact-2026-01-12",
       },
       body: JSON.stringify({
-        model: "Sonnet 5 (PennyRouter)",
+        model: "Sonnet 5",
         max_tokens: 1,
         stream: false,
         messages: [{ role: "user", content: "Reply OK." }],
@@ -135,10 +135,10 @@ export async function probeClaudeCodeGateway({ gatewayBaseUrl, apiKey }) {
 
 // Best-effort "forget my Claude token" on uninstall. Never throws — a cleanup that
 // can't reach the network shouldn't block removing the local integration.
-export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+export async function forgetUpstreamCredential({ gatewayBaseUrl, apiKey, provider }) {
   if (!gatewayBaseUrl || !apiKey) return false;
   try {
-    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/anthropic`;
+    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/${encodeURIComponent(provider)}`;
     const response = await fetch(url, {
       method: "DELETE",
       headers: { authorization: `Bearer ${apiKey}` },
@@ -149,6 +149,10 @@ export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
   }
 }
 
+export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+  return forgetUpstreamCredential({ gatewayBaseUrl, apiKey, provider: "anthropic" });
+}
+
 function platformName() {
   if (process.platform === "darwin") return "Mac";
   if (process.platform === "win32") return "Windows";

package/src/statusline.js

@@ -11,6 +11,10 @@
 // authed with the pr- key already in Claude Code's settings). The gateway keys that
 // endpoint on the CC session uuid it sees in every request's metadata.user_id — the
 // same uuid Claude Code hands the statusline script on stdin.
+//
+// A wrapped user statusline command is cached the same way: it can be slow to spawn
+// (npx especially, and especially on Windows — see WRAP_REFRESH_MS below), so it's never
+// run inline on Claude Code's ~1s render loop.
 
 import { statePath, atomicWrite, readJsonFile, writeJsonFile } from "./state.js";
 
@@ -87,6 +91,14 @@ const stateDir = join(
   "pennyrouter",
 );
 const cacheDir = join(stateDir, "statusline-cache");
+// A wrapped user statusline command can be slow to spawn (npx especially: on Windows
+// it goes through an extra cmd.exe/npx.cmd hop and can take 2-4s per invocation, vs
+// well under 1s on macOS/Linux). Claude Code re-invokes this script every ~1s
+// (refreshInterval), so running the wrap command inline on every render blocked past
+// that interval on Windows, renders piled up, and the statusline never finished in
+// time to display at all. Cache its output and refresh it out-of-band instead, same
+// as the Penny gateway segment below.
+const WRAP_REFRESH_MS = 2000;
 
 function readJson(path) {
   try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
@@ -109,6 +121,8 @@ function claudeEnv() {
   return { base, key };
 }
 
+const config = readJson(join(stateDir, "claude-statusline.json")) || {};
+
 // --refresh <sessionId>: fetch gateway status into the cache file, then exit.
 if (process.argv[2] === "--refresh") {
   const sessionId = process.argv[3];
@@ -131,11 +145,28 @@ if (process.argv[2] === "--refresh") {
   process.exit(0);
 }
 
+// --refresh-wrap <sessionId>: run the (possibly slow) wrapped statusline command out of
+// band and cache its output. Reads the stdin JSON the main render last saw, persisted to
+// a per-session file since a detached child has no stdin of its own to read.
+if (process.argv[2] === "--refresh-wrap") {
+  const sessionId = process.argv[3];
+  if (!sessionId || !config.wrap_command) process.exit(0);
+  let wrapInput = "{}";
+  try { wrapInput = readFileSync(join(cacheDir, sessionId + ".wrap-input.json"), "utf8"); } catch { /* none yet */ }
+  const run = spawnSync(config.wrap_command, {
+    shell: true, input: wrapInput, encoding: "utf8", timeout: 20000, windowsHide: true,
+  });
+  let wrapLines = (run.stdout || "").replace(/\\n$/, "").split("\\n");
+  if (wrapLines.length === 1 && wrapLines[0] === "") wrapLines = [];
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(join(cacheDir, sessionId + ".wrap.json"), JSON.stringify({ lines: wrapLines, at: Date.now() }));
+  process.exit(0);
+}
+
 const raw = readFileSync(0, "utf8");
 let input = {};
 try { input = JSON.parse(raw); } catch { /* keep {} */ }
 const sessionId = input.session_id || "";
-const config = readJson(join(stateDir, "claude-statusline.json")) || {};
 const refreshMs = (config.refresh_seconds ?? 15) * 1000;
 
 const cachePath = join(cacheDir, sessionId + ".json");
@@ -148,7 +179,7 @@ const { base, key } = claudeEnv();
 const pennyInstalled = Boolean(base) && Boolean(key);
 if (sessionId && pennyInstalled && cacheAge > refreshMs) {
   spawn(process.execPath, [process.argv[1], "--refresh", sessionId], {
-    detached: true, stdio: "ignore",
+    detached: true, stdio: "ignore", windowsHide: true,
   }).unref();
 }
 
@@ -193,9 +224,27 @@ if (!pennyInstalled) {
 }
 
 let lines;
-if (config.wrap_command) {
+if (config.wrap_command && sessionId) {
+  const wrapCachePath = join(cacheDir, sessionId + ".wrap.json");
+  const wrapCache = readJson(wrapCachePath);
+  const wrapAge = wrapCache && typeof wrapCache.at === "number" ? Date.now() - wrapCache.at : Infinity;
+  if (wrapAge > WRAP_REFRESH_MS) {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(join(cacheDir, sessionId + ".wrap-input.json"), raw);
+    // Bump the cache timestamp before spawning: Claude Code polls every ~1s, so
+    // without this every render in the next couple seconds would see a still-stale
+    // cache and fire its own overlapping refresh while the first one is still running.
+    writeFileSync(wrapCachePath, JSON.stringify({ lines: (wrapCache && wrapCache.lines) || [], at: Date.now() }));
+    spawn(process.execPath, [process.argv[1], "--refresh-wrap", sessionId], {
+      detached: true, stdio: "ignore", windowsHide: true,
+    }).unref();
+  }
+  lines = (wrapCache && wrapCache.lines) || [];
+} else if (config.wrap_command) {
+  // No session id (e.g. a manual/interactive invocation outside Claude Code): there's
+  // no cache key to keep state under, so run inline like before caching existed.
   const run = spawnSync(config.wrap_command, {
-    shell: true, input: raw, encoding: "utf8", timeout: 5000,
+    shell: true, input: raw, encoding: "utf8", timeout: 5000, windowsHide: true,
   });
   lines = (run.stdout || "").replace(/\\n$/, "").split("\\n");
   if (lines.length === 1 && lines[0] === "") lines = [];