llm-switcher 1.6.10 → 1.6.12

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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.
+- **Images to a text-only chat model.** If a chat upstream refuses an image with HTTP 400, the proxy sends the request one more time. In that request, each image is the text `[image omitted: this model does not accept images]`. The retry happens in each request. The proxy remembers nothing between requests.
+- **Test cleanup.** The browser tests and the gateway tests stop the gateway, the stand-in interceptor, an interceptor that the gateway started, and Chromium. They also delete their temp directories. This occurs also when a test fails or the test process gets `SIGTERM`, `SIGINT` or `SIGHUP`.
+
 ## Release 1.6.10 — 2026-10-11
 
 - **`reasoning_content` replay.** On assistant tool-call turns, `auto` mode sends the earlier thinking as `reasoning_content`. `native` mode sends it only when the profile sets `replayReasoning: true`, because a strict OpenAI-compatible server can refuse the field. `off` mode never sends it.

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 } : {});
@@ -1654,6 +1734,13 @@ function emitUpstreamBody(outFormat, ir, model, opts = {}) {
   // thinkingMode 'off' applies to all upstreams: drop the client's thinking entirely.
   let src = normThinkingMode(opts.thinkingMode) === 'off' ? { ...ir, thinking: { type: 'disabled' } } : ir;
   if (isAntigravityModel(model) && src.system) src = { ...src, system: src.system.replace(BILLING_HEADER_RE, '') };
+  // An upstream refuses a max tokens above the model's output limit. The Anthropic body always
+  // carries one (4096 when the client sent none), so that default is clamped too.
+  const limit = opts.maxOutputTokens;
+  if (Number.isFinite(limit) && limit > 0) {
+    const asked = typeof src.params?.maxTokens === 'number' ? src.params.maxTokens : (outFormat === 'anthropic' ? 4096 : null);
+    if (asked != null && asked > limit) src = { ...src, params: { ...src.params, maxTokens: limit } };
+  }
   switch (outFormat) {
     case 'anthropic': return irToAnthropicBody(src, model, opts);
     case 'vertex': return irToVertexBody(src, model, opts);
@@ -1662,6 +1749,31 @@ function emitUpstreamBody(outFormat, ir, model, opts = {}) {
   }
 }
 
+// A text-only chat model refuses an image part with a 400. These are the refusals seen so far;
+// a looser match would turn an unrelated 400 into a silent retry without the image.
+export const IMAGE_OMITTED_TEXT = '[image omitted: this model does not accept images]';
+
+export function refusesImageInput(text) {
+  const t = String(text || '').toLowerCase();
+  return t.includes('unknown variant `image_url`') || t.includes('image_url is only supported by certain models')
+    || t.includes('does not support image') || t.includes('image input is not supported')
+    || (t.includes('vision') && t.includes('not supported'));
+}
+
+// Replaces every image part of a chat body with IMAGE_OMITTED_TEXT, in place. Returns how many it replaced.
+export function omitChatImages(body) {
+  let replaced = 0;
+  for (const m of Array.isArray(body?.messages) ? body.messages : []) {
+    if (!Array.isArray(m?.content)) continue;
+    m.content = m.content.map(p => {
+      if (p?.type !== 'image_url') return p;
+      replaced++;
+      return { type: 'text', text: IMAGE_OMITTED_TEXT };
+    });
+  }
+  return replaced;
+}
+
 // ---------------- native Anthropic healer (direct passthrough) ----------------
 // The anthropic -> anthropic branch skips IR (to preserve thinking signatures, cache_control, documents...),
 // so it patches the Anthropic payload directly, touching only what the API will definitely reject:
@@ -1712,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)) {
@@ -2721,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) {
@@ -2732,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);
@@ -2746,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();
@@ -2773,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;
@@ -2798,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.10",
+  "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,7 +11,8 @@ import { createFrameReader } from './blindfold/wsframe.mjs';
 import {
   OUT_FORMATS, parseToIR, emitUpstreamBody, irToAnthropicBody, createUpstreamNormalizer, createCollector,
   createThinkTagSplitter, splitThinkTags, healAnthropicPayload, estimateTokens, THINKING_MODES, VALID_EFFORTS,
-  toGeminiSchema, isAntigravityModel,
+  geminiPaddedTools, withGeminiPlaceholderStrip,
+  toGeminiSchema, isAntigravityModel, refusesImageInput, omitChatImages,
   createAnthropicStream, createChatStream, createResponsesStream, createVertexStream,
   buildAnthropicMessage, buildChatMessage, buildResponsesMessage, buildVertexMessage,
   createCodeAssistStream, buildCodeAssistMessage
@@ -26,7 +27,7 @@ import {
   codexModelEntry,
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
-import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows } 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,23 +837,48 @@ function resolveThinkingEffort(profile, slot, mappedModel) {
   return profile?.thinkingEffort || 'auto';
 }
 
-function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = null) {
+// 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;
+  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, 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(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 };
 }
 
+// Sends the upstream request. A chat 400 that says the model takes no images is retried once with
+// every image replaced by text. The status arrives before any byte goes to the client, so the client
+// sees only the retry's answer. Nothing is remembered: a false refusal costs one request, not the model.
+async function fetchUpstream(url, headers, upBody, signal, outFormat, profileKey, mappedModel) {
+  const send = () => fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal });
+  const res = await send();
+  const hasImage = outFormat === 'openai-chat' && upBody.messages?.some(m => Array.isArray(m?.content) && m.content.some(p => p?.type === 'image_url'));
+  if (res.status !== 400 || !hasImage) return res;
+  const errText = await res.text().catch(() => '');
+  if (!refusesImageInput(errText)) return new Response(errText, { status: res.status, statusText: res.statusText, headers: res.headers });
+  console.warn(`[${profileKey}] ${mappedModel} refused ${omitChatImages(upBody)} image(s); retrying this request as text`);
+  return send();
+}
+
 // Feeds upstream stream events to a client renderer until the stream ends, fails or is aborted.
 // Returns the stream error, or null. `sink` is the client stream whose backpressure it waits for.
 async function pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal, sink, tag }) {
@@ -975,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);
@@ -993,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)}` };
@@ -1276,13 +1312,13 @@ 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));
 
     let upstreamRes;
     try {
-      upstreamRes = await fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal: ac.signal });
+      upstreamRes = await fetchUpstream(url, headers, upBody, ac.signal, outFormat, profileKey, mappedModel);
     } catch (fetchErr) {
       if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
       console.error(`[${profileKey}] Network error:`, fetchErr.message);
@@ -1936,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();
 }
@@ -2359,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
@@ -2547,13 +2583,13 @@ 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));
 
     let upstreamRes;
     try {
-      upstreamRes = await fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal: ac.signal });
+      upstreamRes = await fetchUpstream(url, headers, upBody, ac.signal, outFormat, profileKey, mappedModel);
     } catch (fetchErr) {
       if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
       console.error(`[${profileKey}:ws] Network error:`, fetchErr.message);

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/cdp.mjs

@@ -5,6 +5,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { reapDirSync, onAbnormalExit } from './helpers.mjs';
 
 const CANDIDATES = [
   process.env.LLM_SWITCHER_CHROMIUM,
@@ -48,7 +49,10 @@ export async function launchBrowser() {
     'about:blank'
   ];
   // POSIX: a process group of its own, so close() can stop the renderers and helpers too.
-  const child = spawn(findChromium(), args, { stdio: ['ignore', 'ignore', 'pipe'], env: { ...process.env, HOME: dir }, detached: process.platform !== 'win32' });
+  // TMPDIR too: Chromium makes its own org.chromium.* dirs there, and they go with the profile.
+  const child = spawn(findChromium(), args, { stdio: ['ignore', 'ignore', 'pipe'], env: { ...process.env, HOME: dir, TMPDIR: dir }, detached: process.platform !== 'win32' });
+  // The browser runs detached, so a test process that ends without close() would leave it running.
+  const cancelExitReap = onAbnormalExit(() => reapDirSync(dir, process.platform !== 'win32' ? [-child.pid] : [child.pid]));
   const stop = (signal) => {
     try {
       if (process.platform !== 'win32') process.kill(-child.pid, signal);
@@ -71,6 +75,8 @@ export async function launchBrowser() {
       stop('SIGKILL');
       await new Promise(r => { child.once('exit', r); setTimeout(r, 3000); });
     }
+    cancelExitReap();
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
     throw new Error(`Chromium did not open a debugging port (exit: ${exited ?? 'killed'})\n${stderr}`);
   }
 
@@ -84,6 +90,7 @@ export async function launchBrowser() {
       return page;
     },
     async close() {
+      cancelExitReap();
       for (const p of pages) p.close();
       // The whole group: a helper that outlives the main process keeps writing into the profile.
       stop('SIGTERM');

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.