llm-switcher 1.6.11 → 1.6.13

package/scripts/run-tests.mjs

@@ -1,21 +1,69 @@
 // 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';
 
-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'));
+  return false;
+}
 
-// 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 r = spawnSync(process.execPath, ['--test', ...process.argv.slice(2), ...files], { cwd: root, stdio: 'inherit', env });
-process.exit(r.status ?? 1);
+// 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.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/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-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/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.

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,9 +13,12 @@ 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, toolVocabForIR, recordGeminiPadding
 } from '../formats.mjs';
+import { NULL_TOOL_VOCAB, createToolVocab } from '../toolvocab.mjs';
 import { assertValidAnthropicEvents } from './helpers.mjs';
+import { encodeCompaction } from '../compaction.mjs';
 
 test('anthropicToIR: stream defaults to false and thinking budget_tokens is preserved', () => {
   const ir = anthropicToIR({ model: 'claude-opus-4-6', max_tokens: 64000, messages: [{ role: 'user', content: 'hi' }], thinking: { type: 'enabled', budget_tokens: 31999 } });
@@ -109,6 +112,15 @@ test('healAnthropicPayload: native Anthropic passthrough keeps the billing heade
   assert.equal(payload.system[0].text, header);
 });
 
+test('anthropicToIR: a system turn folds into the IR system prompt', () => {
+  const ir = anthropicToIR({
+    model: 'claude-opus-4-6', max_tokens: 10,
+    messages: [{ role: 'system', content: 'You are Rem.' }, { role: 'user', content: 'hi' }]
+  });
+  assert.equal(ir.system, 'You are Rem.');
+  assert.deepEqual(ir.messages.map(m => m.role), ['user']);
+});
+
 test('healToolPairs: orphan result -> user text, missing result -> placeholder, adjacency kept', () => {
   const healed = healToolPairs([
     { role: 'user', content: 'start' },
@@ -1388,3 +1400,291 @@ 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', 'user']);
+  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.' }
+  ], 'a tool_result stays first');
+  assert.ok(!texts(msgs[3]).includes('[system]'));
+  assert.deepEqual(msgs[4], { role: 'user', content: [{ type: 'text', text: '[system] Be brief.' }] }, 'a system message after the last assistant turn stays after it');
+  assert.ok(r.notes.includes('folded system messages into user turns'));
+  assert.ok(!r.notes.includes('dropped system content with no text'));
+
+  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' });
+});
+
+// One anyOf branch padded, another declaring a real _placeholder: the key may be the client's own.
+test('the placeholder strip keeps _placeholder when another anyOf branch declares it', () => {
+  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: 'object', properties: { _placeholder: { type: 'string' }, x: { type: 'string' } } }] } }
+  } }] });
+  const schema = geminiPaddedTools(JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro')))).get('run');
+  assert.equal(schema?.properties?.env?.anyOf?.length, 2, 'fixture: a padded branch and a declaring branch');
+  assert.deepEqual(stripGeminiPlaceholders({ env: { _placeholder: 'keep', x: '1' } }, schema), { env: { _placeholder: 'keep', x: '1' } });
+  const lone = { anyOf: [schema.properties.env.anyOf[0], { type: 'STRING' }] };
+  assert.deepEqual(stripGeminiPlaceholders({ A: '1', _placeholder: true }, lone), { A: '1' }, 'with no declaring branch the padded branch still strips');
+});
+
+// The fold keeps each system text between the same turns it sat between, and says what it did.
+test('healAnthropicPayload keeps a folded system text in place and reports dropped system content', () => {
+  const heal = (messages) => healAnthropicPayload({ model: 'x', max_tokens: 10, messages });
+  const before = heal([
+    { role: 'user', content: 'first' },
+    { role: 'system', content: 'Be brief.' },
+    { role: 'assistant', content: 'ok' },
+    { role: 'user', content: 'second' }
+  ]).payload.messages;
+  assert.deepEqual(before, [
+    { role: 'user', content: [{ type: 'text', text: 'first' }, { type: 'text', text: '[system] Be brief.' }] },
+    { role: 'assistant', content: 'ok' },
+    { role: 'user', content: 'second' }
+  ], 'a system message before an assistant turn stays before it');
+
+  const next = heal([
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'ok' },
+    { role: 'system', content: 'Be brief.' },
+    { role: 'user', content: 'second' }
+  ]).payload.messages;
+  assert.deepEqual(next[2], { role: 'user', content: [{ type: 'text', text: '[system] Be brief.' }, { type: 'text', text: 'second' }] }, 'it precedes the user text that followed it');
+
+  const blank = heal([
+    { role: 'user', content: 'first' },
+    { role: 'system', content: '   ' },
+    { role: 'system', content: [{ type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'AA==' } }] },
+    { role: 'assistant', content: 'ok' }
+  ]);
+  assert.equal(blank.changed, true);
+  assert.deepEqual(blank.payload.messages, [{ role: 'user', content: 'first' }, { role: 'assistant', content: 'ok' }]);
+  assert.deepEqual(blank.notes, ['dropped system content with no text'], 'nothing was folded, so the note does not say so');
+});
+
+// Only the blank or non-text blocks of a system message go; its text blocks stay, joined by a newline.
+test('healAnthropicPayload keeps the text of a partly blank system message and joins its blocks with a newline', () => {
+  const heal = (system) => healAnthropicPayload({ model: 'x', max_tokens: 10, messages: [
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'ok' },
+    { role: 'system', content: system },
+    { role: 'user', content: 'second' }
+  ] });
+  const joined = heal([{ type: 'text', text: 'Be brief.' }, { type: 'text', text: 'Use British spelling.' }]);
+  assert.deepEqual(joined.payload.messages[2], { role: 'user', content: [{ type: 'text', text: '[system] Be brief.\nUse British spelling.' }, { type: 'text', text: 'second' }] });
+  assert.deepEqual(joined.notes, ['folded system messages into user turns'], 'nothing was dropped');
+
+  const partial = heal([
+    { type: 'text', text: 'Be brief.' },
+    { type: 'text', text: '   ' },
+    { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'AA==' } },
+    { type: 'text', text: 'Use British spelling.' }
+  ]);
+  assert.equal(partial.changed, true);
+  assert.deepEqual(partial.payload.messages[2], { role: 'user', content: [{ type: 'text', text: '[system] Be brief.\nUse British spelling.' }, { type: 'text', text: 'second' }] }, 'the text is kept, the blank and image blocks are not');
+  assert.deepEqual(partial.notes, ['folded system messages into user turns', 'dropped system content with no text'], 'the note reports the dropped part');
+});
+
+// A compaction item replaces the turns before it, so reasoning still pending there belongs to none after it.
+test('responsesToIR drops pending reasoning at a compaction item', () => {
+  const ir = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'stale plan' }] },
+    { type: 'compaction', encrypted_content: encodeCompaction('earlier work') },
+    { type: 'message', role: 'assistant', content: 'done' }
+  ] });
+  const reply = ir.messages.find(m => m.role === 'assistant');
+  assert.equal(reply.content, 'done');
+  assert.equal(reply.reasoning, undefined);
+
+  const opaque = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'stale plan' }] },
+    { type: 'compaction', encrypted_content: 'opaque-blob' },
+    { type: 'message', role: 'assistant', content: 'done' }
+  ] }, { allowOpaqueCompaction: true });
+  assert.equal(opaque.opaqueCompaction, true, 'fixture: the opaque path');
+  assert.equal(opaque.messages.find(m => m.role === 'assistant').reasoning, undefined);
+
+  // compaction_trigger must be the last item, so nothing after it can take the reasoning.
+  const trigger = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'stale plan' }] },
+    { type: 'compaction_trigger' }
+  ] });
+  assert.equal(trigger.compaction, true);
+  assert.ok(!trigger.messages.some(m => m.reasoning), 'no turn carries the pending reasoning');
+});
+
+test('responsesToIR joins a second reasoning item onto an assistant turn that already has reasoning', () => {
+  const ir = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'first' }] },
+    { type: 'message', role: 'assistant', content: 'looking' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'second' }] },
+    { type: 'function_call', call_id: 'c1', name: 'shell', arguments: '{}' }
+  ] });
+  const turns = ir.messages.filter(m => m.role === 'assistant');
+  assert.equal(turns.length, 1, 'fixture: the call joins the assistant turn');
+  assert.equal(turns[0].reasoning, 'first\nsecond');
+  assert.equal(turns[0].toolCalls.length, 1);
+});
+
+// A retry or fallback can emit the same IR again for another upstream; each emit gets its own strip.
+test('a rebuild for another upstream format does not reuse the tool vocabulary of the first', () => {
+  const schema = { type: 'object', properties: { env: { type: 'object' } } };
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [{ name: 'my-tool', input_schema: schema }, { name: 'run', input_schema: schema }] });
+  const filled = '{"env":{"A":"1","_placeholder":true}}';
+
+  recordGeminiPadding(ir, irToChatBody(ir, 'gpt-5'), false);
+  assert.equal(toolVocabForIR(ir, 'openai-chat').args('my-tool', filled), filled, 'a chat body padded nothing');
+  recordGeminiPadding(ir, JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro'))), true);
+  const vertex = toolVocabForIR(ir, 'vertex');
+  assert.equal(vertex.name('my_tool'), 'my-tool', 'the Vertex name maps back');
+  assert.deepEqual(JSON.parse(vertex.args('my_tool', filled)), { env: { A: '1' } }, 'the Vertex body padded env');
+
+  assert.deepEqual(JSON.parse(vertex.args('run', filled)), { env: { A: '1' } });
+
+  recordGeminiPadding(ir, irToChatBody(ir, 'gpt-5'), false);
+  assert.equal(toolVocabForIR(ir, 'openai-chat').args('run', filled), filled, 'the padding of the Vertex emit is gone');
+});
+
+// Two padded upstream tools that one client name maps back to: neither schema may strip for that name.
+test('the placeholder strip refuses a client name that two padded tools share', () => {
+  const padded = geminiPaddedTools(JSON.parse(JSON.stringify(irToVertexBody(anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [
+    { name: 'a_b', input_schema: { type: 'object', properties: { env: { type: 'object' }, opts: { type: 'string' } } } },
+    { name: 'a_c', input_schema: { type: 'object', properties: { opts: { type: 'object' }, env: { type: 'string' } } } }
+  ] }), 'gemini-3-pro'))));
+  assert.deepEqual([...padded.keys()], ['a_b', 'a_c'], 'fixture: both tools are padded, on different keys');
+  const strip = withGeminiPlaceholderStrip({ ...NULL_TOOL_VOCAB, name: n => (n === 'a_b' || n === 'a_c' ? 'a.b' : n) }, padded);
+  const args = '{"env":{"_placeholder":true},"opts":{"_placeholder":true}}';
+  assert.equal(strip.args('a.b', args), args, 'the client name is ambiguous: nothing is stripped');
+  assert.deepEqual(JSON.parse(strip.args('a_b', args)), { env: {}, opts: { _placeholder: true } }, 'an upstream name keeps its own schema');
+  assert.deepEqual(JSON.parse(strip.args('a_c', args)), { env: { _placeholder: true }, opts: {} });
+
+  // A real collision: `a.b` and `a_b` sanitize alike for Vertex, so `a.b` goes up under an alias with its own schema.
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: 'go' }], tools: [
+    { name: 'a.b', input_schema: { type: 'object', properties: { env: { type: 'object' } } } },
+    { name: 'a_b', input_schema: { type: 'object', properties: { env: { type: 'object', properties: { _placeholder: { type: 'boolean' } } } } } }
+  ] });
+  const body = JSON.parse(JSON.stringify(irToVertexBody(ir, 'gemini-3-pro')));
+  recordGeminiPadding(ir, body, true);
+  const alias = [...ir._geminiPadded.keys()];
+  assert.equal(alias.length, 1, 'fixture: only a.b is padded');
+  assert.notEqual(alias[0], 'a_b');
+  const vocab = toolVocabForIR(ir, 'vertex');
+  const filled = '{"env":{"_placeholder":true}}';
+  assert.equal(vocab.name(alias[0]), 'a.b');
+  assert.deepEqual(JSON.parse(vocab.args(alias[0], filled)), { env: {} });
+  assert.equal(vocab.args('a_b', filled), filled, 'a_b declared its own _placeholder');
+});