llm-switcher 1.6.11 → 1.6.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.12 — 2026-10-11
+
+- **Reasoning from an aborted turn.** In a Codex request, reasoning that waits for an assistant turn is dropped at the next user message. Separate reasoning items are joined with a newline.
+- **Token counts with separators.** A context overflow message with `131,072`, `131.072`, `131 072` or `131_072` gives the full number to Claude Code. A message without numbers keeps the plain form.
+- **Context overflow over WebSocket.** A Codex turn on WebSocket fails with the code `context_length_exceeded`, the same as on HTTP.
+- **Goal check and images.** The goal-check request to a chat upstream uses the same image retry as other requests.
+- **Output limit cache.** The output limit comes only from the cache entry of the same profile, and only when the entry is less than one hour old. The cache key ignores the case of scheme and host and a trailing slash. A new model list is merged per model, so a list with only output limits keeps the cached windows. A cached output limit is kept only while the newest list still states it.
+- **System messages on the direct Anthropic route.** A `system` message inside `messages` is no longer lost. Its text goes into the next user turn, or into the previous one if no user turn follows, with the prefix `[system] `.
+- **Gemini `_placeholder` in tool calls.** If the model fills the `_placeholder` property that the proxy added, the proxy removes it from the arguments. This applies to stream and non-stream answers for every client format, Code Assist (agy) included, and only where the proxy added the property.
+- **Test temp files.** The tests delete all their temp directories, also when a test fails. `npm test` deletes the `node-compile-cache` directory that npm made at the start of the run.
+- **`replayReasoning` documentation.** The README files now say that `reasoning_content` goes out only on a request with thinking on.
+
 ## Release 1.6.11 — 2026-10-11
 
 - **Output limit.** The proxy keeps the output limit of each model from the `/models` list of the profile (`max_output_tokens` or `top_provider.max_completion_tokens`) in `model-windows.json`. If the client asks for more tokens than this limit, the proxy sends the limit. This applies to `max_tokens`, `max_completion_tokens` and `maxOutputTokens`. If the limit is not known, the value does not change. The limit does not apply to the anthropic-to-anthropic passthrough (direct mode, outFormat `anthropic`, and the native goal-check request). These requests go to the upstream unchanged.

package/README.md

@@ -869,7 +869,7 @@ Because of this split, a provider fingerprint is never a rule in this gateway. I
 | `LLM_SWITCHER_BIFROST_RETRY_MS` | Time before the gateway asks intact again after a failed Bifrost lookup (default 30000 ms). |
 | `x-llm-profile: <key>` header (alias `x-profile`) or `?profile=<key>` | Route a single request through a specific profile. An unknown key returns HTTP 400 instead of silently falling back. |
 | `profile.thinkingMode` | `auto` (default, for gateways like intact or 9Router): restore stripped thinking, inject a `<think>` guide for non-reasoning models, send `thinking` + `reasoning_effort`, and send the earlier thinking as `reasoning_content` on assistant tool-call turns. `native` (strict OpenAI APIs): send only `reasoning_effort` when the client asks, never touch the prompt, use `max_completion_tokens`. Native mode never sends `reasoning_content` unless the profile sets `replayReasoning: true`. `off`: never send reasoning parameters. |
-| `profile.replayReasoning` | `true` sends the earlier thinking as `reasoning_content` on assistant tool-call turns in `native` mode. DeepSeek and Kimi thinking mode need it. The default is `false`. `auto` mode always sends the field, and `off` never sends it. The model name and the client request do not change this rule. |
+| `profile.replayReasoning` | `true` sends the earlier thinking as `reasoning_content` on assistant tool-call turns in `native` mode. DeepSeek and Kimi thinking mode need it. The default is `false`. The field goes out only on a request with thinking on. In `native` mode, thinking is on when the client asks for it. In `auto` mode, the flag is not needed: thinking is on when the client asks for it, or when the model reasons natively and the client did not turn thinking off. `off` never sends the field. |
 | `profile.thinkingEffort` | `auto` (default, caller/client controls effort), or an explicit override level: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`. Overrides client effort before routing upstream. Automatically maps to the nearest equivalent level accepted by the target upstream (e.g. OpenAI ceiling `high`, Anthropic `max`, Gemini budget bounds). In the Web UI, this selector dynamically hides with a guidance hint when Bifrost passthrough is active. |
 | `profile.endpoints.countTokens` | Override the Anthropic `count_tokens` URL. |
 | `profile.endpoints` | Override upstream URLs per format: `{ "openai-chat": "...", "anthropic": "...", "vertex": "https://.../models/{model}:{action}" }`. |

package/README.vi.md

@@ -864,7 +864,7 @@ Nhờ cách chia này, fingerprint của provider không bao giờ là rule tron
 | `LLM_SWITCHER_BIFROST_RETRY_MS` | Thời gian trước khi gateway hỏi lại intact sau một lần tra cứu Bifrost thất bại (mặc định 30000 ms). |
 | Header `x-llm-profile: <key>` (tên khác `x-profile`) hoặc `?profile=<key>` | Định tuyến riêng 1 request qua profile chỉ định. Key không tồn tại trả HTTP 400 thay vì âm thầm dùng profile khác. |
 | `profile.thinkingMode` | `auto` (mặc định, cho gateway như intact hoặc 9Router): phục hồi thinking bị xoá, inject hướng dẫn `<think>` cho model không có reasoning, gửi `thinking` + `reasoning_effort`, và gửi lại thinking trước đó thành `reasoning_content` ở lượt assistant có tool call. `native` (API OpenAI nghiêm ngặt): chỉ gửi `reasoning_effort` khi client yêu cầu, không sửa prompt, dùng `max_completion_tokens`; không gửi `reasoning_content` trừ khi profile đặt `replayReasoning: true`. `off`: không bao giờ gửi tham số reasoning. |
-| `profile.replayReasoning` | `true`: ở chế độ `native`, gửi lại thinking trước đó thành `reasoning_content` ở lượt assistant có tool call. Thinking mode của DeepSeek và Kimi cần field này. Mặc định là `false`. `auto` luôn gửi, `off` không bao giờ gửi. Tên model và request của client không đổi quy tắc này. |
+| `profile.replayReasoning` | `true`: ở chế độ `native`, gửi lại thinking trước đó thành `reasoning_content` ở lượt assistant có tool call. Thinking mode của DeepSeek và Kimi cần field này. Mặc định là `false`. Field chỉ được gửi khi request bật thinking. Ở `native`, thinking bật khi client yêu cầu. Ở `auto`, không cần cờ này: thinking bật khi client yêu cầu, hoặc khi model có reasoning sẵn và client không tắt thinking. `off` không bao giờ gửi field này. |
 | `profile.thinkingEffort` | `auto` (mặc định, client tự quyết định), hoặc đặt cố định mức override: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`. Ghi đè mức reasoning effort từ công cụ trước khi gửi lên upstream. Tự động ánh xạ về mức tương đương gần nhất mà upstream đích hỗ trợ (OpenAI trần `high`, Anthropic trần `max`, Gemini điều chỉnh `thinkingBudget`). Trên Web UI, tùy chọn này tự động ẩn cùng thông báo gợi ý khi profile bật chế độ Bifrost passthrough. |
 | `profile.endpoints.countTokens` | Ghi đè URL `count_tokens` của Anthropic. |
 | `profile.endpoints` | Ghi đè URL upstream theo từng format: `{ "openai-chat": "...", "anthropic": "...", "vertex": "https://.../models/{model}:{action}" }`. |

package/formats.mjs

@@ -693,10 +693,12 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
     if (text) ir.system = ir.system ? `${ir.system}\n\n${text}` : text;
   };
 
-  // A reasoning item precedes the assistant output it belongs to.
+  // A reasoning item precedes the assistant output it belongs to. A user message ends that turn,
+  // so reasoning still pending there came from an aborted turn and is dropped.
   let reasoning = '';
+  const joinLines = (a, b) => (a ? `${a}\n${b}` : b);
   const takeReasoning = (m) => {
-    if (reasoning && m?.role === 'assistant') { m.reasoning = (m.reasoning || '') + reasoning; reasoning = ''; }
+    if (reasoning && m?.role === 'assistant') { m.reasoning = joinLines(m.reasoning || '', reasoning); reasoning = ''; }
   };
 
   // Parallel tool calls arrive as consecutive items -> merge into 1 assistant turn,
@@ -715,7 +717,7 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
     ir.messages.push({ role: 'user', content: input });
   } else if (Array.isArray(input)) {
     for (const item of input) {
-      if (typeof item === 'string') { pushText('user', item); continue; }
+      if (typeof item === 'string') { reasoning = ''; pushText('user', item); continue; }
       if (!item || typeof item !== 'object') continue;
       // EasyInputMessage ({role, content}) doesn't require `type`.
       if (item.type === 'message' || (!item.type && item.role)) {
@@ -739,6 +741,7 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
           continue;
         }
         const role = item.role === 'assistant' ? 'assistant' : 'user';
+        if (role === 'user') reasoning = '';
         if (parts.every(p => p.type === 'text')) {
           pushText(role, parts.map(p => p.text).join('\n'));
         } else {
@@ -747,7 +750,7 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
         if (role === 'assistant') takeReasoning(ir.messages[ir.messages.length - 1]);
       } else if (item.type === 'reasoning') {
         const texts = (Array.isArray(item.summary) ? item.summary : []).map(x => x?.text).filter(t => typeof t === 'string' && t);
-        reasoning += texts.join('\n');
+        if (texts.length) reasoning = joinLines(reasoning, texts.join('\n'));
       } else if (item.type === 'function_call') {
         pushCall({ id: item.call_id || item.id || null, name: responsesToolName(item.namespace, item.name), args: parseArgs(item.arguments) });
       } else if (item.type === 'custom_tool_call') {
@@ -1560,6 +1563,83 @@ function collapseNullableUnion(branches) {
 // key keeps the type an object; the root of a tool with no arguments may stay empty.
 const GEMINI_PLACEHOLDER_PROPERTIES = { _placeholder: { type: 'boolean', description: 'Unused. Leave unset.' } };
 
+// A node the padding produced: its only property is the placeholder. Matched by shape, not by
+// reference, because the schema is deep-copied again before it is sent.
+function isGeminiPadded(schema) {
+  const props = schema?.properties;
+  const p = props?._placeholder;
+  return Boolean(p && Object.keys(props).length === 1 && p.type === GEMINI_PLACEHOLDER_PROPERTIES._placeholder.type
+    && p.description === GEMINI_PLACEHOLDER_PROPERTIES._placeholder.description);
+}
+
+// Removes `_placeholder` from the arguments wherever the schema sent upstream was padded, and only there.
+export function stripGeminiPlaceholders(value, schema) {
+  if (!value || typeof value !== 'object' || !schema || typeof schema !== 'object') return value;
+  if (Array.isArray(value)) {
+    if (!schema.items) return value;
+    const out = value.map(v => stripGeminiPlaceholders(v, schema.items));
+    return out.some((v, i) => v !== value[i]) ? out : value;
+  }
+  if (isGeminiPadded(schema)) {
+    if (!Object.hasOwn(value, '_placeholder')) return value;
+    const { _placeholder, ...rest } = value;
+    return rest;
+  }
+  let out = value;
+  const props = schema.properties && typeof schema.properties === 'object' ? schema.properties : {};
+  for (const [k, v] of Object.entries(value)) {
+    if (!Object.hasOwn(props, k)) continue;
+    const next = stripGeminiPlaceholders(v, props[k]);
+    if (next !== v) out = { ...out, [k]: next };
+  }
+  for (const branch of Array.isArray(schema.anyOf) ? schema.anyOf : []) out = stripGeminiPlaceholders(out, branch);
+  return out;
+}
+
+function hasGeminiPadding(schema) {
+  if (!schema || typeof schema !== 'object') return false;
+  if (isGeminiPadded(schema)) return true;
+  return Object.values(schema.properties || {}).some(hasGeminiPadding) || hasGeminiPadding(schema.items)
+    || (Array.isArray(schema.anyOf) && schema.anyOf.some(hasGeminiPadding));
+}
+
+// The upstream tool name -> the schema sent, for each tool whose schema was padded. Reads both the
+// Vertex and the chat body shape; an empty map means no argument needs the strip.
+export function geminiPaddedTools(upBody) {
+  const padded = new Map();
+  for (const t of Array.isArray(upBody?.tools) ? upBody.tools : []) {
+    const decls = Array.isArray(t?.functionDeclarations) ? t.functionDeclarations : t?.function ? [t.function] : [];
+    for (const d of decls) if (d?.name && hasGeminiPadding(d.parameters)) padded.set(d.name, d.parameters);
+  }
+  return padded;
+}
+
+// The tool vocabulary, plus the strip for padded tools. A renderer holds the arguments of a tool
+// whose needsArgsRewrite is true until the JSON is whole, so the strip also works on a stream.
+export function withGeminiPlaceholderStrip(vocab, padded) {
+  if (!padded?.size) return vocab;
+  const schemaOf = (name) => padded.get(name) || padded.get(vocab.name(name))
+    || [...padded].find(([upstream]) => vocab.name(upstream) === name)?.[1];
+  const args = (name, argsJson) => {
+    const out = vocab.args(name, argsJson);
+    const schema = schemaOf(name);
+    if (!schema) return out;
+    let parsed;
+    try { parsed = JSON.parse(out || '{}'); } catch { return out; }
+    const stripped = stripGeminiPlaceholders(parsed, schema);
+    return stripped === parsed ? out : JSON.stringify(stripped);
+  };
+  return {
+    ...vocab,
+    args,
+    needsArgsRewrite: (name) => Boolean(schemaOf(name)) || Boolean(vocab.needsArgsRewrite?.(name)),
+    repair(upstream, argsJson) {
+      const fixedName = vocab.name(upstream);
+      return { name: fixedName, args: args(upstream, argsJson), renamed: fixedName !== upstream };
+    }
+  };
+}
+
 function toGeminiSchema(schema, root, seen) {
   const nested = Boolean(root);
   const emptyProperties = () => (nested ? { ...GEMINI_PLACEHOLDER_PROPERTIES } : {});
@@ -1744,8 +1824,29 @@ function endsInUnsignedToolLoop(messages) {
 function healAnthropicPayload(payload) {
   const notes = [];
   if (!payload || !Array.isArray(payload.messages)) return { payload, changed: false, notes };
-  const src = payload.messages.filter(m => m && (m.role === 'user' || m.role === 'assistant'));
-  let changed = src.length !== payload.messages.length;
+  // Anthropic has no system role inside messages. Its text joins the next user turn (else the previous
+  // one) after the other blocks, because a tool_result must stay first in its turn.
+  const src = [];
+  let pendingSystem = [];
+  const withSystem = (m) => ({ ...m, content: [...toAnthropicBlocks(m.content), ...pendingSystem] });
+  for (const m of payload.messages) {
+    if (m?.role === 'system') {
+      const text = toAnthropicBlocks(m.content).filter(b => b.type === 'text' && !isBlankText(b)).map(b => b.text).join('\n');
+      if (text) pendingSystem.push({ type: 'text', text: `[system] ${text}` });
+      continue;
+    }
+    if (!m || (m.role !== 'user' && m.role !== 'assistant')) continue;
+    if (m.role === 'user' && pendingSystem.length) { src.push(withSystem(m)); pendingSystem = []; continue; }
+    src.push(m);
+  }
+  if (pendingSystem.length) {
+    const i = src.findLastIndex(m => m.role === 'user');
+    if (i >= 0) src[i] = withSystem(src[i]);
+    else src.unshift({ role: 'user', content: pendingSystem });
+  }
+  const hadSystem = payload.messages.some(m => m?.role === 'system');
+  if (hadSystem) notes.push('folded system messages into user turns');
+  let changed = hadSystem || src.length !== payload.messages.length;
 
   let system = payload.system;
   if (Array.isArray(system) && system.some(isBlankText)) {
@@ -2753,7 +2854,7 @@ function vertexUsage(prompt, completion, cached, reasoning) {
   return u;
 }
 
-function buildVertexMessage({ model, think, text, tools, finish, prompt, completion, cached, reasoning, sig, ids = false }) {
+function buildVertexMessage({ model, think, text, tools, finish, prompt, completion, cached, reasoning, sig, ids = false, vocab = null }) {
   const parts = [];
   const thinking = (think || []).join('');
   if (thinking) {
@@ -2764,7 +2865,8 @@ function buildVertexMessage({ model, think, text, tools, finish, prompt, complet
   const body = (text || []).join('');
   if (body) parts.push({ text: body });
   for (const tc of (tools || [])) {
-    const part = { functionCall: { ...(ids && tc.id ? { id: tc.id } : {}), name: tc.name || 'tool', args: parseArgs(tc.args) } };
+    const args = vocab && typeof tc.args === 'string' ? vocab.args(tc.name, tc.args) : tc.args;
+    const part = { functionCall: { ...(ids && tc.id ? { id: tc.id } : {}), name: tc.name || 'tool', args: parseArgs(args) } };
     const tsig = tc.sig || lookupToolSignature(tc.id);
     if (tsig) part.thoughtSignature = tsig;
     parts.push(part);
@@ -2778,7 +2880,7 @@ function buildVertexMessage({ model, think, text, tools, finish, prompt, complet
 }
 
 // ids: name each functionCall, as Code Assist does. Plain Vertex has no call id.
-function createVertexStream(emit, model, { ids = false } = {}) {
+function createVertexStream(emit, model, { ids = false, vocab = null } = {}) {
   const cand = (parts) => emit(null, { candidates: [{ content: { role: 'model', parts }, index: 0 }], modelVersion: model });
   // Tool args arrive from OpenAI/Anthropic as deltas; Vertex needs complete functionCalls -> buffer them, emit at the end.
   const tools = new Map();
@@ -2805,7 +2907,8 @@ function createVertexStream(emit, model, { ids = false } = {}) {
       const parts = [...tools.values()]
         .filter(t => t.name)
         .map(t => {
-          const part = { functionCall: { ...(ids && t.id ? { id: t.id } : {}), name: t.name, args: parseArgs(t.args || '{}') } };
+          const args = vocab ? vocab.args(t.name, t.args || '{}') : (t.args || '{}');
+          const part = { functionCall: { ...(ids && t.id ? { id: t.id } : {}), name: t.name, args: parseArgs(args) } };
           const tsig = t.sig || lookupToolSignature(t.id);
           if (tsig) part.thoughtSignature = tsig;
           return part;
@@ -2830,10 +2933,10 @@ function codeAssistTrace() {
   return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
 }
 
-function createCodeAssistStream(emit, model) {
+function createCodeAssistStream(emit, model, { vocab = null } = {}) {
   const traceId = codeAssistTrace();
   const responseId = `agy-${traceId}`;
-  return createVertexStream((e, d) => emit(e, d?.error ? d : { response: { ...d, responseId }, traceId }), model, { ids: true });
+  return createVertexStream((e, d) => emit(e, d?.error ? d : { response: { ...d, responseId }, traceId }), model, { ids: true, vocab });
 }
 
 function buildCodeAssistMessage(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.11",
+  "version": "1.6.12",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -11,6 +11,7 @@ import { createFrameReader } from './blindfold/wsframe.mjs';
 import {
   OUT_FORMATS, parseToIR, emitUpstreamBody, irToAnthropicBody, createUpstreamNormalizer, createCollector,
   createThinkTagSplitter, splitThinkTags, healAnthropicPayload, estimateTokens, THINKING_MODES, VALID_EFFORTS,
+  geminiPaddedTools, withGeminiPlaceholderStrip,
   toGeminiSchema, isAntigravityModel, refusesImageInput, omitChatImages,
   createAnthropicStream, createChatStream, createResponsesStream, createVertexStream,
   buildAnthropicMessage, buildChatMessage, buildResponsesMessage, buildVertexMessage,
@@ -26,7 +27,7 @@ import {
   codexModelEntry,
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
-import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows, readWindowsCache } from './windows.mjs';
+import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows, windowsCacheKey, cachedProfileWindows } from './windows.mjs';
 import { createToolVocab, NULL_TOOL_VOCAB, toolNameMapForIR } from './toolvocab.mjs';
 import { readUpstreamPayloads } from './upstream-stream.mjs';
 import { compactionResponse, emitCompaction, expandGatewayCompactions, collectCompaction } from './compaction.mjs';
@@ -386,10 +387,15 @@ function isContextOverflow(status, message) {
 }
 
 // Claude Code compacts on "prompt is too long: N tokens > M maximum", so the numbers lead when the upstream names them.
+// A count may group its digits ("131,072", "131.072", "131 072", "131_072"); the group form is tried first.
+const TOKEN_COUNT = String.raw`(\d{1,3}(?:[,. _]\d{3})+(?!\d)|\d+)`;
+const MAX_TOKENS_RE = new RegExp(String.raw`(?:maximum context length|context window|limit) (?:is |of )?` + TOKEN_COUNT, 'i');
+const ASKED_TOKENS_RE = new RegExp(String.raw`(?:requested|resulted in|prompt (?:is|has|contains)|input (?:is|has)) (?:about )?` + TOKEN_COUNT, 'i');
+
 function promptTooLongMessage(message) {
   if (/^prompt is too long/i.test(message)) return message;
-  const max = message.match(/(?:maximum context length|context window|limit) (?:is |of )?(\d+)/i)?.[1];
-  const asked = message.match(/(?:requested|resulted in|prompt (?:is|has|contains)|input (?:is|has)) (?:about )?(\d+)/i)?.[1];
+  const max = message.match(MAX_TOKENS_RE)?.[1]?.replace(/\D/g, '');
+  const asked = message.match(ASKED_TOKENS_RE)?.[1]?.replace(/\D/g, '');
   return max && asked ? `prompt is too long: ${asked} tokens > ${max} maximum (${message})` : `prompt is too long: ${message}`;
 }
 
@@ -494,15 +500,18 @@ function upstreamEndpoint(profile, outFormat, model, stream, req) {
 // declared none pays nothing and a turn where the model agreed with the list changes nothing.
 function toolVocabFor(ir, outFormat) {
   if (!ir || typeof ir !== 'object') return NULL_TOOL_VOCAB;
-  if (!ir._vocab) ir._vocab = createToolVocab(ir.tools, { allowHyphens: outFormat !== 'vertex', names: [...toolNameMapForIR(ir).forward.keys()] });
+  if (!ir._vocab) {
+    const vocab = createToolVocab(ir.tools, { allowHyphens: outFormat !== 'vertex', names: [...toolNameMapForIR(ir).forward.keys()] });
+    ir._vocab = withGeminiPlaceholderStrip(vocab, ir._geminiPadded);
+  }
   return ir._vocab;
 }
 
 function clientRenderer(clientFormat, res, model, opts = {}) {
   if (clientFormat === 'anthropic') return createAnthropicStream((e, d) => sendSSE(res, e, d), model, opts);
   if (clientFormat === 'responses') return createResponsesStream((e, d) => sendSSE(res, e, d), model, opts);
-  if (clientFormat === 'vertex') return createVertexStream((e, d) => sendSSE(res, null, d), model);
-  if (clientFormat === 'codeassist') return createCodeAssistStream((e, d) => sendSSE(res, null, d), model);
+  if (clientFormat === 'vertex') return createVertexStream((e, d) => sendSSE(res, null, d), model, opts);
+  if (clientFormat === 'codeassist') return createCodeAssistStream((e, d) => sendSSE(res, null, d), model, opts);
   return createChatStream((e, d) => sendSSE(res, null, d), model, opts);
 }
 
@@ -781,7 +790,7 @@ async function maybeCompactIdle(req, clientFormat, payload, ir, profile, profile
     const summaryModel = mapModel(policy.model, profile, clientFormat);
     const summaryFormat = resolveOutFormat(profile, summaryModel);
     askSummary({ ir: prefixIR, policy, profile, model: summaryModel,
-      build: (prof, model, summaryIR) => buildUpstreamRequest(prof, summaryFormat, summaryIR, model, req),
+      build: (prof, model, summaryIR) => buildUpstreamRequest(prof, summaryFormat, summaryIR, model, req, null, profileKey),
       onDiagnostic: ({ code, status }) => console.warn(`[llm-switcher] idle compact ${key.slice(0, 12)}: ${code}${status ? ` (${status})` : ''}`),
     }).then(summary => {
       if (!summary) return;
@@ -828,30 +837,29 @@ function resolveThinkingEffort(profile, slot, mappedModel) {
   return profile?.thinkingEffort || 'auto';
 }
 
-// The output limit the profile's own model list names for this model, or 0 when no cached list
-// names one. The cache is filled by /v1/models; this only reads it.
-function modelOutputLimit(profile, mappedModel) {
+// The output limit this profile's own model list names for this model, or 0 when no fresh cached
+// list names one. The cache is filled by /v1/models; this only reads it.
+function modelOutputLimit(profileKey, profile, mappedModel) {
   if (!profile?.baseURL || !mappedModel) return 0;
-  for (const entry of Object.values(readWindowsCache(STATE_DIR))) {
-    const output = entry?.baseURL === profile.baseURL ? Number(entry.models?.[mappedModel]?.output) : 0;
-    if (output > 0) return output;
-  }
-  return 0;
+  const output = Number(cachedProfileWindows(STATE_DIR, windowsCacheKey(profileKey, profile.baseURL))[mappedModel]?.output);
+  return output > 0 ? output : 0;
 }
 
-function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = null) {
+function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = null, profileKey = null) {
   const effort = resolveThinkingEffort(profile, slot, mappedModel);
   const upBody = emitUpstreamBody(outFormat, ir, mappedModel, {
     thinkingMode: profile.thinkingMode,
     thinkingEffort: effort,
     replayReasoning: profile.replayReasoning === true,
-    maxOutputTokens: modelOutputLimit(profile, mappedModel),
+    maxOutputTokens: modelOutputLimit(profileKey, profile, mappedModel),
   });
   if (upBody?.tools && Array.isArray(upBody.tools)) {
     upBody.tools = cleanSchemaDeep(upBody.tools);
     if (outFormat === 'openai-chat' && isAntigravityModel(mappedModel)) {
       upBody.tools = geminiSafeTools(upBody.tools);
     }
+    // Read by toolVocabFor when the answer is rendered: the arguments lose the keys padding added.
+    if (outFormat === 'vertex' || (outFormat === 'openai-chat' && isAntigravityModel(mappedModel))) ir._geminiPadded = geminiPaddedTools(upBody);
   }
   const { url, headers } = upstreamEndpoint(profile, outFormat, mappedModel, ir.stream, req);
   return { url, headers, upBody };
@@ -1001,7 +1009,7 @@ async function executeGoalCheckGate({ req, res, clientFormat, payload, ir, profi
   try {
     const nativePromise = (async () => {
       try {
-        let url, headers, body;
+        let url, headers, body, upBody = null;
         if (bifrost) {
           url = bifrostURL(profile, clientFormat, req, opts);
           headers = bifrostHeaders(req, profile);
@@ -1019,16 +1027,18 @@ async function executeGoalCheckGate({ req, res, clientFormat, payload, ir, profi
           body = Buffer.from(JSON.stringify(json), 'utf8');
         } else {
           const slot = resolveSlot(requestedModel, mappedModel, profile, clientFormat);
-          const reqData = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot);
+          const reqData = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot, profileKey);
           url = reqData.url;
           headers = reqData.headers;
-          body = JSON.stringify(reqData.upBody);
+          upBody = reqData.upBody;
         }
 
         const traceId = clientFormat === 'codeassist' ? null : (probeTraceId(req) || contractLab.traceFor(mappedModel));
         if (traceId) headers['x-intact-trace'] = traceId;
 
-        const upRes = await fetch(url, { method: 'POST', headers, body, signal: gateAC.signal });
+        const upRes = upBody
+          ? await fetchUpstream(url, headers, upBody, gateAC.signal, outFormat, profileKey, mappedModel)
+          : await fetch(url, { method: 'POST', headers, body, signal: gateAC.signal });
         if (!upRes.ok) {
           const errText = await upRes.text().catch(() => '');
           return { malformed: true, error: `Upstream HTTP ${upRes.status}: ${errText.slice(0, 150)}` };
@@ -1302,7 +1312,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       return log({ status: 400, error: 'unsupported compaction state' });
     }
     const slot = resolveSlot(requestedModel, mappedModel, profile, clientFormat);
-    const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot);
+    const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot, profileKey);
     if (traceId) headers['x-intact-trace'] = traceId;
     debugLog(`[${profileKey}] ${clientFormat} -> ${outFormat} ${url} ::`, JSON.stringify(upBody).slice(0, 500));
 
@@ -1962,7 +1972,7 @@ async function servedModels(req) {
 // still gets the cached numbers, because an entry with the template window is better than none.
 async function modelWindowsFor(profileKey, profile) {
   if (!profile?.baseURL) return {};
-  const listed = await resolveProfileWindows(STATE_DIR, `${profileKey || 'profile'}@${profile.baseURL}`, profile.baseURL, profile.apiKey);
+  const listed = await resolveProfileWindows(STATE_DIR, windowsCacheKey(profileKey, profile.baseURL), profile.baseURL, profile.apiKey);
   if (Object.keys(listed).length) return listed;
   return readLocalCodexWindows();
 }
@@ -2385,7 +2395,7 @@ function sendWsFailed(socket, model, message, status = 500, tap = null, code = n
     if (socket.writable) socket.write(encodeWsFrame(JSON.stringify(d)));
   }, model || 'main');
   renderer.start();
-  renderer.error(message, code || responsesErrorCode(status));
+  renderer.error(message, code || (isContextOverflow(status, message) ? 'context_length_exceeded' : responsesErrorCode(status)));
 }
 
 // Codex on WebSocket sends only the new items of a turn and names the turn before in
@@ -2573,7 +2583,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
   let answered = false; // set only after a complete answer; the half upload depends on it
   try {
     const slot = resolveSlot(requestedModel, mappedModel, profile, clientFormat);
-    const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot);
+    const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot, profileKey);
     if (traceId) headers['x-intact-trace'] = traceId;
     debugLog(`[${profileKey}:ws] ${clientFormat} -> ${outFormat} ${url} ::`, JSON.stringify(upBody).slice(0, 300));
 

package/scripts/run-tests.mjs

@@ -1,6 +1,7 @@
 // Runs only tests/**/*.test.mjs. A bare `node --test` also collects test files from git-ignored
 // folders (an old copy in temp/), and Node 18 and 20 do not expand a glob argument.
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -17,5 +18,16 @@ const files = [];
 
 // A version check must never reach the real npm registry.
 const env = { ...process.env, LLM_SWITCHER_REGISTRY_URL: 'http://127.0.0.1:9/' };
+// `npm test` itself, not a test, makes node-compile-cache in TMPDIR as it starts. Only a cache born
+// in the seconds before this run is removed afterwards; one that was there before stays.
+const compileCache = path.join(os.tmpdir(), 'node-compile-cache');
+const launchedAt = Date.now() - process.uptime() * 1000;
+let npmMadeCache = false;
+try {
+  const born = fs.statSync(compileCache).birthtimeMs;
+  npmMadeCache = Boolean(process.env.npm_lifecycle_event) && born > 0 && born >= launchedAt - 10_000;
+} catch { /* no cache: nothing to remove */ }
+
 const r = spawnSync(process.execPath, ['--test', ...process.argv.slice(2), ...files], { cwd: root, stdio: 'inherit', env });
+if (npmMadeCache) fs.rmSync(compileCache, { recursive: true, force: true });
 process.exit(r.status ?? 1);

package/tests/blindfold.task3.test.mjs

@@ -24,6 +24,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-task3-'));
+test.after(() => fs.rmSync(TMP, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }));
 process.env.LLM_SWITCHER_HOME = TMP;
 process.env.LLM_SWITCHER_CONFIG = path.join(TMP, 'config.json');
 delete process.env.LLM_SWITCHER_BLINDFOLD_CERTS;

package/tests/contract-check.test.mjs

@@ -1,7 +1,7 @@
 // `switch contract-check`: it turns open findings of intact into JSON test data, and never into
 // JavaScript. Every path, enum value and name in a finding or a fixture is untrusted text, so the
 // hostile-finding test hashes every .mjs file of the repository before and after a run.
-import { test } from 'node:test';
+import { test, after } from 'node:test';
 import assert from 'node:assert/strict';
 import http from 'node:http';
 import crypto from 'node:crypto';
@@ -15,8 +15,13 @@ import { runCheck, loadExclusions, matchExclusion, FINDING_ID_RE } from '../cont
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HOSTILE = "x');require('child_process')";
 
+// Every directory is removed once more after the file, so a failed test leaves none behind.
+const made = [];
+after(() => { for (const d of made) fs.rmSync(d, { recursive: true, force: true }); });
 function tmpDir(name) {
-  return fs.mkdtempSync(path.join(os.tmpdir(), `lsw-${name}-`));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `lsw-${name}-`));
+  made.push(dir);
+  return dir;
 }
 
 // One fake intact: it serves the findings list and one fixture per known trace id.

package/tests/datadir.test.mjs

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test, after } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -6,7 +6,9 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { resolveDataDir } from '../state.mjs';
 
-const tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'llm-sw-datadir-'));
+const made = [];
+after(() => { for (const d of made) fs.rmSync(d, { recursive: true, force: true }); });
+const tmp = () => { const d = fs.mkdtempSync(path.join(os.tmpdir(), 'llm-sw-datadir-')); made.push(d); return d; };
 
 test('a git checkout keeps its data next to the code', () => {
   const root = tmp();

package/tests/formats.test.mjs

@@ -13,8 +13,10 @@ import {
   smartText, smartReasoning, sanitizeJsonSchema, normalizeUpstream, buildVertexMessage,
   createCodeAssistStream,
   budgetToEffort, effortToBudget, normalizeEffort, capEffort, mapEquivalentEffort, EFFORT_LEVELS, parseArgs, buildAnthropicMessage,
-  refusesImageInput, omitChatImages, IMAGE_OMITTED_TEXT
+  refusesImageInput, omitChatImages, IMAGE_OMITTED_TEXT,
+  stripGeminiPlaceholders, geminiPaddedTools, withGeminiPlaceholderStrip
 } from '../formats.mjs';
+import { NULL_TOOL_VOCAB, createToolVocab } from '../toolvocab.mjs';
 import { assertValidAnthropicEvents } from './helpers.mjs';
 
 test('anthropicToIR: stream defaults to false and thinking budget_tokens is preserved', () => {
@@ -1388,3 +1390,126 @@ test('healAnthropicPayload dedupes repeated tool_use ids', () => {
   assert.deepEqual(msgs[2].content.map(b => [b.tool_use_id, b.content]), [[ids[0], 'a.txt']]);
   assert.deepEqual(msgs[4].content.map(b => [b.tool_use_id, b.content]), [[ids[1], '/'], [ids[2], 'uid']]);
 });
+
+// Reasoning from an aborted turn must not attach to the assistant turn after the next user message.
+test('responsesToIR drops pending reasoning at a user message and joins reasoning pieces with a newline', () => {
+  const ir = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'plan it' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'stale plan' }] },
+    { type: 'message', role: 'user', content: 'start over' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'fresh plan' }] },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'second piece' }] },
+    { type: 'message', role: 'assistant', content: 'done' }
+  ] });
+  const assistant = ir.messages.find(m => m.role === 'assistant');
+  assert.equal(assistant.reasoning, 'fresh plan\nsecond piece');
+  const viaString = responsesToIR({ model: 'x', input: [
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'stale plan' }] },
+    'start over',
+    { type: 'message', role: 'assistant', content: 'done' }
+  ] });
+  assert.equal(viaString.messages.find(m => m.role === 'assistant').reasoning, undefined);
+});
+
+// The direct Anthropic route has no system role inside messages; dropping the message loses its instruction.
+test('healAnthropicPayload folds a mid-conversation system message into a user turn', () => {
+  const roles = (msgs) => msgs.map(m => m.role);
+  const texts = (msgs) => JSON.stringify(msgs);
+  const alternates = (msgs) => msgs.every((m, i) => i === 0 || m.role !== msgs[i - 1].role);
+
+  const r = healAnthropicPayload({ model: 'x', max_tokens: 10, messages: [
+    { role: 'user', content: 'list files' },
+    { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'ls' } }] },
+    { role: 'system', content: 'Use British spelling from now on.' },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'a.txt' }] },
+    { role: 'assistant', content: 'one file' },
+    { role: 'system', content: [{ type: 'text', text: 'Be brief.' }] }
+  ] });
+  assert.equal(r.changed, true);
+  const msgs = r.payload.messages;
+  assert.ok(!msgs.some(m => m.role === 'system'), 'no system role remains');
+  assert.ok(alternates(msgs), `roles alternate: ${roles(msgs)}`);
+  assert.deepEqual(roles(msgs), ['user', 'assistant', 'user', 'assistant']);
+  assert.deepEqual(msgs[2].content, [
+    { type: 'tool_result', tool_use_id: 'toolu_1', content: 'a.txt' },
+    { type: 'text', text: '[system] Use British spelling from now on.' },
+    { type: 'text', text: '[system] Be brief.' }
+  ], 'a tool_result stays first; with no user turn after it, the last text joins the previous user turn');
+  assert.ok(!texts(msgs[3]).includes('[system]'));
+
+  const only = healAnthropicPayload({ model: 'x', max_tokens: 10, messages: [
+    { role: 'system', content: 'Answer in French.' },
+    { role: 'assistant', content: 'Bonjour' }
+  ] }).payload.messages;
+  assert.deepEqual(only, [{ role: 'user', content: [{ type: 'text', text: '[system] Answer in French.' }] }, { role: 'assistant', content: 'Bonjour' }]);
+});
+
+// Vertex path: the schema is deep-copied before it is sent, and an Anthropic client streams the call.
+test('a Vertex tool padded for Gemini loses _placeholder in streamed arguments, and only where padded', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [{ name: 'run', input_schema: {
+    type: 'object', properties: { env: { type: 'object' }, list: { type: 'array', items: { type: 'object' } }, opts: { type: 'object', properties: { _placeholder: { type: 'string' } } } }
+  } }, { name: 'plain', input_schema: { type: 'object', properties: { a: { type: 'string' } } } }] });
+  const body = JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro')));
+  const padded = geminiPaddedTools(body);
+  assert.deepEqual([...padded.keys()], ['run'], 'only the tool with a padded node');
+  const args = { env: { A: '1', _placeholder: true }, list: [{ _placeholder: false, b: 2 }], opts: { _placeholder: 'keep' }, _placeholder: 1 };
+  assert.deepEqual(stripGeminiPlaceholders(args, padded.get('run')), { env: { A: '1' }, list: [{ b: 2 }], opts: { _placeholder: 'keep' }, _placeholder: 1 });
+
+  const events = [];
+  const r = createAnthropicStream((e, d) => events.push(d), 'm', { vocab: withGeminiPlaceholderStrip(NULL_TOOL_VOCAB, padded) });
+  r.start();
+  const json = JSON.stringify(args);
+  r.tool({ index: 0, id: 'c1', name: 'run', args: json.slice(0, 12) });
+  r.tool({ index: 0, args: json.slice(12) });
+  r.finish('tool_calls');
+  const streamed = events.filter(d => d.delta?.type === 'input_json_delta').map(d => d.delta.partial_json).join('');
+  assert.deepEqual(JSON.parse(streamed), { env: { A: '1' }, list: [{ b: 2 }], opts: { _placeholder: 'keep' }, _placeholder: 1 });
+  assert.equal(withGeminiPlaceholderStrip(NULL_TOOL_VOCAB, padded).args('plain', '{"_placeholder":true}'), '{"_placeholder":true}');
+  assert.equal(withGeminiPlaceholderStrip(NULL_TOOL_VOCAB, new Map()), NULL_TOOL_VOCAB, 'no padding, no wrapper');
+});
+
+// A vertex client gets complete functionCalls, so the strip applies when the call is written out.
+test('a vertex client gets tool-call args without the padded _placeholder, stream and non-stream', () => {
+  const declared = [{ name: 'run', parameters: { type: 'object', properties: { env: { type: 'object' }, opts: { type: 'object', properties: { _placeholder: { type: 'string' } } } } } }];
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: declared.map(t => ({ name: t.name, input_schema: t.parameters })) });
+  const padded = geminiPaddedTools(JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro'))));
+  const vocab = withGeminiPlaceholderStrip(createToolVocab(ir.tools, { allowHyphens: false }), padded);
+  const args = JSON.stringify({ env: { A: '1', _placeholder: true }, opts: { _placeholder: 'keep' } });
+  const want = { env: { A: '1' }, opts: { _placeholder: 'keep' } };
+
+  const chunks = [];
+  const s = createVertexStream((e, d) => chunks.push(d), 'm', { vocab });
+  s.tool({ index: 0, id: 'c1', name: 'run', args: args.slice(0, 9) });
+  s.tool({ index: 0, args: args.slice(9) });
+  s.finish('tool_calls');
+  const streamed = chunks.flatMap(c => c.candidates?.[0]?.content?.parts || []).find(p => p.functionCall);
+  assert.deepEqual(streamed.functionCall.args, want);
+
+  const whole = buildVertexMessage({ model: 'm', tools: [{ index: 0, id: 'c1', name: 'run', args }], finish: 'tool_calls', vocab });
+  assert.deepEqual(whole.candidates[0].content.parts.find(p => p.functionCall).functionCall.args, want);
+});
+
+// The Vertex body names a tool without hyphens, so the strip must find the schema by either name.
+test('the placeholder strip finds a hyphenated tool by its upstream name and by its client name', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [{ name: 'my-tool', input_schema: { type: 'object', properties: { env: { type: 'object' } } } }] });
+  const vocab = createToolVocab(ir.tools, { allowHyphens: false, names: ['my-tool'] });
+  assert.equal(vocab.name('my_tool'), 'my-tool', 'fixture: the upstream name is the sanitized one');
+  const padded = geminiPaddedTools(JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro'))));
+  assert.deepEqual([...padded.keys()], ['my_tool']);
+  const strip = withGeminiPlaceholderStrip(vocab, padded);
+  const args = '{"env":{"A":"1","_placeholder":true}}';
+  assert.deepEqual(JSON.parse(strip.args('my_tool', args)), { env: { A: '1' } }, 'upstream name');
+  assert.deepEqual(JSON.parse(strip.args('my-tool', args)), { env: { A: '1' } }, 'client name');
+});
+
+// A union with an object branch becomes anyOf for Gemini, and that object branch is padded too.
+test('the placeholder strip reaches a padded object inside an anyOf branch', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [{ name: 'run', input_schema: {
+    type: 'object', properties: { env: { oneOf: [{ type: 'object' }, { type: 'string' }] } }
+  } }] });
+  const padded = geminiPaddedTools(JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro'))));
+  const schema = padded.get('run');
+  assert.ok(Array.isArray(schema?.properties?.env?.anyOf), 'fixture: env is an anyOf with a padded branch');
+  assert.deepEqual(stripGeminiPlaceholders({ env: { A: '1', _placeholder: true } }, schema), { env: { A: '1' } });
+  assert.deepEqual(stripGeminiPlaceholders({ env: 'plain' }, schema), { env: 'plain' });
+});

package/tests/gateway.e2e.test.mjs

@@ -62,6 +62,18 @@ const sse = (res, objs, { raw = [] } = {}) => {
   res.end();
 };
 
+// Upstream errors keyed by a MOCK_ERR:<key> marker in the last user message: [status, message].
+const MOCK_ERRORS = {
+  comma: [400, "This model's maximum context length is 131,072 tokens. However, your messages resulted in 140,000 tokens."],
+  dot: [400, 'Input exceeds the context window of 131.072 tokens: requested 140.000 tokens'],
+  space: [400, 'maximum context length is 131 072 tokens, you requested 140 000 tokens'],
+  underscore: [400, 'maximum context length is 131_072 tokens, you requested 140_000 tokens'],
+  prefixed: [400, 'prompt is too long: 200000 tokens > 199999 maximum'],
+  nonumber: [400, 'The input exceeds the context window of this model.'],
+  rate: [429, 'Rate limit reached on context tokens per minute: maximum context length is 131,072'],
+  server: [500, "Internal error: this model's maximum context length is 131,072 tokens"]
+};
+
 function startUpstream() {
   upstream = http.createServer((req, res) => {
     let body = '';
@@ -123,10 +135,28 @@ function startUpstream() {
             { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }], usage: { prompt_tokens: 10, completion_tokens: 15 } }
           ], { raw: ['data: [DONE]\n\n'] });
         }
+        if (lastUser.includes('PLACEHOLDER_ECHO')) {
+          const args = '{"cmd":"ls","env":{"A":"1","_placeholder":true},"opts":{"_placeholder":"keep"},"_placeholder":true}';
+          if (!json.stream) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            return res.end(JSON.stringify({ choices: [{ index: 0, message: { role: 'assistant', content: null, tool_calls: [{ id: 'call_ph', type: 'function', function: { name: 'run', arguments: args } }] }, finish_reason: 'tool_calls' }], usage: { prompt_tokens: 5, completion_tokens: 5 } }));
+          }
+          return sse(res, [
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: 'call_ph', type: 'function', function: { name: 'run', arguments: args.slice(0, 30) } }] } }] },
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: args.slice(30) } }] } }] },
+            { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }], usage: { prompt_tokens: 5, completion_tokens: 5 } }
+          ], { raw: ['data: [DONE]\n\n'] });
+        }
         if (lastUser.includes('RATE_LIMIT')) {
           res.writeHead(429, { 'Content-Type': 'application/json', 'retry-after': '7' });
           return res.end(JSON.stringify({ error: { message: 'slow down' } }));
         }
+        const mockErr = lastUser.match(/MOCK_ERR:(\w+)/)?.[1];
+        if (mockErr && MOCK_ERRORS[mockErr]) {
+          const [status, message] = MOCK_ERRORS[mockErr];
+          res.writeHead(status, { 'Content-Type': 'application/json' });
+          return res.end(JSON.stringify({ error: { message, type: 'invalid_request_error' } }));
+        }
         if (lastUser.includes('CONTEXT_OVERFLOW')) {
           res.writeHead(400, { 'Content-Type': 'application/json' });
           return res.end(JSON.stringify({ error: { message: "This model's maximum context length is 131072 tokens. However, you requested 140000 tokens (132000 in the messages, 8000 in the completion). Please reduce the length of the messages or completion.", type: 'invalid_request_error', code: 'invalid_request_error' } }));
@@ -262,6 +292,9 @@ before(async () => {
       intactcc: { name: 'Mock intact', mode: 'convert', tool: 'claude', outFormat: 'openai-chat', thinkingMode: 'off', baseURL: `${base}/intact/v1`, apiKey: 'sk-intact-user', defaultModels: { opus: 'claude/claude-opus-5', sonnet: 'gem/flash', haiku: 'claude/claude-haiku-4-5', fable: 'gem/flash' } },
       textonly: { name: 'Mock Text Only', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-textonly', defaultModels: { opus: 'up-textonly', sonnet: 'up-badreq', haiku: 'up-haiku', fable: 'up-fable' } },
       capped: { name: 'Mock Capped Output', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-capped', defaultModels: { opus: 'up-capped', sonnet: 'up-sonnet', haiku: 'up-haiku', fable: 'up-fable' } },
+      agyph: { name: 'Mock agy to AG via chat', mode: 'convert', tool: 'agy', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-agy', defaultModels: { main: 'ag/mock-flash' } },
+      cappedtwin: { name: 'Mock Capped Twin', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-capped', defaultModels: { opus: 'up-capped', sonnet: 'up-sonnet', haiku: 'up-haiku', fable: 'up-fable' } },
+      cappedold: { name: 'Mock Capped Old', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-capped', defaultModels: { opus: 'up-capped', sonnet: 'up-sonnet', haiku: 'up-haiku', fable: 'up-fable' } },
       ant: { name: 'Mock Anthropic', mode: 'direct', inFormat: 'auto', outFormat: 'anthropic', baseURL: `${base}/ant`, apiKey: 'sk-secret-ant', defaultModels: models }
     }
   };
@@ -628,6 +661,72 @@ test('max_tokens above the listed output limit is clamped; a model with no liste
   assert.equal(received.at(-1).body.max_tokens, 64000);
 });
 
+// The clamp trusts only the list this profile read within the hour, whatever other profile shares its baseURL.
+test('max_tokens is clamped only from a fresh cache entry of the same profile', async () => {
+  const listed = await fetch(url('/v1/models'), { headers: { 'x-llm-profile': 'capped' } });
+  await listed.text();
+  const ask = async (profile) => {
+    const res = await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 64000, messages: [{ role: 'user', content: 'hi' }] }, { 'x-llm-profile': profile });
+    assert.equal(res.status, 200, profile);
+    await res.text();
+    assert.equal(received.at(-1).body.model, 'up-capped', profile);
+    return received.at(-1).body.max_tokens;
+  };
+  assert.equal(await ask('cappedtwin'), 64000, 'another profile on the same baseURL has not read its list');
+  const cacheFile = path.join(tmpDir, 'model-windows.json');
+  const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+  const base = `http://127.0.0.1:${upstreamPort}/chat/v1`;
+  cache[`cappedold@${base}`] = { at: Date.now() - 2 * 3_600_000, baseURL: base, models: { 'up-capped': { context: 200000, compact: 0, output: 4096 } } };
+  fs.writeFileSync(cacheFile, JSON.stringify(cache));
+  assert.equal(await ask('cappedold'), 64000, 'an entry two hours old is not trusted');
+  assert.equal(await ask('capped'), 8192);
+});
+
+// Gemini gets `_placeholder` on an empty nested object; the client never declared it, so it must not come back.
+test('A _placeholder the gateway added for Gemini is stripped from tool-call arguments, stream and non-stream', async () => {
+  const tools = [{ type: 'function', name: 'run', parameters: { type: 'object', properties: {
+    cmd: { type: 'string' },
+    env: { type: 'object', additionalProperties: { type: 'string' } },
+    opts: { type: 'object', properties: { _placeholder: { type: 'string' } } }
+  } } }];
+  const want = { cmd: 'ls', env: { A: '1' }, opts: { _placeholder: 'keep' }, _placeholder: true };
+
+  const plain = await post('/v1/responses', { model: 'main', stream: false, tools, input: 'PLACEHOLDER_ECHO' }, { 'x-llm-profile': 'agmock' });
+  assert.equal(plain.status, 200);
+  const sent = received.at(-1).body.tools.find(t => t.function.name === 'run').function.parameters;
+  assert.deepEqual(Object.keys(sent.properties.env.properties), ['_placeholder'], 'the schema sent upstream was padded');
+  const call = (await plain.json()).output.find(o => o.type === 'function_call');
+  assert.deepEqual(JSON.parse(call.arguments), want);
+
+  const streamed = await post('/v1/responses', { model: 'main', stream: true, tools, input: 'PLACEHOLDER_ECHO' }, { 'x-llm-profile': 'agmock' });
+  const done = parseSSE(await streamed.text()).find(e => e.data?.type === 'response.completed');
+  assert.ok(done, 'the stream completes');
+  assert.deepEqual(JSON.parse(done.data.response.output.find(o => o.type === 'function_call').arguments), want);
+});
+
+test('A Code Assist (agy) client gets tool-call args without the padded _placeholder, stream and non-stream', async () => {
+  const envelope = { project: 'p', requestId: 'agent/s/1/t/1', model: 'gemini-3.8-flash-high', userAgent: 'antigravity', requestType: 'agent', request: {
+    contents: [{ role: 'user', parts: [{ text: 'PLACEHOLDER_ECHO' }] }],
+    tools: [{ functionDeclarations: [{ name: 'run', description: 'Run.', parameters: { type: 'OBJECT', properties: {
+      cmd: { type: 'STRING' }, env: { type: 'OBJECT' }, opts: { type: 'OBJECT', properties: { _placeholder: { type: 'STRING' } } }
+    } } }] }]
+  } };
+  const want = { cmd: 'ls', env: { A: '1' }, opts: { _placeholder: 'keep' }, _placeholder: true };
+  const headers = { 'content-type': 'application/json', 'x-llm-profile': 'agyph' };
+  const callOf = (chunks) => chunks.flatMap(c => c.response?.candidates?.[0]?.content?.parts || []).find(p => p.functionCall)?.functionCall;
+
+  const whole = await fetch(url('/v1internal:generateContent'), { method: 'POST', headers, body: JSON.stringify(envelope) });
+  assert.equal(whole.status, 200);
+  const sent = received.at(-1).body.tools.find(t => t.function.name === 'run').function.parameters;
+  assert.deepEqual(Object.keys(sent.properties.env.properties), ['_placeholder'], 'the schema sent upstream was padded');
+  assert.deepEqual(callOf([await whole.json()]).args, want);
+
+  const streamed = await fetch(url('/v1internal:streamGenerateContent?alt=sse'), { method: 'POST', headers, body: JSON.stringify(envelope) });
+  assert.equal(streamed.status, 200);
+  const chunks = parseSSE(await streamed.text()).map(e => e.data).filter(Boolean);
+  assert.deepEqual(callOf(chunks).args, want);
+});
+
 // A text-only model refuses an image that stays in the history, so every later turn would fail too.
 test('An image refused by a text-only chat model is retried once as text in each request', async () => {
   const image = { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'iVBORw0KGgo=' } };
@@ -685,6 +784,36 @@ test('sendClientError maps context overflow per client', async () => {
   assert.match(codexJson.error.message, /maximum context length is 131072/);
 });
 
+test('Context overflow numbers with thousands separators reach Claude Code whole', async () => {
+  const ask = async (key) => {
+    const res = await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, messages: [{ role: 'user', content: `MOCK_ERR:${key}` }] });
+    return { status: res.status, error: (await res.json()).error };
+  };
+  for (const key of ['comma', 'dot', 'space', 'underscore']) {
+    const { status, error } = await ask(key);
+    assert.equal(status, 400, key);
+    assert.equal(error.type, 'invalid_request_error', key);
+    assert.equal(error.message, `prompt is too long: 140000 tokens > 131072 maximum (${MOCK_ERRORS[key][1]})`, key);
+  }
+  assert.deepEqual(await ask('prefixed'), { status: 400, error: { type: 'invalid_request_error', message: MOCK_ERRORS.prefixed[1] } });
+  assert.deepEqual(await ask('nonumber'), { status: 400, error: { type: 'invalid_request_error', message: `prompt is too long: ${MOCK_ERRORS.nonumber[1]}` } });
+  assert.deepEqual(await ask('rate'), { status: 429, error: { type: 'rate_limit_error', message: MOCK_ERRORS.rate[1] } });
+  assert.deepEqual(await ask('server'), { status: 500, error: { type: 'api_error', message: MOCK_ERRORS.server[1] } });
+});
+
+test('Codex WS: an upstream context overflow fails the turn with context_length_exceeded', async () => {
+  const ws = await rawWs();
+  ws.socket.write(clientFrame(1, JSON.stringify({ type: 'response.create', model: 'main', input: 'MOCK_ERR:comma over ws' })));
+  assert.ok(await until(() => ws.messages.some(m => m.type === 'response.failed')), 'no response.failed');
+  const failed = ws.messages.find(m => m.type === 'response.failed').response.error;
+  assert.equal(failed.code, 'context_length_exceeded');
+  assert.equal(failed.message, MOCK_ERRORS.comma[1]);
+  ws.socket.write(clientFrame(1, JSON.stringify({ type: 'response.create', model: 'main', input: 'MOCK_ERR:rate over ws' })));
+  assert.ok(await until(() => ws.messages.filter(m => m.type === 'response.failed').length === 2), 'no second response.failed');
+  assert.equal(ws.messages.filter(m => m.type === 'response.failed')[1].response.error.code, 'rate_limit_exceeded');
+  ws.socket.destroy();
+});
+
 test('Mid-stream upstream error surfaces as an error event instead of a fake end_turn', async () => {
   const res = await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, stream: true, messages: [{ role: 'user', content: 'MID_STREAM_ERROR' }] });
   const events = parseSSE(await res.text());

package/tests/goalcheck.e2e.test.mjs

@@ -27,6 +27,7 @@ async function fixture(t) {
   let nativeVerdict = { ok: true, reason: 'looks complete' };
   let jevScores = { complete: 0.14, evidence: 0.84, unfinished: 0.63 };
   let jevStatus = 200;
+  const chatRequests = [];
 
   // Mock native upstream (Anthropic format)
   const nativeUp = http.createServer((req, res) => {
@@ -40,6 +41,16 @@ async function fixture(t) {
       const body = JSON.parse(raw);
       const isStream = Boolean(body.stream);
       const respText = JSON.stringify(nativeVerdict);
+      // A text-only chat model: it refuses any image part.
+      if (req.url.endsWith('/chat/completions')) {
+        chatRequests.push(body);
+        res.setHeader('content-type', 'application/json');
+        if (body.messages.some(m => Array.isArray(m.content) && m.content.some(c => c?.type === 'image_url'))) {
+          res.statusCode = 400;
+          return res.end(JSON.stringify({ error: { message: 'Failed to deserialize the JSON body: messages[1]: unknown variant `image_url`, expected `text`' } }));
+        }
+        return res.end(JSON.stringify({ id: 'c1', object: 'chat.completion', model: body.model, choices: [{ index: 0, message: { role: 'assistant', content: respText }, finish_reason: 'stop' }] }));
+      }
 
       if (isStream) {
         res.setHeader('content-type', 'text/event-stream');
@@ -110,6 +121,16 @@ async function fixture(t) {
         outFormat: 'anthropic',
         baseURL: `http://127.0.0.1:${nativeUp.address().port}`,
         apiKey: 'sk-native-key'
+      },
+      chat: {
+        name: 'ChatMock',
+        mode: 'convert',
+        tool: 'claude',
+        inFormat: 'auto',
+        outFormat: 'openai-chat',
+        baseURL: `http://127.0.0.1:${nativeUp.address().port}/v1`,
+        apiKey: 'sk-chat-key',
+        defaultModels: { opus: 'up-textonly', sonnet: 'up-textonly', haiku: 'up-textonly', fable: 'up-textonly' }
       }
     },
     goalCheck: {
@@ -166,11 +187,12 @@ async function fixture(t) {
     body: body ? JSON.stringify(body) : undefined
   });
 
-  const sendClaude = (body, stream = false) => fetch(`http://127.0.0.1:${port}/v1/messages`, {
+  const sendClaude = (body, stream = false, headers = {}) => fetch(`http://127.0.0.1:${port}/v1/messages`, {
     method: 'POST',
     headers: {
       'content-type': 'application/json',
-      'user-agent': 'claude-cli/2.1.295'
+      'user-agent': 'claude-cli/2.1.295',
+      ...headers
     },
     body: JSON.stringify({ ...body, stream })
   });
@@ -183,6 +205,7 @@ async function fixture(t) {
     setJevScores: s => { jevScores = s; },
     setJevStatus: st => { jevStatus = st; },
     jevRequests,
+    chatRequests,
     logs: () => logs
   };
 }
@@ -314,3 +337,24 @@ test('goalcheck e2e: live interception, veto, and allow behaviors', async t => {
   assert.ok(logsData.logs.length >= 4);
   assert.equal(logsData.logs[0].verdictType, 'Unavailable');
 });
+
+test('goalcheck e2e: an openai-chat evaluator call that a text-only model refuses for an image is retried as text', async t => {
+  const f = await fixture(t);
+  await f.sendAdmin('/api/goal-check', 'POST', { enabled: true });
+  f.setJevScores({ complete: 0.95, evidence: 0.90, unfinished: 0.05 });
+  f.setNativeVerdict({ ok: true, reason: 'screenshot shows green tests' });
+  const image = { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'iVBORw0KGgo=' } };
+  const request = {
+    ...evaluatorRequest,
+    messages: [
+      { role: 'user', content: [image, { type: 'text', text: 'Please fix the failing tests in repo.' }] },
+      ...evaluatorRequest.messages.slice(1)
+    ]
+  };
+  const res = await f.sendClaude(request, false, { 'x-llm-profile': 'chat' });
+  assert.equal(res.status, 200);
+  const verdict = JSON.parse((await res.json()).content[0].text);
+  assert.deepEqual(verdict, { ok: true, reason: 'screenshot shows green tests' });
+  assert.equal(f.chatRequests.length, 2, 'one refusal, one retry');
+  assert.ok(JSON.stringify(f.chatRequests[1]).includes('[image omitted'), 'the retry carries text in place of the image');
+});

package/tests/shim.test.mjs

@@ -34,7 +34,10 @@ if (process.platform !== 'win32') {
 // Only node, never the directory it lives in: an npm install puts the real claude and codex next to it.
 const NODE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'shimnode-'));
 if (process.platform !== 'win32') fs.symlinkSync(process.execPath, path.join(NODE_DIR, 'node'));
+// Per-test fake binaries live here, so one teardown removes them even when a test fails.
+const SCRATCH = fs.mkdtempSync(path.join(os.tmpdir(), 'shimscratch-'));
 test.after(() => {
+  fs.rmSync(SCRATCH, { recursive: true, force: true });
   fs.rmSync(NODE_DIR, { recursive: true, force: true });
   fs.rmSync(RENDER_DIR, { recursive: true, force: true });
   fs.rmSync(STATE, { recursive: true, force: true });
@@ -61,7 +64,7 @@ function runShim(name, args, { active, fakeDir, extraPath = '', env = {}, files
 // Prints every value the switcher could have touched, so a test can see both what was scrubbed
 // and what must have been kept.
 function makeEnvBin(name) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimenv-'));
+  const dir = fs.mkdtempSync(path.join(SCRATCH, 'shimenv-'));
   fs.writeFileSync(path.join(dir, name),
     '#!/usr/bin/env bash\n'
     + 'echo "HTTPS_PROXY=${HTTPS_PROXY:-NONE} BASE=${ANTHROPIC_BASE_URL:-NONE} OPENAI=${OPENAI_BASE_URL:-NONE} MODEL=${ANTHROPIC_MODEL:-NONE} DEFOPUS=${ANTHROPIC_DEFAULT_OPUS_MODEL:-NONE} CA=${NODE_EXTRA_CA_CERTS:-NONE}"\n'
@@ -73,14 +76,14 @@ function makeEnvBin(name) {
 
 // A fake binary that prints every argument on its own line, so the test sees argument boundaries.
 function makeArgvBin(name) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimargv-'));
+  const dir = fs.mkdtempSync(path.join(SCRATCH, 'shimargv-'));
   fs.writeFileSync(path.join(dir, name), '#!/usr/bin/env bash\necho "HTTPS_PROXY=${HTTPS_PROXY:-NONE}"\nprintf \'%s\\n\' "$@"\n');
   fs.chmodSync(path.join(dir, name), 0o755);
   return dir;
 }
 
 function makeFakeBin(name) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimtest-'));
+  const dir = fs.mkdtempSync(path.join(SCRATCH, 'shimtest-'));
   fs.writeFileSync(path.join(dir, name),
     '#!/usr/bin/env bash\necho "BASE=${ANTHROPIC_BASE_URL:-NONE} ARGS=$*"\n');
   fs.chmodSync(path.join(dir, name), 0o755);
@@ -118,7 +121,7 @@ test('shim never recurses into itself', (t) => {
 
 test('shim fails loudly (127) when the real binary is missing', (t) => {
   if (process.platform === 'win32') return t.skip('posix only');
-  const empty = fs.mkdtempSync(path.join(os.tmpdir(), 'shimempty-'));
+  const empty = fs.mkdtempSync(path.join(SCRATCH, 'shimempty-'));
   assert.throws(
     () => runShim('claude', [], { active: true, fakeDir: empty }),
     (err) => err.status === 127,
@@ -583,7 +586,7 @@ for (const [kind, routed] of [['forged', false], ['silent', false], ['real', tru
     const server = await agyListener(kind);
     t.after(() => server.close());
     const port = server.address().port;
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyposix-'));
+    const dir = fs.mkdtempSync(path.join(SCRATCH, 'agyposix-'));
     fs.writeFileSync(path.join(dir, 'agy'), `#!/usr/bin/env bash\necho "CCU=[\${CLOUD_CODE_URL:-}]"\nnode "${AGY_REQUEST}"\n`);
     fs.chmodSync(path.join(dir, 'agy'), 0o755);
     for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });

package/tests/version.test.mjs

@@ -1,5 +1,5 @@
 // The running version and the update notice. The registry is a local server, never npm.
-import { test } from 'node:test';
+import { test, after } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -15,7 +15,10 @@ async function registry(handler) {
   await new Promise(r => server.listen(0, '127.0.0.1', r));
   return { url: `http://127.0.0.1:${server.address().port}/llm-switcher/latest`, hits: () => hits, close: () => server.close() };
 }
-const tmpState = () => fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-version-'));
+// Every state dir is removed after the file, also the ones a failed test did not reach.
+const made = [];
+after(() => { for (const d of made) fs.rmSync(d, { recursive: true, force: true }); });
+const tmpState = () => { const d = fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-version-')); made.push(d); return d; };
 
 test('the current version is the one in package.json', () => {
   assert.equal(CURRENT_VERSION, pkg.version);

package/tests/windows.test.mjs

@@ -6,7 +6,8 @@ import path from 'node:path';
 import http from 'node:http';
 import {
   parseModelWindows, parseModelList, fetchProfileWindows,
-  resolveProfileWindows, readWindowsCache, readLocalCodexWindows
+  resolveProfileWindows, readWindowsCache, readLocalCodexWindows,
+  windowsCacheKey, cachedProfileWindows
 } from '../windows.mjs';
 
 const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-windows-'));
@@ -152,3 +153,64 @@ test('the Codex CLI own cache is a fallback, not a source of truth', () => {
     fs.rmSync(home, { recursive: true, force: true });
   }
 });
+
+// A profile whose baseURL is spelled with another case or a trailing slash is the same address.
+test('the cache key of a profile ignores the case of scheme and host and a trailing slash', () => {
+  assert.equal(windowsCacheKey('p', 'HTTP://Api.Example.COM:8080/v1/'), 'p@http://api.example.com:8080/v1');
+  assert.equal(windowsCacheKey('p', 'http://api.example.com:8080/v1'), 'p@http://api.example.com:8080/v1');
+  assert.equal(windowsCacheKey('p', 'https://api.example.com/V1//'), 'p@https://api.example.com/V1', 'the path keeps its case');
+  assert.equal(windowsCacheKey(null, 'https://h/v1'), 'profile@https://h/v1');
+});
+
+// The output clamp reads the cache without a refresh, so it trusts only what this profile read within the hour.
+test('cachedProfileWindows answers only for its own key and only while the entry is fresh', () => {
+  const dir = tmpDir();
+  try {
+    const models = { m: { context: 200000, compact: 0, output: 8192 } };
+    fs.writeFileSync(path.join(dir, 'model-windows.json'), JSON.stringify({ 'a@http://h/v1': { at: 1_000, baseURL: 'http://h/v1', models } }));
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 1_000 + 60_000 }), models);
+    assert.deepEqual(cachedProfileWindows(dir, 'b@http://h/v1', { now: 1_000 + 60_000 }), {}, 'another profile on the same baseURL');
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 1_000 + 3_600_000 }), {}, 'an entry an hour old');
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 2_000, ttlMs: 500 }), {});
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// A list that names only an output limit must not erase the windows an earlier read found, and an
+// output limit lives only as long as the newest list still states it.
+test('a refresh merges each model into the cached windows, but never carries an output limit forward', async () => {
+  const dir = tmpDir();
+  const lists = [
+    [{ id: 'm', context_length: 200000, compact_window: 150000, max_output_tokens: 4096 }, { id: 'n', context_length: 100000, max_output_tokens: 2048 }],
+    [{ id: 'm', context_length: 300000 }, { id: 'o', context_length: 50000 }],
+    [{ id: 'm', max_output_tokens: 8192 }]
+  ];
+  let hits = 0;
+  const sink = http.createServer((req, res) => {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ data: lists[hits++] }));
+  });
+  await new Promise(r => sink.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${sink.address().port}/v1`;
+  try {
+    await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 });
+    const second = await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 + 3_600_000 });
+    const expected = {
+      m: { context: 300000, compact: 150000 },
+      n: { context: 100000, compact: 0 },
+      o: { context: 50000, compact: 0 }
+    };
+    assert.deepEqual(second, expected, 'a changed window replaces the cached one; no output limit the list did not state');
+    assert.deepEqual(readWindowsCache(dir).p.models, expected);
+    const fresh = cachedProfileWindows(dir, 'p', { now: 1_000 + 3_600_000 + 60_000 });
+    assert.equal(fresh.m.output, undefined);
+    assert.equal(fresh.m.context, 300000);
+    const third = await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 + 7_200_000 });
+    assert.equal(hits, 3);
+    assert.deepEqual(third.m, { context: 300000, compact: 150000, output: 8192 }, 'an output-only list keeps the windows');
+  } finally {
+    sink.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/windows.mjs

@@ -84,8 +84,20 @@ export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey,
   const entry = cache[cacheKey] || {};
   const fresh = entry.at && now - entry.at < ttlMs;
   if (fresh) return entry.models || {};
-  const models = await fetchProfileWindows(baseURL, apiKey);
-  if (Object.keys(models).length) {
+  const listed = await fetchProfileWindows(baseURL, apiKey);
+  if (Object.keys(listed).length) {
+    // Merged per model and per number: a list that names only an output limit keeps the cached windows.
+    // An output limit is never carried forward: the entry is stamped now, so it must be one this list states.
+    const models = {};
+    for (const [id, w] of Object.entries(entry.models || {})) {
+      const { output: _output, ...windows } = w && typeof w === 'object' ? w : {};
+      models[id] = windows;
+    }
+    for (const [id, w] of Object.entries(listed)) {
+      const merged = { ...(models[id] || {}) };
+      for (const [k, v] of Object.entries(w)) if (v > 0 || !(merged[k] > 0)) merged[k] = v;
+      models[id] = merged;
+    }
     cache[cacheKey] = { at: now, baseURL, models };
     writeWindowsCache(stateDir, cache);
     return models;
@@ -93,6 +105,21 @@ export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey,
   return entry.models || {};
 }
 
+// One address however it is spelled: scheme and host are case-blind, and a trailing slash adds nothing.
+export function normalizeBaseURL(baseURL) {
+  return String(baseURL || '').trim().replace(/\/+$/, '').replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, m => m.toLowerCase());
+}
+
+export function windowsCacheKey(profileKey, baseURL) {
+  return `${profileKey || 'profile'}@${normalizeBaseURL(baseURL)}`;
+}
+
+// The cached windows of one profile while they are fresh, without reading the list again.
+export function cachedProfileWindows(stateDir, cacheKey, { ttlMs = DEFAULT_TTL_MS, now = Date.now() } = {}) {
+  const entry = readWindowsCache(stateDir)[cacheKey];
+  return entry?.at && now - entry.at < ttlMs ? entry.models || {} : {};
+}
+
 export function windowsCachePath(stateDir) {
   return path.join(stateDir, 'model-windows.json');
 }