llm-switcher 1.4.1 → 1.6.2

package/tests/idlecompact.e2e.test.mjs

@@ -0,0 +1,203 @@
+// Actual proxy -> HTTP mock upstream; no external provider or official account is used.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const listen = server => new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+async function unusedPort() {
+  const server = http.createServer(); await listen(server); const port = server.address().port;
+  await new Promise(resolve => server.close(resolve)); return port;
+}
+async function until(predicate, detail = 'condition', timeout = 5000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) { if (await predicate()) return; await new Promise(resolve => setTimeout(resolve, 20)); }
+  throw new Error(`timeout waiting for ${detail}`);
+}
+function history() {
+  const messages = [{ role: 'user', content: 'task' }];
+  for (let i = 0; i < 12; i++) messages.push(
+    { role: 'assistant', content: [{ type: 'text', text: `DECISION_${i}` },
+      { type: 'tool_use', id: `t${i}`, name: 'Read', input: { file_path: '/test' } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: `t${i}`, content: `RESULT_${i} ` + 'X'.repeat(4000) }] });
+  return messages;
+}
+
+async function fixture(t, { model = '', codex = false } = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-idle-e2e-'));
+  const received = []; const pendingSummaries = [];
+  const upstream = http.createServer((req, res) => {
+    let raw = '';
+    req.on('data', chunk => raw += chunk);
+    req.on('end', () => {
+      const body = raw ? JSON.parse(raw) : {};
+      received.push({ url: req.url, body });
+      res.setHeader('content-type', 'application/json');
+      if (req.method === 'GET') return res.end(JSON.stringify({ data: [],
+        bifrost_ua: req.url.includes('codex') ? 'codex_exec/' : '' }));
+      if (body.model === 'cheap-summary') {
+        pendingSummaries.push({ res, body }); return;
+      }
+      if (req.url.endsWith('/responses')) return res.end(JSON.stringify({ id: 'resp_test', object: 'response',
+        status: 'completed', model: body.model, output: [{ type: 'message', role: 'assistant',
+          content: [{ type: 'output_text', text: 'ok' }] }] }));
+      res.end(JSON.stringify({ id: 'msg_test', type: 'message', role: 'assistant', model: body.model,
+        content: [{ type: 'text', text: 'ok' }], stop_reason: 'end_turn', usage: { input_tokens: 2, output_tokens: 1 } }));
+    });
+  });
+  await listen(upstream); const port = await unusedPort();
+  const cfg = { port, activeProfiles: {}, profiles: {
+    p1: { name: 'Offline', mode: 'hybrid', baseURL: `http://127.0.0.1:${upstream.address().port}/v1`, apiKey: 'fixture-only' },
+  }, idleCompact: { enabled: true, codex, model, minBytes: 8192, keepRecent: 6 } };
+  const config = path.join(dir, 'config.json'); fs.writeFileSync(config, JSON.stringify(cfg));
+  const nativeDir = path.join(dir, 'native'); fs.mkdirSync(nativeDir);
+  const nativeFiles = ['projects/test-project/session-one.jsonl', 'sessions/2026/10/08/rollout-A.jsonl',
+    'sessions/2026/10/08/rollout-B.jsonl', 'thread_history_1.sqlite'];
+  for (const file of nativeFiles) {
+    fs.mkdirSync(path.dirname(path.join(nativeDir, file)), { recursive: true });
+    fs.writeFileSync(path.join(nativeDir, file), JSON.stringify({ type: 'user', uuid: 'leaf-one',
+      sessionId: 'session-one', message: { role: 'user', content: `UNCHANGED_${file}` } }) + '\n');
+  }
+  const nativeBefore = nativeFiles.map(file => fs.readFileSync(path.join(nativeDir, file)));
+  const nativeMtimes = nativeFiles.map(file => fs.statSync(path.join(nativeDir, file)).mtimeMs);
+  let child, logs = '';
+  const start = async () => {
+    child = spawn(process.execPath, [path.join(root, 'proxy.mjs'), '--port', String(port)], {
+      env: { ...process.env, LLM_SWITCHER_CONFIG: config, LLM_SWITCHER_STATE_DIR: dir,
+        LLM_SWITCHER_PORT: '', LLM_SWITCHER_REGISTRY_URL: 'http://127.0.0.1:9/',
+        CODEX_HOME: nativeDir, CLAUDE_CONFIG_DIR: nativeDir }, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout.on('data', chunk => logs += chunk); child.stderr.on('data', chunk => logs += chunk);
+    await until(async () => (await fetch(`http://127.0.0.1:${port}/health`).catch(() => null))?.ok, `proxy start: ${logs}`);
+  };
+  const stop = async () => {
+    if (!child || child.exitCode !== null) return;
+    const exited = new Promise(resolve => child.once('exit', resolve)); child.kill('SIGTERM');
+    await Promise.race([exited, new Promise(resolve => setTimeout(resolve, 2000))]);
+    if (child.exitCode === null) { child.kill('SIGKILL'); await exited; }
+  };
+  t.after(async () => { await stop(); upstream.closeAllConnections?.();
+    await new Promise(resolve => upstream.close(resolve)); fs.rmSync(dir, { recursive: true, force: true }); });
+  await start();
+  const send = async (body, { session = 'session-one', responses = false } = {}) => {
+    const response = await fetch(`http://127.0.0.1:${port}/v1/${responses ? 'responses' : 'messages'}`, {
+      method: 'POST', headers: { 'content-type': 'application/json', 'x-profile': 'p1',
+        ...(responses ? { 'thread-id': session, 'user-agent': 'codex_exec/0.160' } : { 'x-claude-code-session-id': session }) },
+      body: JSON.stringify(body) });
+    assert.equal(response.status, 200, await response.text());
+    return received.filter(entry => !entry.url.includes('/models') && entry.body.model !== 'cheap-summary').at(-1).body;
+  };
+  const age = () => {
+    const files = fs.readdirSync(path.join(dir, 'idle-compact')).filter(file => file.endsWith('.json'));
+    for (const file of files) { const location = path.join(dir, 'idle-compact', file);
+      const record = JSON.parse(fs.readFileSync(location)); record.seenAt = Date.now() - 16 * 60000;
+      fs.writeFileSync(location, JSON.stringify(record)); }
+  };
+  const finish = index => pendingSummaries[index].res.end(JSON.stringify({ choices: [{ message: { content: `SUMMARY_${index}` } }] }));
+  return { dir, config, cfg, received, pendingSummaries, send, age, finish,
+    restart: async () => { await stop(); await start(); },
+    assertNativeUntouched: () => nativeFiles.forEach((file, index) =>
+      { assert.deepEqual(fs.readFileSync(path.join(nativeDir, file)), nativeBefore[index]); assert.equal(fs.statSync(path.join(nativeDir, file)).mtimeMs, nativeMtimes[index]); }),
+    logs: () => logs, port };
+}
+
+test('proxy retains a stable compact prefix through appended turns and restart without model calls or client writes', { timeout: 20000 }, async t => {
+  const f = await fixture(t); const body = { model: 'claude-probe', stream: false, messages: history() };
+  const initial = await f.send(body); assert.match(JSON.stringify(initial), /RESULT_1 /);
+  f.age(); const shortened = await f.send(body);
+  assert.doesNotMatch(JSON.stringify(shortened), /RESULT_1 /); assert.match(JSON.stringify(shortened), /DECISION_1"/);
+  assert.ok(JSON.stringify(shortened.messages).length < JSON.stringify(body.messages).length / 2);
+  body.messages.push({ role: 'assistant', content: 'NEW_ANSWER' }, { role: 'user', content: 'NEW_REQUEST' });
+  const next = await f.send(body); assert.match(JSON.stringify(next), /NEW_ANSWER.*NEW_REQUEST/);
+  assert.deepEqual(next.messages.slice(0, shortened.messages.length), shortened.messages);
+  await f.restart(); assert.deepEqual((await f.send(body)).messages, next.messages);
+  const cachedFile = fs.readdirSync(path.join(f.dir, 'idle-compact')).find(file => file.endsWith('.json'));
+  fs.writeFileSync(path.join(f.dir, 'idle-compact', cachedFile), '{bad');
+  assert.match(JSON.stringify(await f.send(body)), /RESULT_1 /, 'corrupt cache forwards original history');
+  assert.equal(f.pendingSummaries.length, 0); f.assertNativeUntouched();
+});
+
+test('delayed summary preserves new suffix, maps its own protocol, and loses CAS to a newer idle generation', { timeout: 20000 }, async t => {
+  const f = await fixture(t, { model: 'cheap-summary' });
+  const body = { model: 'claude-probe', stream: false, messages: history() };
+  await f.send(body); f.age(); await f.send(body);
+  await until(() => f.pendingSummaries.length === 1, 'first summary');
+  assert.ok(f.received.some(entry => entry.url === '/v1/chat/completions' && entry.body.model === 'cheap-summary'));
+  assert.doesNotMatch(JSON.stringify(f.pendingSummaries[0].body), /RESULT_11/);
+  body.messages.push({ role: 'assistant', content: 'AFTER_SNAPSHOT_ANSWER' }, { role: 'user', content: 'AFTER_SNAPSHOT_USER' });
+  await f.send(body);
+  f.finish(0); await until(() => f.logs().includes('summary cached'), 'summary storage');
+  const resumed = await f.send(body); assert.match(JSON.stringify(resumed), /SUMMARY_0.*AFTER_SNAPSHOT_ANSWER.*AFTER_SNAPSHOT_USER/);
+  // Force a larger prefix during a subsequent idle window while an older generation is pending.
+  for (let i = 0; i < 8; i++) body.messages.push({ role: 'assistant', content: `NEW_WINDOW_${i} ` + 'Y'.repeat(1000) }, { role: 'user', content: `question ${i}` });
+  f.age(); await f.send(body); await until(() => f.pendingSummaries.length === 2, 'second summary');
+  for (let i = 0; i < 8; i++) body.messages.push({ role: 'assistant', content: `THIRD_WINDOW_${i}` }, { role: 'user', content: `third question ${i}` });
+  f.age(); await f.send(body); await until(() => f.pendingSummaries.length === 3, 'third summary');
+  f.finish(2); await until(() => f.logs().split('summary cached').length >= 3, 'newest summary cached');
+  f.finish(1); await until(() => f.logs().includes('discarded after a newer generation'), 'stale summary rejection');
+  const latest = JSON.stringify(await f.send(body)); assert.match(latest, /SUMMARY_2/); assert.doesNotMatch(latest, /SUMMARY_1/);
+  f.assertNativeUntouched();
+});
+
+test('Responses opt-in compacts actual forwarded input, keeps assistant output_text and both native threads untouched', { timeout: 20000 }, async t => {
+  const f = await fixture(t, { codex: true, model: 'cheap-summary' });
+  const input = [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'task' }] }];
+  for (let i = 0; i < 12; i++) input.push(
+    { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: `DECISION_${i}` }] },
+    { type: 'function_call', call_id: `c${i}`, name: 'read_file', arguments: '{}' },
+    { type: 'function_call_output', call_id: `c${i}`, output: `OUTPUT_${i} ` + 'X'.repeat(4000) });
+  const body = { model: 'codex/probe', input, stream: false, store: false };
+  await f.send(body, { responses: true }); f.age();
+  const shortened = await f.send(body, { responses: true });
+  assert.doesNotMatch(JSON.stringify(shortened.input), /OUTPUT_1 /); assert.match(JSON.stringify(shortened.input), /DECISION_1/);
+  assert.equal(shortened.input.find(item => item.role === 'assistant').content[0].type, 'output_text');
+  await until(() => f.pendingSummaries.length === 1, 'Codex configured summary');
+  f.finish(0); await until(() => f.logs().includes('summary cached'), 'Codex summary storage');
+  body.input.push({ role: 'user', content: 'NEW_CODEX_USER' });
+  await f.restart(); assert.match(JSON.stringify(await f.send(body, { responses: true })), /NEW_CODEX_USER/);
+  f.assertNativeUntouched();
+});
+
+test('native compaction and configuration changes each invalidate an in-flight summary', { timeout: 20000 }, async t => {
+  const f = await fixture(t, { model: 'cheap-summary' });
+  const body = { model: 'claude-probe', messages: history(), stream: false };
+  await f.send(body); f.age(); await f.send(body);
+  await until(() => f.pendingSummaries.length === 1, 'summary before native compact');
+  const native = { ...body, messages: [{ role: 'user', content: 'NATIVE_CONTEXT' },
+    { role: 'assistant', content: 'NATIVE_ANSWER' }, { role: 'user', content: 'NEW_TURN' }] };
+  assert.match(JSON.stringify(await f.send(native)), /NATIVE_CONTEXT.*NEW_TURN/);
+  f.finish(0); await until(() => f.logs().includes('discarded after a newer generation'), 'native compact discards late summary');
+  assert.doesNotMatch(JSON.stringify(await f.send(native)), /SUMMARY_0/);
+  // The larger raw history replaces the native prefix and starts its own idle window.
+  await f.send(body); f.age(); await f.send(body);
+  await until(() => f.pendingSummaries.length === 2, 'summary before config change');
+  const cfg = JSON.parse(fs.readFileSync(f.config)); cfg.idleCompact.model = null;
+  fs.writeFileSync(f.config, JSON.stringify(cfg));
+  f.finish(1); await until(() => f.logs().includes('discarded after configuration change'), 'configuration guard');
+  assert.doesNotMatch(JSON.stringify(await f.send(body)), /SUMMARY_1/);
+  f.assertNativeUntouched();
+});
+
+test('API rejects invalid patch without writing config, accepts all settings, and anonymous calls remain unmodified', { timeout: 20000 }, async t => {
+  const f = await fixture(t); const token = fs.readFileSync(path.join(f.dir, 'admin.token'), 'utf8').trim();
+  const update = patch => fetch(`http://127.0.0.1:${f.port}/api/idle-compact`, { method: 'POST',
+    headers: { 'content-type': 'application/json', 'x-llm-switcher-token': token }, body: JSON.stringify(patch) });
+  const before = fs.readFileSync(f.config);
+  for (const patch of [{ unknown: 1 }, { userChars: 0 }, { codex: 'yes' }, { keepRecent: 0.5 }]) {
+    const response = await update(patch); assert.equal(response.status, 400); await response.text();
+    assert.deepEqual(fs.readFileSync(f.config), before);
+  }
+  const valid = await update({ codex: true, model: null, userChars: 128, summaryMaxChars: 256, sessionLookbackHours: 24 });
+  assert.equal(valid.status, 200); const settings = await valid.json(); assert.equal(settings.idleCompact.codex, true);
+  const body = { model: 'claude-probe', messages: history(), stream: false };
+  const response = await fetch(`http://127.0.0.1:${f.port}/v1/messages`, { method: 'POST', headers: {
+    'content-type': 'application/json', 'x-profile': 'p1' }, body: JSON.stringify(body) });
+  assert.equal(response.status, 200); await response.text();
+  assert.match(JSON.stringify(f.received.at(-1).body), /RESULT_1 /);
+  assert.equal(fs.existsSync(path.join(f.dir, 'idle-compact')), false);
+});

package/tests/idlecompact.test.mjs

@@ -0,0 +1,282 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseToIR } from '../formats.mjs';
+import { idleCompactPolicy, validateIdleCompactPatch, conversationKey, compactIR,
+  compactRawHistory, compactResponsesInput, summaryMessages, summaryReplacement, clampSummary } from '../idlecompact.mjs';
+import { IdlePrefixCache, compactCacheKey } from '../idlecache.mjs';
+import { askSummary } from '../idlecall.mjs';
+
+const policy = (over = {}) => idleCompactPolicy({ idleCompact: { enabled: true, ...over } });
+const fixture = () => {
+  const messages = [{ role: 'user', content: 'Fix the failing test' }];
+  for (let i = 0; i < 12; i++) messages.push(
+    { role: 'assistant', content: [{ type: 'text', text: `DECISION_${i}: preserve the contract` },
+      { type: 'tool_use', id: `call_${i}`, name: 'Read', input: { file_path: `file_${i}` } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: `call_${i}`, content: `RESULT_${i}:` + 'X'.repeat(4000) }] });
+  return { model: 'claude-probe', system: 'Be concise', messages, stream: false };
+};
+const req = (session = 'one', token = 'owner') => ({ headers: { 'x-claude-code-session-id': session, authorization: `Bearer ${token}` } });
+const profile = { baseURL: 'http://127.0.0.1:1234', apiKey: 'PRIVATE_PROVIDER_KEY', outFormat: 'anthropic' };
+
+function cacheFixture(t, options = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-prefix-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  let now = 100000000;
+  const cache = new IdlePrefixCache(dir, { now: () => now, ...options });
+  return { dir, cache, advance(ms) { now += ms; } };
+}
+
+function keyFor(body = fixture(), request = req(), prof = profile, p = policy(), name = 'profile') {
+  return compactCacheKey('anthropic', request, body, parseToIR('anthropic', body), prof, name, p);
+}
+
+test('config accepts all supported fields and rejects unknown, wrong type, zero, and fractional counts', () => {
+  assert.equal(idleCompactPolicy({}).enabled, false);
+  assert.equal(idleCompactPolicy({}).codex, false);
+  assert.equal(validateIdleCompactPatch({ enabled: true, codex: true, userChars: 128,
+    summaryMaxChars: 256, sessionLookbackHours: 168 }), '');
+  assert.equal(validateIdleCompactPatch({ model: null }), '');
+  assert.equal(idleCompactPolicy({ idleCompact: { model: null } }).model, null);
+  for (const patch of [{ unknown: 1 }, { codex: 'yes' }, { userChars: 0 },
+    { keepRecent: 2.5 }, { minBytes: 8191 }, { idleMinutes: Infinity }, { model: {} }]) {
+    assert.notEqual(validateIdleCompactPatch(patch), '', JSON.stringify(patch));
+  }
+  const p = idleCompactPolicy({ idleCompact: { idleMinutes: '4', minBytes: -5,
+    keepRecent: 10000, userChars: 1, unknown: 9 } });
+  assert.equal(p.idleMinutes, 15);
+  assert.equal(p.minBytes, 65536);
+  assert.equal(p.keepRecent, 100);
+  assert.equal(p.userChars, 128);
+  assert.equal('unknown' in p, false);
+});
+
+test('only explicit session identifiers establish cache identity', () => {
+  const ir = parseToIR('anthropic', fixture());
+  assert.equal(conversationKey('anthropic', { headers: {} }, ir), '');
+  assert.equal(conversationKey('anthropic', req(), ir), 'h:one');
+  assert.equal(conversationKey('responses', { headers: { 'thread-id': 'thread-A' } }, {}), 'h:thread-A');
+  assert.equal(conversationKey('responses', { headers: { 'x-codex-turn-metadata': '{"session_id":"thread-B"}' } }, {}), 'h:thread-B');
+  assert.equal(conversationKey('responses', { headers: {} }, { promptCacheKey: 'thread-C' }), 'p:thread-C');
+});
+
+test('scope separates sessions, callers, profiles, models, system prompts, tools, and policies', () => {
+  const body = fixture();
+  const base = keyFor(body);
+  const others = [keyFor(body, req('two')), keyFor(body, req('one', 'other-owner')),
+    keyFor(body, req(), { ...profile, baseURL: 'http://other' }), keyFor(body, req(), profile, policy(), 'other-profile'),
+    keyFor({ ...body, model: 'other-model' }), keyFor({ ...body, system: 'other-system' }),
+    keyFor({ ...body, tools: [{ name: 'Write' }] }), keyFor(body, req(), profile, policy({ model: 'summary' }))];
+  assert.ok(others.every(key => key !== base));
+  assert.match(base, /^[a-f0-9]{64}$/);
+  assert.equal(keyFor(body, { headers: {} }), '');
+});
+
+test('actual parsed assistant tool call keeps its accompanying decision text', () => {
+  const body = fixture();
+  const ir = parseToIR('anthropic', body);
+  assert.ok(ir.messages[1].toolCalls);
+  const compacted = compactIR(ir, policy());
+  assert.match(JSON.stringify(compacted.messages), /DECISION_1:/);
+  assert.doesNotMatch(JSON.stringify(compacted.messages), /RESULT_1:/);
+  assert.match(JSON.stringify(summaryMessages(ir, policy())), /DECISION_1:/);
+  assert.doesNotMatch(JSON.stringify(summaryMessages(ir, policy())), /X{4000}/);
+});
+
+test('raw compact prefix keeps exact opening and suffix without dangling tool results', () => {
+  const body = fixture();
+  for (const keepRecent of [1, 2, 3, 6, 9]) {
+    const p = policy({ keepRecent });
+    const compacted = compactRawHistory(body.messages, 'anthropic', p);
+    assert.ok(compacted);
+    assert.deepEqual(compacted.history[0], body.messages[0]);
+    assert.deepEqual(compacted.history.slice(compacted.replacement.length), body.messages.slice(compacted.prefixCount));
+    const calls = new Set();
+    for (const message of compacted.history) for (const block of Array.isArray(message.content) ? message.content : []) {
+      if (block.type === 'tool_use') calls.add(block.id);
+      if (block.type === 'tool_result') assert.ok(calls.has(block.tool_use_id));
+    }
+  }
+});
+
+test('a result deeper in the tail keeps its older call, and malformed orphan input is forwarded', () => {
+  const body = fixture();
+  body.messages[20] = { role: 'user', content: 'result still pending' };
+  body.messages.push({ role: 'user', content: 'An intervening question' },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'call_9', content: 'delayed result' }] });
+  const compacted = compactRawHistory(body.messages, 'anthropic', policy({ keepRecent: 2 }));
+  assert.ok(compacted.prefixCount <= 19);
+  const orphan = structuredClone(body.messages);
+  orphan.at(-1).content[0].tool_use_id = 'missing';
+  assert.equal(compactRawHistory(orphan, 'anthropic', policy({ keepRecent: 2 })), null);
+});
+
+test('multiple calls pair correctly, mixed result text survives, and missing or duplicate IDs are rejected', () => {
+  const body = fixture();
+  body.messages[2].content.push({ type: 'text', text: 'USER_DECISION_KEEP' });
+  const good = compactRawHistory(body.messages, 'anthropic', policy());
+  assert.match(JSON.stringify(good.replacement), /USER_DECISION_KEEP/);
+  for (const change of [messages => delete messages[1].content[1].id,
+    messages => messages[3].content[1].id = 'call_0',
+    messages => messages[4].content[0].tool_use_id = 'call_0']) {
+    const messages = structuredClone(body.messages); change(messages);
+    assert.equal(compactRawHistory(messages, 'anthropic', policy()), null);
+  }
+  body.messages.at(-2).content.push({ type: 'tool_use', id: 'concurrent', name: 'Bash', input: {} });
+  body.messages.at(-1).content.push({ type: 'tool_result', tool_use_id: 'concurrent', content: 'parallel result' });
+  assert.ok(compactRawHistory(body.messages, 'anthropic', policy({ keepRecent: 1 })));
+});
+
+test('unknown Anthropic server tools and tool references prevent shortening', () => {
+  for (const type of ['server_tool_use', 'web_search_tool_result', 'bash_code_execution_tool_result', 'tool_reference']) {
+    const body = fixture(); body.messages.at(-1).content.push({ type, id: 'server-id', content: 'result' });
+    assert.equal(compactRawHistory(body.messages, 'anthropic', policy()), null, type);
+  }
+});
+
+test('Responses assistant text uses output_text and deeper custom tool results retain calls', () => {
+  const input = [{ role: 'developer', content: 'policy' }, { role: 'user', content: 'task' }];
+  for (let i = 0; i < 10; i++) input.push(
+    { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: `decision ${i}` }] },
+    { type: 'custom_tool_call', call_id: `c${i}`, name: 'shell', input: 'ls' },
+    { type: 'custom_tool_call_output', call_id: `c${i}`, output: 'X'.repeat(4000) });
+  input[25] = { type: 'message', role: 'user', content: 'output pending' };
+  input.push({ role: 'user', content: 'new turn' }, { type: 'custom_tool_call_output', call_id: 'c7', output: 'delayed' });
+  const compacted = compactRawHistory(input, 'responses', policy({ keepRecent: 2 }));
+  assert.ok(compacted);
+  const assistant = compacted.replacement.find(item => item.role === 'assistant');
+  assert.equal(assistant.content[0].type, 'output_text');
+  const calls = new Set();
+  for (const item of compactResponsesInput(input, policy({ keepRecent: 2 }))) {
+    if (item.type === 'custom_tool_call') calls.add(item.call_id);
+    if (item.type === 'custom_tool_call_output') assert.ok(calls.has(item.call_id));
+  }
+});
+
+test('stable cached prefix preserves every new suffix turn and survives a gateway restart', t => {
+  const { cache, dir, advance } = cacheFixture(t);
+  const body = fixture(); const p = policy(); const key = keyFor(body);
+  assert.equal(cache.visit(key, body.messages, p).history, null);
+  advance(16 * 60000);
+  assert.equal(cache.visit(key, body.messages, p).idleMs, 16 * 60000);
+  const compacted = compactRawHistory(body.messages, 'anthropic', p);
+  assert.ok(cache.create(key, body.messages, compacted.prefixCount, compacted.replacement, p));
+  const suffix = [{ role: 'assistant', content: 'NEW_ANSWER' }, { role: 'user', content: 'NEW_REQUEST' }];
+  const resumed = new IdlePrefixCache(dir, { now: cache.now });
+  const result = resumed.visit(key, [...body.messages, ...suffix], p);
+  assert.deepEqual(result.history, [...compacted.replacement, ...body.messages.slice(compacted.prefixCount), ...suffix]);
+  assert.deepEqual(resumed.visit(key, [...body.messages, ...suffix], p).history, result.history);
+  const contents = fs.readFileSync(path.join(dir, 'idle-compact', `${key}.json`), 'utf8');
+  assert.doesNotMatch(contents, /PRIVATE_PROVIDER_KEY|Bearer owner|RESULT_1:/);
+  if (process.platform !== 'win32') {
+    assert.equal(fs.statSync(path.join(dir, 'idle-compact')).mode & 0o777, 0o700);
+    assert.equal(fs.statSync(path.join(dir, 'idle-compact', `${key}.json`)).mode & 0o777, 0o600);
+  }
+});
+
+test('native client compact or edited history invalidates cached prefix and rejects late summary', t => {
+  const { cache } = cacheFixture(t); const body = fixture(); const p = policy(); const key = keyFor(body);
+  const compacted = compactRawHistory(body.messages, 'anthropic', p);
+  const original = cache.create(key, body.messages, compacted.prefixCount, compacted.replacement, p);
+  assert.equal(cache.visit(key, [{ role: 'user', content: 'NATIVE SUMMARY' }], p).history, null);
+  assert.equal(cache.upgrade(key, original.generation, summaryReplacement(compacted, 'OLD'), p), false);
+  const second = cache.create(key, body.messages, compacted.prefixCount, compacted.replacement, p);
+  assert.equal(cache.upgrade(key, original.generation, summaryReplacement(compacted, 'OLD'), p), false);
+  assert.equal(cache.upgrade(key, second.generation, summaryReplacement(compacted, 'CURRENT'), p), true);
+  const suffix = [{ role: 'user', content: 'AFTER SUMMARY REQUEST' }];
+  assert.deepEqual(cache.visit(key, [...body.messages, ...suffix], p).history.at(-1), suffix[0]);
+});
+
+test('corrupt, oversized, expired, and unavailable cache state safely forwards original history', t => {
+  const { cache, dir, advance } = cacheFixture(t); const p = policy(); const key = keyFor(); const body = fixture();
+  cache.visit(key, body.messages, p);
+  const file = path.join(dir, 'idle-compact', `${key}.json`);
+  fs.writeFileSync(file, '{bad');
+  assert.equal(cache.visit(key, body.messages, p).history, null);
+  fs.writeFileSync(file, 'X'.repeat(2 * 1024 * 1024 + 1));
+  assert.equal(cache.visit(key, body.messages, p).history, null);
+  advance(73 * 3600000);
+  assert.equal(cache.visit(key, body.messages, p).idleMs, 0);
+  const impossible = path.join(dir, 'file'); fs.writeFileSync(impossible, 'x');
+  assert.equal(new IdlePrefixCache(impossible).visit(key, body.messages, p).history, null);
+});
+
+test('parseable corruption and a symlinked cache directory cannot replace history or delete external files', t => {
+  const { cache, dir } = cacheFixture(t); const p = policy(); const body = fixture(); const key = keyFor(body);
+  const compacted = compactRawHistory(body.messages, 'anthropic', p);
+  const record = cache.create(key, body.messages, compacted.prefixCount, compacted.replacement, p);
+  const file = path.join(dir, 'idle-compact', `${key}.json`);
+  fs.writeFileSync(file, JSON.stringify({ ...record, replacement: [{ role: 'user', content: 'CORRUPT' }] }));
+  assert.equal(cache.visit(key, body.messages, p).history, null);
+  if (process.platform === 'win32') return;
+  fs.rmSync(path.join(dir, 'idle-compact'), { recursive: true });
+  const outside = path.join(dir, 'outside'); fs.mkdirSync(outside);
+  const external = path.join(outside, `${key}.json`); fs.writeFileSync(external, JSON.stringify(record));
+  fs.symlinkSync(outside, path.join(dir, 'idle-compact'), 'dir');
+  const before = fs.readFileSync(external);
+  assert.equal(cache.visit(key, body.messages, p).history, null);
+  assert.deepEqual(fs.readFileSync(external), before);
+});
+
+test('cache expires by configured lookback and never touches Claude transcripts or either Codex rollout/SQLite file', async t => {
+  const { cache, dir, advance } = cacheFixture(t);
+  const clientDir = path.join(dir, 'clients'); fs.mkdirSync(clientDir);
+  const files = ['claude.jsonl', 'thread-A.jsonl', 'thread-B.jsonl', 'thread_history_1.sqlite'];
+  for (const file of files) fs.writeFileSync(path.join(clientDir, file), `original ${file}`);
+  const before = files.map(file => fs.readFileSync(path.join(clientDir, file)));
+  const p = policy(); const body = fixture(); const compacted = compactRawHistory(body.messages, 'anthropic', p);
+  for (let i = 0; i < 8; i++) { advance(1); cache.create(keyFor(body, req(`session-${i}`)), body.messages, compacted.prefixCount, compacted.replacement, p); }
+  assert.equal(fs.readdirSync(path.join(dir, 'idle-compact')).length, 8);
+  advance(p.sessionLookbackHours * 3600000 + 1);
+  cache.prune(p);
+  assert.equal(fs.readdirSync(path.join(dir, 'idle-compact')).length, 0);
+  files.forEach((file, i) => assert.deepEqual(fs.readFileSync(path.join(clientDir, file)), before[i]));
+});
+
+test('empty summary model calls neither builder nor provider', async () => {
+  let called = false;
+  assert.equal(await askSummary({ ir: parseToIR('anthropic', fixture()), policy: policy(), profile,
+    model: 'official-expensive-model', build() { called = true; }, fetchImpl() { called = true; } }), '');
+  assert.equal(called, false);
+});
+
+test('summary builder exceptions, HTTP failures, tool-only output, and ignored abort are contained with diagnostics', async () => {
+  const ir = parseToIR('anthropic', fixture()); const p = policy({ model: 'free-summary' });
+  const diagnostics = []; const base = { ir, policy: p, profile, model: 'mapped-summary', onDiagnostic: e => diagnostics.push(e.code) };
+  assert.equal(await askSummary({ ...base, build() { throw new Error('bad route'); } }), '');
+  const build = () => ({ url: 'http://unused', headers: {}, upBody: {} });
+  assert.equal(await askSummary({ ...base, build, fetchImpl: async () => new Response('', { status: 429 }) }), '');
+  assert.equal(await askSummary({ ...base, build, fetchImpl: async () => new Response(JSON.stringify({ content: [{ type: 'tool_use', id: 'c', name: 'Read' }] })) }), '');
+  assert.equal(await askSummary({ ...base, build, timeoutMs: 10, fetchImpl: () => new Promise(() => {}) }), '');
+  assert.deepEqual(diagnostics, ['summary-call-failed', 'summary-http-failed', 'summary-empty-output', 'summary-timeout']);
+});
+
+test('configured summary uses supplied mapped model, stripped tools, and bounded text', async () => {
+  const p = policy({ model: 'summary-alias', summaryMaxChars: 256 }); let sent;
+  const result = await askSummary({ ir: parseToIR('anthropic', fixture()), policy: p, profile, model: 'mapped-cheap',
+    build(_profile, model, ir) { assert.equal(model, 'mapped-cheap'); assert.equal(ir.model, model);
+      assert.deepEqual(ir.tools, []); return { url: 'http://mock', headers: {}, upBody: { model, messages: ir.messages } }; },
+    fetchImpl: async (_url, options) => { sent = JSON.parse(options.body);
+      return new Response(JSON.stringify({ choices: [{ message: { content: 'SUMMARY ' + 'X'.repeat(1000) } }] })); } });
+  assert.ok(result.length <= 256);
+  assert.equal(sent.model, 'mapped-cheap');
+  assert.match(JSON.stringify(sent.messages), /DECISION_1:/);
+  assert.equal(clampSummary(null, p), '');
+});
+
+test('invalid legacy numeric text budgets preserve complete text while wrong types default', () => {
+  for (const value of [0, -1, NaN, Infinity]) {
+    const p = policy({ userChars: value, summaryMaxChars: value });
+    const text = '完整原文'.repeat(10000);
+    assert.equal(clampSummary(text, p), text);
+    const msgs = summaryMessages({messages:[{role:'user', content:text}]}, p);
+    assert.equal(JSON.stringify(msgs).includes(text), true);
+  }
+  assert.equal(clampSummary('X'.repeat(50000), policy({summaryMaxChars:1})).length, 50000);
+  for (const value of [null, [], {}, '0', true]) {
+    const p = policy({userChars:value,summaryMaxChars:value});
+    assert.equal(p.userChars, 3000); assert.equal(p.summaryMaxChars, 24000);
+  }
+});