llm-switcher 1.6.12 → 1.6.14

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.14 — 2026-10-12
+
+- **System turn with an odd content shape.** On the translated route, a `system` turn whose `content` is not text and not a list is dropped. Before, the request failed with a `TypeError`.
+
+## Release 1.6.13 — 2026-10-12
+
+- **`switch on` with no profile.** `switch on` gives each tool the profile that it had before `switch off`. A tool that was off stays off. A tool that is on keeps its profile.
+- **System turns on the translated route.** A `system` turn inside the `messages` of an Anthropic request now goes into the system prompt when the proxy translates the request.
+- **System messages on the direct Anthropic route.** A folded `[system] ` text keeps its place between the turns around it. It never moves past an assistant turn. A system message with no text is dropped, and the healer note now says so. A system message after a final assistant prefill becomes the last user turn, so the request no longer ends on the prefill.
+- **Gemini `_placeholder` in `anyOf`.** If one branch of an `anyOf` declares a real `_placeholder` property, the proxy keeps the key in the arguments.
+- **Gemini `_placeholder` and tool names.** If two padded tools map back to one client tool name, the proxy removes nothing for that name.
+- **Retry to another upstream format.** A request that the proxy builds again for another upstream format gets a new tool vocabulary and a new placeholder rule.
+- **Reasoning before a compaction item.** In a Codex request, reasoning that waits for an assistant turn is dropped at a `compaction` item.
+- **Model list cache time.** A cache entry with a time in the future is stale. It no longer stays fresh forever.
+- **More token count forms.** A context overflow message with `128k`, `1m`, `131 072` (no-break space), `131'072` or `1,31,072` gives the full number to Claude Code. A decimal number after `limit` is not read as a token count. A plain `limit N` counts as the maximum only when `tokens` follows the number. A count of zero, or a count too large to be exact, is not read as a token count.
+- **Output limit for every profile.** If a converted request finds no fresh model list for its profile, the proxy reads the list in the background. The request does not wait. The next request gets the limit. Each profile keeps its own limit, also on a shared base URL. The proxy reads `<baseURL>/models` with the API key of the profile, except for a profile with an `endpoints` override. That profile gets no output limit. The `/v1/models` list also does not send the key of that profile to `<baseURL>/models`.
+- **Goal check when the evaluator call fails.** If the native evaluator call fails, the goal check does not let the goal through. A test now holds this behavior.
+- **Test cleanup.** Every test file that makes a temp directory deletes it, also when a test fails. `npm test` deletes `node-compile-cache` only when npm made it for this run. A failed delete no longer changes the exit status of the tests.
+
 ## 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.

package/README.md

@@ -519,7 +519,8 @@ switch status                  # Display status for all active CLI targets
 switch version                 # Show the version and tell you when npm has a newer one
 switch doctor                  # Audit environment, settings & routing
 switch update                  # Install the newest release and restart the gateway on it
-switch on [profile]            # Start the gateway and activate a profile
+switch on                      # Start the gateway; each tool gets back the profile it had before `switch off`
+switch on <profile>            # Start the gateway and activate a profile
 switch <profile>               # Activate a profile for both tools
 switch claude <profile>        # Set the active profile for Claude Code only
 switch codex <profile>         # Set the active profile for Codex only

package/README.vi.md

@@ -516,7 +516,8 @@ switch status                  # Xem trạng thái kích hoạt của tất cả
 switch version                 # Xem version đang chạy và báo khi npm có bản mới
 switch doctor                  # Quét & thanh tra toàn bộ môi trường, settings và định tuyến
 switch update                  # Cài bản mới nhất và khởi động lại gateway trên bản đó
-switch on [profile]            # Khởi động gateway và kích hoạt một profile
+switch on                      # Khởi động gateway; mỗi công cụ lấy lại profile nó có trước `switch off`
+switch on <profile>            # Khởi động gateway và kích hoạt một profile
 switch <profile>               # Kích hoạt một profile cho cả hai công cụ
 switch claude <profile>        # Đặt profile kích hoạt riêng cho Claude Code
 switch codex <profile>         # Đặt profile kích hoạt riêng cho Codex

package/formats.mjs

@@ -24,7 +24,7 @@
 // }
 // ============================================================
 
-import { sanitizeToolName, toolNameMapForIR, rewriteToolNameMentions, rewriteToolSearchArgs } from './toolvocab.mjs';
+import { sanitizeToolName, toolNameMapForIR, rewriteToolNameMentions, rewriteToolSearchArgs, createToolVocab, NULL_TOOL_VOCAB } from './toolvocab.mjs';
 import { decodeCompaction, COMPACTION_INSTRUCTION } from './compaction.mjs';
 
 export const OUT_FORMATS = ['openai-chat', 'anthropic', 'vertex'];
@@ -455,9 +455,22 @@ function anthropicToIR(payload) {
     }
   }
 
+  // Messages has no system role. Left in place, the emitters send such a turn as user text, so fold
+  // it into the system prompt, as responsesToIR and the Chat reader already do.
+  const foldSystemTurn = (msg) => {
+    if (msg.role !== 'system' && msg.role !== 'developer') return false;
+    const text =
+      typeof msg.content === 'string'
+        ? msg.content
+        : Array.isArray(msg.content) ? msg.content.filter(p => p && p.type === 'text').map(p => p.text).join('\n') : '';
+    if (text.trim()) ir.system = ir.system ? `${ir.system}\n\n${text}` : text;
+    return true;
+  };
+
   if (Array.isArray(payload.messages)) {
     for (const msg of payload.messages) {
       if (!msg) continue;
+      if (foldSystemTurn(msg)) continue;
       if (typeof msg.content === 'string') {
         ir.messages.push({ role: msg.role, content: msg.content });
         continue;
@@ -693,8 +706,8 @@ 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 user message ends that turn,
-  // so reasoning still pending there came from an aborted turn and is dropped.
+  // A reasoning item precedes the assistant output it belongs to. A user message or a compaction item
+  // 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) => {
@@ -763,6 +776,7 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
       } else if (item.type === 'additional_tools' && Array.isArray(item.tools)) {
         toolList.push(...item.tools);
       } else if (item.type === 'compaction') {
+        reasoning = '';
         if (allowOpaqueCompaction && !item.encrypted_content?.startsWith('llm-gateway-compact-v1:')) { ir.opaqueCompaction = true; continue; }
         pushText('user', `Conversation summary from an earlier turn:\n${decodeCompaction(item.encrypted_content)}`);
       } else if (item.type === 'compaction_trigger') {
@@ -1592,7 +1606,10 @@ export function stripGeminiPlaceholders(value, schema) {
     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);
+  // A branch that declares a real `_placeholder` makes the key the client's own, so no padded branch strips it.
+  const branches = Array.isArray(schema.anyOf) ? schema.anyOf : [];
+  const declared = branches.some(b => !isGeminiPadded(b) && b?.properties && Object.hasOwn(b.properties, '_placeholder'));
+  for (const branch of branches) if (!(declared && isGeminiPadded(branch))) out = stripGeminiPlaceholders(out, branch);
   return out;
 }
 
@@ -1618,8 +1635,14 @@ export function geminiPaddedTools(upBody) {
 // 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];
+  // By client name too. Two padded tools that one client name maps back to make that name
+  // ambiguous, so it gets no strip, as the vocabulary refuses a tie.
+  const byClient = new Map();
+  for (const [upstream, schema] of padded) {
+    const client = vocab.name(upstream);
+    byClient.set(client, byClient.has(client) ? null : schema);
+  }
+  const schemaOf = (name) => padded.get(name) || byClient.get(vocab.name(name)) || byClient.get(name);
   const args = (name, argsJson) => {
     const out = vocab.args(name, argsJson);
     const schema = schemaOf(name);
@@ -1640,6 +1663,26 @@ export function withGeminiPlaceholderStrip(vocab, padded) {
   };
 }
 
+// The tool vocabulary the caller declared, so a model that answers with a name from its own
+// training is written back in the caller's words instead of ending the turn with "No such tool
+// available". Built once per request from the tools the caller actually sent, so a request that
+// declared none pays nothing and a turn where the model agreed with the list changes nothing.
+export function toolVocabForIR(ir, outFormat) {
+  if (!ir || typeof ir !== 'object') return NULL_TOOL_VOCAB;
+  if (ir._vocab?.outFormat !== outFormat) {
+    const vocab = createToolVocab(ir.tools, { allowHyphens: outFormat !== 'vertex', names: [...toolNameMapForIR(ir).forward.keys()] });
+    ir._vocab = { outFormat, vocab: withGeminiPlaceholderStrip(vocab, ir._geminiPadded) };
+  }
+  return ir._vocab.vocab;
+}
+
+// Read by toolVocabForIR when the answer is rendered: the arguments lose the keys padding added.
+// Called on every emit, so a rebuild of the same IR never keeps the strip of an earlier body.
+export function recordGeminiPadding(ir, upBody, gemini) {
+  ir._geminiPadded = gemini && Array.isArray(upBody?.tools) ? geminiPaddedTools(upBody) : null;
+  ir._vocab = null;
+}
+
 function toGeminiSchema(schema, root, seen) {
   const nested = Boolean(root);
   const emptyProperties = () => (nested ? { ...GEMINI_PLACEHOLDER_PROPERTIES } : {});
@@ -1824,29 +1867,28 @@ function endsInUnsignedToolLoop(messages) {
 function healAnthropicPayload(payload) {
   const notes = [];
   if (!payload || !Array.isArray(payload.messages)) return { payload, changed: false, notes };
-  // 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.
+  // Anthropic has no system role inside messages. Its text becomes a user turn in the same place, so it
+  // never moves past an assistant turn; Step 0 merges it into a user turn beside it, Steps 1-3 keep a tool_result first.
   const src = [];
-  let pendingSystem = [];
-  const withSystem = (m) => ({ ...m, content: [...toAnthropicBlocks(m.content), ...pendingSystem] });
+  let folded = false;
+  let droppedSystem = false;
   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}` });
+      const blocks = toAnthropicBlocks(m.content);
+      const kept = blocks.filter(b => b.type === 'text' && !isBlankText(b));
+      if (!kept.length || kept.length !== blocks.length) droppedSystem = true;
+      if (kept.length) {
+        src.push({ role: 'user', content: [{ type: 'text', text: `[system] ${kept.map(b => b.text).join('\n')}` }] });
+        folded = true;
+      }
       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;
+  if (folded) notes.push('folded system messages into user turns');
+  if (droppedSystem) notes.push('dropped system content with no text');
+  let changed = folded || droppedSystem || src.length !== payload.messages.length;
 
   let system = payload.system;
   if (Array.isArray(system) && system.some(isBlankText)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.12",
+  "version": "1.6.14",
   "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,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,
+  toolVocabForIR, recordGeminiPadding,
   toGeminiSchema, isAntigravityModel, refusesImageInput, omitChatImages,
   createAnthropicStream, createChatStream, createResponsesStream, createVertexStream,
   buildAnthropicMessage, buildChatMessage, buildResponsesMessage, buildVertexMessage,
@@ -27,8 +27,7 @@ import {
   codexModelEntry,
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
-import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows, windowsCacheKey, cachedProfileWindows } from './windows.mjs';
-import { createToolVocab, NULL_TOOL_VOCAB, toolNameMapForIR } from './toolvocab.mjs';
+import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows, windowsCacheKey, cachedProfileWindows, createWindowsRefresher } from './windows.mjs';
 import { readUpstreamPayloads } from './upstream-stream.mjs';
 import { compactionResponse, emitCompaction, expandGatewayCompactions, collectCompaction } from './compaction.mjs';
 import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
@@ -387,15 +386,26 @@ 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');
+// A count may group its digits (131,072 / 131.072 / 131 072 / 131'072 / 1,31,072, also with U+00A0 or U+202F) or
+// carry a k or m suffix. A dot before exactly three digits reads as a group, so 3.141 reads as 3141: the cost of
+// reading 131.072. Any other decimal part (0.125, 3.14) with no k or m after it is no token count.
+const TOKEN_COUNT = String.raw`(\d+(?:\.\d+)?[km](?![a-z])|[1-9]\d?(?:,\d\d)+,\d{3}(?![.,]?\d)|[1-9]\d{0,2}(?:[,. _'\u00a0\u202f]\d{3})+(?![.,]?\d)|\d+(?![.,]?\d))`;
+// A bare "limit" may be a rate or a time, so it counts only when "tokens" follows the number.
+const MAX_TOKENS_RE = new RegExp(String.raw`(?:maximum context length|context window|tokens? limit) (?:is |of )?${TOKEN_COUNT}|limit (?:is |of )?${TOKEN_COUNT}(?= ?tokens?\b)`, 'i');
 const ASKED_TOKENS_RE = new RegExp(String.raw`(?:requested|resulted in|prompt (?:is|has|contains)|input (?:is|has)) (?:about )?` + TOKEN_COUNT, 'i');
 
+function tokenCount(text) {
+  if (!text) return '';
+  const short = text.match(/^(\d+(?:\.\d+)?)([km])$/i);
+  const n = short ? Math.round(Number(short[1]) * (short[2].toLowerCase() === 'k' ? 1e3 : 1e6)) : Number(text.replace(/\D/g, ''));
+  return Number.isSafeInteger(n) && n > 0 ? String(n) : '';
+}
+
 function promptTooLongMessage(message) {
   if (/^prompt is too long/i.test(message)) return message;
-  const max = message.match(MAX_TOKENS_RE)?.[1]?.replace(/\D/g, '');
-  const asked = message.match(ASKED_TOKENS_RE)?.[1]?.replace(/\D/g, '');
+  const m = message.match(MAX_TOKENS_RE);
+  const max = tokenCount(m?.[1] ?? m?.[2]);
+  const asked = tokenCount(message.match(ASKED_TOKENS_RE)?.[1]);
   return max && asked ? `prompt is too long: ${asked} tokens > ${max} maximum (${message})` : `prompt is too long: ${message}`;
 }
 
@@ -494,19 +504,6 @@ function upstreamEndpoint(profile, outFormat, model, stream, req) {
   return { url: ov['openai-chat'] || `${base}/chat/completions`, headers };
 }
 
-// The tool vocabulary the caller declared, so a model that answers with a name from its own
-// training is written back in the caller's words instead of ending the turn with "No such tool
-// available". Built once per request from the tools the caller actually sent, so a request that
-// 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) {
-    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);
@@ -837,11 +834,20 @@ function resolveThinkingEffort(profile, slot, mappedModel) {
   return profile?.thinkingEffort || 'auto';
 }
 
+const refreshProfileWindows = createWindowsRefresher(STATE_DIR, { debug: (...a) => debugLog(...a) });
+
+// A profile with an endpoints override sends its requests past baseURL, so its key must not go to baseURL/models.
+const routesThroughOverride = (profile) => Object.values(profile?.endpoints || {}).some(Boolean);
+
 // 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.
+// list names one. With no fresh entry the list is read in the background; this request never waits.
 function modelOutputLimit(profileKey, profile, mappedModel) {
   if (!profile?.baseURL || !mappedModel) return 0;
-  const output = Number(cachedProfileWindows(STATE_DIR, windowsCacheKey(profileKey, profile.baseURL))[mappedModel]?.output);
+  if (routesThroughOverride(profile)) return 0;
+  const key = windowsCacheKey(profileKey, profile.baseURL);
+  const models = cachedProfileWindows(STATE_DIR, key);
+  if (!Object.keys(models).length) refreshProfileWindows(key, profile.baseURL, profile.apiKey);
+  const output = Number(models[mappedModel]?.output);
   return output > 0 ? output : 0;
 }
 
@@ -858,9 +864,8 @@ function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = n
     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);
   }
+  recordGeminiPadding(ir, upBody, outFormat === 'vertex' || (outFormat === 'openai-chat' && isAntigravityModel(mappedModel)));
   const { url, headers } = upstreamEndpoint(profile, outFormat, mappedModel, ir.stream, req);
   return { url, headers, upBody };
 }
@@ -1382,7 +1387,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       const out = clientMessage(clientFormat, {
         model: requestedModel || mappedModel, think, text: [split.text], tools, toolMeta: ir.toolMeta,
         finish: col.finish, prompt: col.prompt, completion, cached: col.cached,
-        reasoning: col.reasoning, sig: col.sig, vocab: toolVocabFor(ir, outFormat)
+        reasoning: col.reasoning, sig: col.sig, vocab: toolVocabForIR(ir, outFormat)
       });
       sendJson(res, 200, out);
       answered = true;
@@ -1399,7 +1404,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       'Connection': 'keep-alive',
       'X-Accel-Buffering': 'no'
     });
-    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir, outFormat) });
+    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabForIR(ir, outFormat) });
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));
     const streamError = await pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal: ac.signal, sink: res, tag: profileKey });
@@ -1972,6 +1977,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 {};
+  if (routesThroughOverride(profile)) return readLocalCodexWindows();
   const listed = await resolveProfileWindows(STATE_DIR, windowsCacheKey(profileKey, profile.baseURL), profile.baseURL, profile.apiKey);
   if (Object.keys(listed).length) return listed;
   return readLocalCodexWindows();
@@ -2629,7 +2635,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
       if (socket.writable) {
         socket.write(encodeWsFrame(JSON.stringify(d)));
       }
-    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir, outFormat) });
+    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabForIR(ir, outFormat) });
 
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));

package/scripts/run-tests.mjs

@@ -6,28 +6,64 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
-const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
-const files = [];
-(function walk(dir) {
-  for (const e of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-    const p = path.join(dir, e.name);
-    if (e.isDirectory()) walk(p);
-    else if (e.name.endsWith('.test.mjs')) files.push(path.relative(root, p));
+function holdsFile(dir) {
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!e.isDirectory() || holdsFile(path.join(dir, e.name))) return true;
   }
-})(path.join(root, 'tests'));
-
-// 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);
+  return false;
+}
+
+// npm makes node-compile-cache in TMPDIR as it starts and writes files only as it exits, so an empty cache is taken
+// as made by this run. Not exact: the empty cache of another npm run still in progress goes too, which costs that
+// run a rebuild only. npm makes the directory before this script starts, so no earlier existence check can tell.
+export function compileCacheIsNew(dir, env = process.env) {
+  if (!env.npm_lifecycle_event) return false;
+  try {
+    return !holdsFile(dir);
+  } catch {
+    return false; // missing or unreadable: nothing of ours to remove
+  }
+}
+
+export function removeQuietly(dir, rm = fs.rmSync) {
+  try {
+    rm(dir, { recursive: true, force: true });
+  } catch (err) {
+    console.error(`run-tests: could not remove ${dir}: ${err.message}`);
+  }
+}
+
+function main() {
+  const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const files = [];
+  (function walk(dir) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith('.test.mjs')) files.push(path.relative(root, p));
+    }
+  })(path.join(root, 'tests'));
+
+  // A version check must never reach the real npm registry.
+  const env = { ...process.env, LLM_SWITCHER_REGISTRY_URL: 'http://127.0.0.1:9/' };
+  const compileCache = path.join(os.tmpdir(), 'node-compile-cache');
+  const npmMadeCache = compileCacheIsNew(compileCache);
+
+  const r = spawnSync(process.execPath, ['--test', ...process.argv.slice(2), ...files], { cwd: root, stdio: 'inherit', env });
+  if (npmMadeCache) removeQuietly(compileCache);
+  process.exit(r.status ?? 1);
+}
+
+// node runs a symlinked script from its real path, so only real paths compare. A path that cannot be
+// resolved is not this script: returning false keeps an import by the test from running the suite.
+export function isMainModule(argv1, selfUrl = import.meta.url) {
+  if (!argv1) return false;
+  try {
+    return fs.realpathSync(path.resolve(argv1)) === fs.realpathSync(fileURLToPath(selfUrl));
+  } catch {
+    return false;
+  }
+}
+
+// Imported by its test, run by `npm test`.
+if (isMainModule(process.argv[1])) main();

package/switch.mjs

@@ -357,6 +357,7 @@ function printTargets(activeMap) {
 // Applies the switch to a copy of `base`. Exits on an error; nothing is written here.
 function planSwitch(base, key, cliTarget) {
   const planned = structuredClone(base);
+  delete planned.resumeProfiles;
   const err = cliTarget ? setTargetProfile(planned, cliTarget, key) : activateProfile(planned, key);
   if (err) {
     console.error(`[Error] ${show(err)}`);
@@ -365,6 +366,18 @@ function planSwitch(base, key, cliTarget) {
   return planned;
 }
 
+// Bare `switch on`: the targets `switch off` turned off come back as they were. A target the user
+// switched off stays off, and a target that is on keeps its profile.
+function planResume(base) {
+  const planned = structuredClone(base);
+  const saved = planned.resumeProfiles;
+  delete planned.resumeProfiles;
+  if (saved && typeof saved === 'object' && !Object.values(getActiveMap(planned)).some(Boolean)) {
+    for (const t of TOOLS) if (saved[t]) setTargetProfile(planned, t, saved[t]);
+  }
+  return planned;
+}
+
 function refuseBlindfoldProblem(planned, port) {
   const bf = computeLaunchState(planned, port).blindfold;
   // A missing or outdated certificate is built here; only a set that cannot be built stops the switch.
@@ -386,21 +399,26 @@ async function turnOn(profileName, cliTarget) {
   }
 
   const port = getTargetPort();
-  const wanted = profileName || config.activeProfile || Object.keys(config.profiles)[0];
-  const key = findProfileKey(config, wanted);
-  if (!key) {
-    console.error(`[Error] Profile "${show(wanted)}" not found in config.json!`);
+  const resume = !profileName && !cliTarget;
+  const key = resume ? null : findProfileKey(config, profileName);
+  if (!resume && !key) {
+    console.error(`[Error] Profile "${show(profileName)}" not found in config.json!`);
     console.error(`Available profiles: ${show(Object.keys(config.profiles).join(', ')) || '(none)'}`);
     process.exit(1);
   }
 
   // Plan on a copy. Nothing is written until every check below passes.
-  let planned = planSwitch(config, key, cliTarget);
+  const plan = (base) => (resume ? planResume(base) : planSwitch(base, key, cliTarget));
+  let planned = plan(config);
   // The example config routes to YOUR-ROUTER-HOST; activating it silently makes every request fail.
-  if (hasPlaceholder(planned.profiles[key])) {
-    console.warn(`[WARN] Profile "${show(key)}" still has a placeholder baseURL/apiKey. Edit ${configPath} first, or requests will fail.`);
+  for (const k of new Set(resume ? Object.values(getActiveMap(planned)).filter(Boolean) : [key])) {
+    if (hasPlaceholder(planned.profiles[k])) {
+      console.warn(`[WARN] Profile "${show(k)}" still has a placeholder baseURL/apiKey. Edit ${configPath} first, or requests will fail.`);
+    }
   }
-  console.log(`Activating profile: [${show(planned.profiles[key].name || key)}] (${show(key)})${cliTarget ? ` for ${cliTarget}` : ''} on port ${port}...`);
+  console.log(resume
+    ? `Starting the gateway on port ${port} with the targets as they were...`
+    : `Activating profile: [${show(planned.profiles[key].name || key)}] (${show(key)})${cliTarget ? ` for ${cliTarget}` : ''} on port ${port}...`);
 
   const gatewayState = await probeGateway(port);
   if (isHeld(gatewayState)) refuseForeignPort(port, 'this switcher', gatewayState);
@@ -417,9 +435,8 @@ async function turnOn(profileName, cliTarget) {
     console.error(`[Error] config.json does not parse any more: ${getLastLoadError()?.message}. Nothing was changed.`);
     process.exit(1);
   }
-  planned = planSwitch(current, key, cliTarget);
+  planned = plan(current);
   refuseBlindfoldProblem(planned, port);
-  const profile = planned.profiles[key];
 
   const previousBytes = fs.readFileSync(configPath);
   try {
@@ -471,8 +488,14 @@ async function turnOn(profileName, cliTarget) {
     console.warn(`[Shim] ${err.message}`);
   }
 
-  console.log(`\n[SUCCESS] Switched to profile "${show(profile.name || key)}".`);
-  printProfile(profile);
+  if (resume) {
+    console.log('\n[SUCCESS] Gateway is on.');
+    if (!Object.values(getActiveMap(planned)).some(Boolean)) console.log('No target is on. Turn one on with: switch <profile>');
+  } else {
+    const profile = planned.profiles[key];
+    console.log(`\n[SUCCESS] Switched to profile "${show(profile.name || key)}".`);
+    printProfile(profile);
+  }
   console.log('\nActive targets:');
   printTargets(getActiveMap(planned));
   const codexKey = getActiveMap(planned).codex;
@@ -578,6 +601,7 @@ async function turnOff(targetArg) {
     console.log('\n[SUCCESS] Switched back to Claude Official Subscription. Run `switch on` to re-enable.');
     return;
   }
+  config.resumeProfiles = getActiveMap(config);
   deactivateAll(config);
   saveConfig(config);
   reportSettings(clearLaunchState(port));
@@ -1337,7 +1361,8 @@ if (cmd === 'off' || cmd === 'stop') {
   console.log('  switch version                 # Show the version and check for a newer one');
   console.log('  switch doctor                  # Audit environment, settings & routing');
   console.log('  switch update                  # Install the newest release and restart the gateway');
-  console.log('  switch on [profile]            # Start gateway & activate profile for all compatible targets');
+  console.log('  switch on                      # Start gateway; each target gets back what it had before `switch off`');
+  console.log('  switch on <profile>            # Start gateway & activate profile for all compatible targets');
   console.log('  switch <profile>               # Activate profile for all compatible targets');
   console.log('  switch claude <profile>        # Set active profile for Claude Code');
   console.log('  switch codex <profile>         # Set active profile for Codex');

package/tests/blindfold.test.mjs

@@ -207,7 +207,7 @@ test('make-certs.sh writes private files and refuses a directory it does not own
     }
     // A failed rebuild (here: no openssl on PATH) must leave the working set untouched.
     const caBefore = fs.readFileSync(path.join(out, 'ca.pem'));
-    const bin = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-bin-'));
+    const bin = fs.mkdtempSync(path.join(base, 'bin-'));
     for (const tool of ['mkdir', 'stat', 'id', 'chmod', 'rm', 'cat', 'dirname', 'mv', 'mktemp']) {
       const real = execFileSync('bash', ['-c', `command -v ${tool}`], { encoding: 'utf8' }).trim();
       fs.symlinkSync(real, path.join(bin, tool));

package/tests/compaction.e2e.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';
@@ -9,9 +9,13 @@ import { fileURLToPath } from 'node:url';
 import { openResponsesWs } from './ws-client.mjs';
 const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const listen = server => new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+// Every temp directory goes once more after the file, so a setup that fails early leaves none behind.
+const made = [];
+after(() => { for (const d of made) fs.rmSync(d, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); });
 async function until(check) { const deadline = Date.now() + 6000; while (Date.now() < deadline) { if (await check()) return; await new Promise(r => setTimeout(r, 20)); } throw new Error('timeout'); }
 async function fixture(t) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-compaction-'));
+  made.push(dir);
   const received = []; let finish = 'stop', truncate = false;
   const up = http.createServer((req, res) => {
     let raw = ''; req.on('data', b => raw += b); req.on('end', () => {

package/tests/contract-lab.test.mjs

@@ -70,7 +70,7 @@ test('the tool version is read from the User-Agent, and a bad one is dropped', (
 
 // ---------------------------------------------------------------- unit: config block
 
-test('contractLab is absent by default, and a saved block survives a rewrite', () => {
+test('contractLab is absent by default, and a saved block survives a rewrite', (t) => {
   assert.deepEqual(contractLabSettings({}), { url: '', apiKey: '', enabled: false });
   assert.deepEqual(contractLabSettings(null), { url: '', apiKey: '', enabled: false });
   // Enabled needs a real http(s) URL and a key: a half-filled block stays off.
@@ -80,6 +80,7 @@ test('contractLab is absent by default, and a saved block survives a rewrite', (
   assert.equal(contractLabSettings({ contractLab: { url: 'http://127.0.0.1:9/', apiKey: 'k', enabled: true } }).url, 'http://127.0.0.1:9');
 
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llm-switcher-lab-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
   const cfgPath = path.join(dir, 'config.json');
   const cfg = { port: 3456, profiles: {}, contractLab: { url: 'http://127.0.0.1:20142', apiKey: 'sk-lab', enabled: true } };
   fs.writeFileSync(cfgPath, JSON.stringify(cfg));
@@ -94,7 +95,6 @@ test('contractLab is absent by default, and a saved block survives a rewrite', (
   // The dashboard must never read the intact key back out of /api/config.
   assert.equal(out.masked.apiKey, MASKED_KEY);
   assert.equal(out.masked.hasApiKey, true);
-  fs.rmSync(dir, { recursive: true, force: true });
 });
 
 // state.mjs reads its config path once per process, so a config test runs in its own process.