clauderipple 0.2.0 → 0.3.0

package/dist/router/src/config.js

@@ -6,6 +6,76 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+/**
+ * The provider's own key, re-sent under the header another wire on the same account expects.
+ *
+ * The key is never restated in a model entry, so there is exactly one copy of it to rotate and one
+ * to leak. Every other header the provider set is kept: only the auth one is replaced, because
+ * sending both conventions at once would hand the endpoint a credential it did not ask for.
+ */
+function reauthorized(headers, kind) {
+    if (!headers)
+        return headers;
+    const kept = {};
+    let key;
+    for (const [name, value] of Object.entries(headers)) {
+        const lower = name.toLowerCase();
+        if (lower === "x-api-key") {
+            key ??= value;
+            continue;
+        }
+        if (lower === "authorization") {
+            key ??= value.replace(/^Bearer\s+/i, "");
+            continue;
+        }
+        kept[name] = value;
+    }
+    // Nothing recognisable to move: leave the headers exactly as they were rather than inventing an
+    // empty credential, which would read to the endpoint as a missing key instead of a config error.
+    if (key === undefined)
+        return headers;
+    if (kind === "x-api-key")
+        kept["x-api-key"] = key;
+    else
+        kept.authorization = `Bearer ${key}`;
+    return kept;
+}
+/**
+ * The provider shape a request for `model` is actually talking to.
+ *
+ * A model may speak another wire than the rest of its provider, on another path, under another auth
+ * convention (see `ProviderModel.wire`). Those overrides are folded back into an ordinary provider
+ * here, so every `provider.type` branch downstream keeps working against one unchanged contract —
+ * and one subscription stays one provider instead of three (2026-09-22).
+ *
+ * A provider with no override for this model is returned as it is, by identity, so nothing on the
+ * ordinary path pays for this.
+ */
+export function providerFor(provider, model) {
+    if (!model || !("models" in provider) || !provider.models)
+        return provider;
+    const entry = provider.models.find((m) => m.id === model);
+    if (!entry || (entry.wire === undefined && entry.url === undefined && entry.authHeader === undefined))
+        return provider;
+    const url = entry.url ?? ("url" in provider ? provider.url : undefined);
+    const headers = entry.authHeader
+        ? reauthorized("headers" in provider ? provider.headers : undefined, entry.authHeader)
+        : ("headers" in provider ? provider.headers : undefined);
+    const shared = {
+        ...provider,
+        ...(url !== undefined ? { url } : {}),
+        ...(headers !== undefined ? { headers } : {}),
+    };
+    // Anthropic Messages needs no translation, so this model is served by the anthropic-compatible
+    // adapter instead. The two `caps` shapes do not describe the same things, and only an effort
+    // ladder carries over; the rest fall back to the strict defaults `resolveCompatibleCaps` applies,
+    // which is what the separate provider did before this.
+    if (entry.wire === "anthropic") {
+        const { wire: _wire, caps: _caps, ...rest } = shared;
+        return { ...rest, type: "anthropic-compatible", url: url ?? "", caps: { effortLevels: entry.effortLevels ?? [] } };
+    }
+    return { ...shared, type: "openai-compatible", url: url ?? "", ...(entry.wire ? { wire: entry.wire } : {}) };
+}
 export const PICKER_HOSTS_DEFAULT = ["claude.ai"];
 export function terminateHosts(c) {
     const hosts = [c.upstream];
@@ -21,7 +91,7 @@ export const DEFAULTS = {
     direct: [],
     aliases: {},
     effortClamp: { ultra: "max" },
-    cli: { extraModels: [] },
+    cli: { extraModels: [], agentFiles: true },
     health: { maxConsecutiveUpstreamFailures: 20 },
     log: { maxBytes: 5 * 1024 * 1024, keep: 3 },
 };
@@ -44,12 +114,128 @@ function merge(base, over) {
         ...(over.picker ? { picker: { ...over.picker } } : {}),
     };
 }
+/**
+ * An HTTP header value is bytes, so anything above U+00FF cannot travel in one. A key pasted with
+ * the label beside it — "API 키 sk-…" — fails deep inside the HTTP client with a message about
+ * ByteString conversion and a character code, which tells the person nothing about what they did.
+ * Returns what to say instead, or null when the value is fine.
+ */
+export function headerValueProblem(value) {
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code > 0xff)
+            return `character ${i + 1} is "${value[i]}", which cannot travel in an HTTP header — paste the key on its own, without any label or surrounding text`;
+        // A newline would split the header; a stray one usually means a copied line rather than a key.
+        if (code === 0x0a || code === 0x0d)
+            return `there is a line break at character ${i + 1} — paste the key on its own, without the line around it`;
+    }
+    return null;
+}
+/** Named once because three provider kinds report it, and a drifting copy would describe the wrong shape. */
+const MODELS_SHAPE = 'models must be entries with a string id and optional name, effortLevels, url, wire ("chat" | "responses" | "anthropic") and authHeader ("x-api-key" | "authorization-bearer")';
 function validModels(models) {
-    return Array.isArray(models) && models.every((model) => model !== null && typeof model === "object" &&
-        typeof model.id === "string" &&
-        (model.name === undefined || typeof model.name === "string") &&
-        (model.effortLevels === undefined ||
-            (Array.isArray(model.effortLevels) && model.effortLevels.every((level) => typeof level === "string"))));
+    return Array.isArray(models) && models.every((model) => {
+        if (model === null || typeof model !== "object")
+            return false;
+        const m = model;
+        if (typeof m.id !== "string")
+            return false;
+        if (m.name !== undefined && typeof m.name !== "string")
+            return false;
+        if (m.effortLevels !== undefined && (!Array.isArray(m.effortLevels) || m.effortLevels.some((level) => typeof level !== "string")))
+            return false;
+        // A model's own wire, endpoint and auth convention: wrong here and the request goes out in the
+        // wrong shape to the wrong path, which reads as a provider that rejects a working key.
+        if (m.wire !== undefined && m.wire !== "chat" && m.wire !== "responses" && m.wire !== "anthropic")
+            return false;
+        if (m.url !== undefined && (typeof m.url !== "string" || !/^https?:\/\//.test(m.url)))
+            return false;
+        if (m.authHeader !== undefined && m.authHeader !== "x-api-key" && m.authHeader !== "authorization-bearer")
+            return false;
+        return true;
+    });
+}
+/**
+ * The presets one OpenCode Go account had to be split across, and what each third actually was.
+ *
+ * Keyed on `preset` rather than on the provider's name: the GUI chose those names itself
+ * (`opencode-go-responses`) and the user may have chosen others since.
+ */
+const SPLIT_BY_PRESET = {
+    "opencode-go": { wire: "responses", authHeader: "authorization-bearer" },
+    "opencode-go-chat": { wire: "chat", authHeader: "authorization-bearer" },
+    "opencode-go-anthropic": { wire: "anthropic", authHeader: "x-api-key" },
+};
+/** The effort ladder a provider actually offered, so it can travel with the models that had it. */
+function ladderOf(p) {
+    if (p.type === "openai-compatible")
+        return p.caps?.reasoning === "effort" ? [...(p.caps.effortLevels ?? [])] : [];
+    if (p.type === "anthropic-compatible")
+        return [...(p.caps?.effortLevels ?? [])];
+    return [];
+}
+/**
+ * The three providers one OpenCode Go account used to need, read as the single provider it is.
+ *
+ * `wire` and `url` sat on the provider, so an account whose models speak Responses, Chat
+ * Completions and Anthropic Messages had to be configured three times — and every `direct` rule had
+ * to name whichever third its model lived in. A model carries its own wire now, so a config written
+ * against the old shape is folded here on the way in.
+ *
+ * Nothing is rewritten on disk. A save from the GUI is what eventually settles it, and until then
+ * this stays reversible: the file still describes what an older router would read correctly.
+ *
+ * Every model keeps its own endpoint, wire and auth convention rather than inheriting the merged
+ * provider's, so which third happens to become the base cannot change where a request goes.
+ */
+function foldSplitProviders(c) {
+    const parts = Object.entries(c.providers).filter(([, p]) => "preset" in p && typeof p.preset === "string" && p.preset in SPLIT_BY_PRESET);
+    // One of them on its own is not a split, and is left exactly as it is.
+    if (parts.length < 2)
+        return c;
+    const [baseName, baseProvider] = parts.find(([, p]) => p.preset === "opencode-go") ?? parts[0];
+    // Take the canonical name unless something outside the split already holds it.
+    const name = parts.some(([n]) => n === "opencode-go") || !("opencode-go" in c.providers) ? "opencode-go" : baseName;
+    const models = [];
+    for (const [, p] of parts) {
+        const split = SPLIT_BY_PRESET[p.preset];
+        const ladder = ladderOf(p);
+        for (const model of ("models" in p && p.models) || []) {
+            // `/models` lists every model on the plan, so the same id can appear under more than one
+            // third. The first one wins: they describe one model, and a duplicate entry would shadow it.
+            if (models.some((m) => m.id === model.id))
+                continue;
+            models.push({
+                ...model,
+                wire: split.wire,
+                authHeader: split.authHeader,
+                ...("url" in p ? { url: p.url } : {}),
+                // The merged provider's caps no longer describe this model, so the ladder its own endpoint
+                // published travels with it. Inheriting the Responses one would start sending an effort to
+                // an endpoint that never accepted one.
+                effortLevels: model.effortLevels ?? ladder,
+            });
+        }
+    }
+    const providers = {};
+    for (const [n, p] of Object.entries(c.providers))
+        if (!parts.some(([partName]) => partName === n))
+            providers[n] = p;
+    providers[name] = { ...baseProvider, preset: "opencode-go", models };
+    // Every reference to a name that has just gone follows it, or the config stops validating on a
+    // provider the user never removed.
+    const moved = new Map(parts.map(([n]) => [n, name]).filter(([from, to]) => from !== to));
+    const renamed = (of) => moved.get(of) ?? of;
+    return {
+        ...c,
+        providers,
+        direct: c.direct.map((d) => ({ ...d, provider: renamed(d.provider) })),
+        routes: Object.fromEntries(Object.entries(c.routes).map(([alias, r]) => [alias, {
+                ...r,
+                provider: renamed(r.provider),
+                ...(r.fallbacks ? { fallbacks: r.fallbacks.map((f) => ({ ...f, provider: renamed(f.provider) })) } : {}),
+            }])),
+    };
 }
 export function validate(c) {
     const errors = [];
@@ -58,6 +244,29 @@ export function validate(c) {
             errors.push(`route ${alias}: unknown provider "${r.provider}"`);
         if (!r.model)
             errors.push(`route ${alias}: missing model`);
+        // A fallback is only reached when something has already gone wrong, so a broken one is found
+        // on the worst possible day. Refuse it at save time instead.
+        if (r.fallbacks !== undefined) {
+            if (!Array.isArray(r.fallbacks))
+                errors.push(`route ${alias}: fallbacks must be a list`);
+            else
+                r.fallbacks.forEach((f, i) => {
+                    if (!f || typeof f !== "object") {
+                        errors.push(`route ${alias}: fallback ${i} must be an object`);
+                        return;
+                    }
+                    if (!c.providers[f.provider])
+                        errors.push(`route ${alias}: fallback ${i} names unknown provider "${f.provider}"`);
+                    // A native `anthropic` provider is routable only when its Claude OAuth pool is explicitly
+                    // enabled. Existing native providers remain ingress-only to avoid hijacking Claude traffic.
+                    else if (c.providers[f.provider].type === "anthropic" && !c.providers[f.provider].accountPool)
+                        errors.push(`route ${alias}: fallback ${i} names "${f.provider}", which serves the OpenAI ingress only`);
+                    if (!f.model || typeof f.model !== "string")
+                        errors.push(`route ${alias}: fallback ${i} missing model`);
+                    if (f.provider === r.provider && f.model === r.model)
+                        errors.push(`route ${alias}: fallback ${i} repeats the primary target`);
+                });
+        }
     }
     for (const d of c.direct) {
         if (!c.providers[d.provider])
@@ -70,13 +279,49 @@ export function validate(c) {
             errors.push(`provider ${name}: identity must be true or false`);
         if (shared.instructionsAppend !== undefined && typeof shared.instructionsAppend !== "string")
             errors.push(`provider ${name}: instructionsAppend must be a string`);
+        // Ids key the router's cooldown and quarantine state, so a duplicate would make two credentials
+        // share one health record and take each other down.
+        const pool = p.credentials;
+        if (pool !== undefined) {
+            if (!Array.isArray(pool))
+                errors.push(`provider ${name}: credentials must be a list`);
+            else {
+                const seen = new Set();
+                pool.forEach((entry, i) => {
+                    const cred = entry;
+                    if (!cred || typeof cred !== "object") {
+                        errors.push(`provider ${name}: credential ${i} must be an object`);
+                        return;
+                    }
+                    if (typeof cred.id !== "string" || !cred.id)
+                        errors.push(`provider ${name}: credential ${i} needs a non-empty id`);
+                    else if (seen.has(cred.id))
+                        errors.push(`provider ${name}: credential id "${cred.id}" is used twice`);
+                    else
+                        seen.add(cred.id);
+                    if (!cred.headers || typeof cred.headers !== "object" || Array.isArray(cred.headers) ||
+                        Object.values(cred.headers).some((value) => typeof value !== "string")) {
+                        errors.push(`provider ${name}: credential ${i} headers must be a string record`);
+                    }
+                    else {
+                        for (const [header, value] of Object.entries(cred.headers)) {
+                            const problem = headerValueProblem(value);
+                            if (problem)
+                                errors.push(`provider ${name}: credential ${i} header "${header}": ${problem}`);
+                        }
+                    }
+                    if (cred.label !== undefined && typeof cred.label !== "string")
+                        errors.push(`provider ${name}: credential ${i} label must be a string`);
+                });
+            }
+        }
         if (p.type === "anthropic-compatible") {
             if (!/^https?:\/\//.test(p.url))
                 errors.push(`provider ${name}: url must start with http:// or https://`);
             if (p.preset !== undefined && typeof p.preset !== "string")
                 errors.push(`provider ${name}: preset must be a string`);
             if (p.models !== undefined && !validModels(p.models)) {
-                errors.push(`provider ${name}: models must be entries with string id, optional string name, and optional string[] effortLevels`);
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
             }
             if (p.caps !== undefined) {
                 const caps = p.caps;
@@ -91,7 +336,7 @@ export function validate(c) {
         }
         else if (p.type === "chatgpt") {
             if (p.models !== undefined && !validModels(p.models)) {
-                errors.push(`provider ${name}: models must be entries with string id, optional string name, and optional string[] effortLevels`);
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
             }
             if (p.url && !/^https?:\/\//.test(p.url))
                 errors.push(`provider ${name}: url must start with http:// or https://`);
@@ -107,7 +352,7 @@ export function validate(c) {
                 errors.push(`provider ${name}: headers must be a string record`);
             }
             if (p.models !== undefined && !validModels(p.models)) {
-                errors.push(`provider ${name}: models must be entries with string id, optional string name, and optional string[] effortLevels`);
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
             }
             if (p.caps !== undefined && (!p.caps || typeof p.caps !== "object" || Array.isArray(p.caps) ||
                 (p.caps.effortLevels !== undefined && (!Array.isArray(p.caps.effortLevels) || p.caps.effortLevels.some((level) => typeof level !== "string"))) ||
@@ -120,8 +365,12 @@ export function validate(c) {
                 errors.push(`provider ${name}: auth must be "api-key" or "claude-code"`);
             if (p.apiKey !== undefined && typeof p.apiKey !== "string")
                 errors.push(`provider ${name}: apiKey must be a string`);
+            if (p.accountPool !== undefined && typeof p.accountPool !== "boolean")
+                errors.push(`provider ${name}: accountPool must be true or false`);
+            if (p.accountPool && p.auth !== "claude-code")
+                errors.push(`provider ${name}: accountPool requires auth "claude-code"`);
             if (p.models !== undefined && !validModels(p.models)) {
-                errors.push(`provider ${name}: models must be entries with string id, optional string name, and optional string[] effortLevels`);
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
             }
         }
         else {
@@ -130,6 +379,8 @@ export function validate(c) {
     }
     if (!(c.listen.port > 0 && c.listen.port < 65536))
         errors.push("listen.port out of range");
+    if (c.cli.agentFiles !== undefined && typeof c.cli.agentFiles !== "boolean")
+        errors.push("cli.agentFiles must be true or false");
     if (c.listen.openaiPort !== undefined && !(c.listen.openaiPort >= 0 && c.listen.openaiPort < 65536))
         errors.push("listen.openaiPort out of range");
     return errors;
@@ -164,7 +415,9 @@ export class ConfigStore {
             return;
         try {
             const parsed = JSON.parse(fs.readFileSync(this.file, "utf8"));
-            const next = merge(DEFAULTS, parsed);
+            // Folded before validation, because the old three-provider shape is what is on disk and the
+            // references it carries have to be the ones that get checked.
+            const next = foldSplitProviders(merge(DEFAULTS, parsed));
             const errors = validate(next);
             if (errors.length === 0 || initial)
                 this.current = next;

package/dist/router/src/index.js

@@ -9,6 +9,7 @@ import path from "node:path";
 import { codexEnabled, writeCodexCatalog } from "../../cli/src/codex.js";
 import { ingressModels } from "./ingress/models.js";
 import { ConfigStore, configPath, homeDir, terminateHosts } from "./config.js";
+import { defaultAgentDir, syncAgentFiles } from "./agents.js";
 import { CertStore } from "./certs.js";
 import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
@@ -40,6 +41,14 @@ const store = new ConfigStore(undefined, (c, errors) => {
     catch (e) {
         log?.warn(`codex catalog: ${e.message}`);
     }
+    // One place for the truth: the agent files a worker's model comes from are derived from this
+    // config, so a model ticked here cannot disagree with the alias a marker resolves to.
+    try {
+        syncAgentFiles(c, defaultAgentDir(), log ?? console);
+    }
+    catch (e) {
+        (log ?? console).warn(`agent files: ${e.message}`);
+    }
 });
 const cfg0 = store.get();
 log = new Logger(logFile, cfg0.log.maxBytes, cfg0.log.keep, !!process.env.CLAUDERIPPLE_ECHO || !logFile);
@@ -122,6 +131,9 @@ proxy
         ` (startup ${since(T_EXEC)}ms: node ${T_MODULE - T_EXEC}, config ${T_CONFIG - T_MODULE}, listen ${since(T_CONFIG)})`);
     const ingressPort = await ingress.listen();
     log.info(`clauderipple OpenAI ingress listening on 127.0.0.1:${ingressPort}`);
+    // Quota only arrives on GPT response headers, so a quiet day left the status 11 hours stale
+    // (2026-09-20). Ask once now, after listen(), and never wait for the answer.
+    proxy.chatgptRefreshAll();
     const admin = await startAdmin({
         config: () => store.get(),
         configFile: configPath(),
@@ -130,7 +142,8 @@ proxy
         health: () => health.consecutiveFailures,
         version: VERSION,
         requests,
-        chatgpt: () => ({ quota: proxy.chatgptRateLimits, auth: proxy.chatgptAuthStatus() }),
+        chatgpt: () => ({ quota: proxy.chatgptRateLimits, auth: proxy.chatgptAuthStatus(), refresh: (name) => proxy.chatgptFetchRateLimits(name), models: (name) => proxy.chatgptFetchModels(name) }),
+        credentials: () => proxy.credentialHealth(),
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         shutdown: () => beginDrain("shutdown requested"),

package/dist/router/src/ingress/server.js

@@ -3,6 +3,9 @@
 // intentionally never copied to the Anthropic-compatible upstream.
 import http from "node:http";
 import https from "node:https";
+import os from "node:os";
+import path from "node:path";
+import { providerFor } from "../config.js";
 import { resolve } from "../routing.js";
 import { PRESETS } from "../presets.js";
 import { resolveCompatibleCaps, sanitizeForCompatible } from "../compat.js";
@@ -10,7 +13,8 @@ import { SseParser } from "../providers/chatgpt/sse.js";
 import { ingressModels } from "./models.js";
 import { requestId } from "../requestlog.js";
 import { credentialHeaderValues, redactErrorText } from "../redact.js";
-import { CLAUDE_CODE_IDENTITY, ClaudeCodeAuthStore, fromClaudeCodeToolName, nativeAnthropicHeaders, observedAnthropicHeaders, toClaudeCodeToolName } from "../providers/anthropic.js";
+import { CLAUDE_CODE_IDENTITY, fromClaudeCodeToolName, nativeAnthropicHeaders, toClaudeCodeToolName } from "../providers/anthropic.js";
+import { ClaudeAccountAuthPool } from "../providers/anthropic-account-pool.js";
 import { ObservedClaudeCodeAuth } from "../providers/anthropic-observed.js";
 import { ResponsesEventMapper, chatToAnthropic, formatDataSse, formatSse, responsesEventsToChatChunks, responsesToAnthropic, responsesToChatCompletion, } from "./translate.js";
 const MAX_BODY = 64 * 1024 * 1024;
@@ -91,15 +95,15 @@ export class OpenAiIngress {
     server;
     agents = new Map();
     sockets = new Set();
-    claudeCodeAuth;
+    claudeAccounts;
     deps;
     draining = false;
     constructor(deps) {
         this.deps = deps;
-        this.claudeCodeAuth = new ClaudeCodeAuthStore(undefined, {
+        this.claudeAccounts = deps.claudeAccounts ?? new ClaudeAccountAuthPool({
+            home: deps.home ?? (process.env.CLAUDERIPPLE_HOME?.trim() || path.join(os.homedir(), ".clauderipple")),
             ...(deps.observedClaudeCodeAuth ? { observed: deps.observedClaudeCodeAuth } : {}),
-            ...(deps.home ? { home: deps.home } : {}),
-            log: (line) => deps.log.info(line),
+            log: deps.log,
         });
         this.server = http.createServer({ maxHeaderSize: 64 * 1024 }, (req, res) => void this.handle(req, res));
         this.server.keepAliveTimeout = 65_000;
@@ -244,12 +248,16 @@ export class OpenAiIngress {
                 finish(400, bytes);
                 return;
             }
-            const provider = cfg.providers[route.provider];
-            if (!provider) {
+            const configured = cfg.providers[route.provider];
+            if (!configured) {
                 const bytes = sendJson(res, 500, openAiError(`Configured provider ${route.provider} is missing`, "server_error"));
                 finish(500, bytes);
                 return;
             }
+            // A model that speaks Anthropic Messages is servable here even when the rest of its provider
+            // is an OpenAI wire, which the refusal below would otherwise turn away on the provider's type
+            // alone. One subscription is one provider, so the model decides.
+            const provider = providerFor(configured, route.model);
             if (provider.type === "chatgpt" || provider.type === "openai-compatible") {
                 const bytes = sendJson(res, 400, openAiError(`${provider.type === "chatgpt" ? "ChatGPT" : "OpenAI-compatible"} provider is not available through OpenAI ingress`, "invalid_request_error", "unsupported_provider"));
                 finish(400, bytes, { note: `model ${requested} -> ${provider.type} provider unsupported` });
@@ -291,16 +299,18 @@ export class OpenAiIngress {
     }
     async forward(res, provider, wire, model, chat, stream, onTerminal) {
         const native = provider.type === "anthropic";
-        const upstream = new URL(native ? "https://api.anthropic.com" : provider.url);
+        const upstream = new URL(native ? (this.deps.nativeUpstream ?? "https://api.anthropic.com") : provider.url);
         const protocol = upstream.protocol === "https:" ? "https:" : "http:";
         const body = Buffer.from(JSON.stringify(wire));
         let authentication;
         if (native && provider.auth === "claude-code") {
-            await this.claudeCodeAuth.refreshIfNeeded();
-            const auth = this.claudeCodeAuth.get();
-            if (auth instanceof Error)
-                return { status: 401, bytes: sendJson(res, 401, openAiError(auth.message, "authentication_error")), note: "Claude Code OAuth unavailable" };
-            authentication = auth.source === "observed" ? observedAnthropicHeaders(auth.observed) : nativeAnthropicHeaders(provider, auth.credentials);
+            // Codex ingress deliberately uses one credential per request and does not fail over. The shared
+            // projection preserves source precedence and keeps ClaudeRipple's added accounts as the fallback
+            // that the old single OAuth file provided before multi-account storage.
+            const credential = (await this.claudeAccounts.credentials())[0];
+            if (!credential)
+                return { status: 401, bytes: sendJson(res, 401, openAiError("Claude login unavailable — connect a Claude subscription", "authentication_error")), note: "Claude OAuth unavailable" };
+            authentication = credential.headers;
         }
         else if (native) {
             try {
@@ -315,7 +325,7 @@ export class OpenAiIngress {
         const headers = { "content-type": "application/json", accept: stream ? "text/event-stream" : "application/json", "content-length": String(body.length), ...authentication };
         const lib = protocol === "https:" ? https : http;
         const response = await new Promise((resolveP, reject) => {
-            const request = lib.request({ protocol, hostname: upstream.hostname, port: Number(upstream.port) || (protocol === "https:" ? 443 : 80), method: "POST", path: `${upstream.pathname.replace(/\/+$/, "")}/v1/messages`, headers, agent: this.agentFor(native ? "https://api.anthropic.com" : provider.url, protocol), ...(protocol === "https:" ? { servername: upstream.hostname } : {}) }, resolveP);
+            const request = lib.request({ protocol, hostname: upstream.hostname, port: Number(upstream.port) || (protocol === "https:" ? 443 : 80), method: "POST", path: `${upstream.pathname.replace(/\/+$/, "")}/v1/messages`, headers, agent: this.agentFor(upstream.origin, protocol), ...(protocol === "https:" ? { servername: upstream.hostname } : {}) }, resolveP);
             request.once("error", reject);
             res.once("close", () => request.destroy());
             request.end(body);

package/dist/router/src/picker.js

@@ -48,6 +48,11 @@ export function injectPickerModels(json, extra, contextWindow) {
             if (existing.has(e.model))
                 continue;
             const entry = { ...structuredClone(template), id: e.model, name: e.name };
+            const w = e.contextWindow ?? contextWindow;
+            if (w)
+                entry.context_window = w;
+            else
+                delete entry.context_window;
             if (e.description)
                 entry.description = e.description;
             else
@@ -58,12 +63,15 @@ export function injectPickerModels(json, extra, contextWindow) {
             surface.models.push(entry);
             result.injected++;
         }
-        if (contextWindow) {
-            for (const key of ["context_window_by_model", "contextWindowByModel"]) {
-                const map = surface[key];
-                if (map && typeof map === "object")
-                    for (const e of extra)
-                        map[e.model] = contextWindow;
+        // Per-entry window first: routed models do not share one, and `contextWindow` is only the fallback.
+        for (const key of ["context_window_by_model", "contextWindowByModel"]) {
+            const map = surface[key];
+            if (!map || typeof map !== "object")
+                continue;
+            for (const e of extra) {
+                const w = e.contextWindow ?? contextWindow;
+                if (w)
+                    map[e.model] = w;
             }
         }
         const recorded = result.surfaces[result.surfaces.length - 1];