llm-switcher 1.6.10 → 1.6.12

package/tests/goalcheck.e2e.test.mjs

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

package/tests/helpers.mjs

@@ -1,4 +1,64 @@
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+// The pids of every process whose command line names `dir`, this one excluded. A gateway records
+// its detached interceptor only once it answers, so a teardown that trusts the record misses one
+// still starting. POSIX only: on Windows it returns [].
+export function pidsNaming(dir) {
+  if (process.platform === 'win32' || !dir) return [];
+  const r = spawnSync('ps', ['-eo', 'pid=,args='], { encoding: 'utf8' });
+  if (r.status !== 0) return [];
+  return r.stdout.split('\n')
+    .map(line => line.trim().match(/^(\d+)\s+(.*)$/))
+    .filter(m => m && m[2].includes(dir) && Number(m[1]) !== process.pid)
+    .map(m => Number(m[1]));
+}
+
+// Stops a child and waits for its exit, so nothing it does later lands in a removed directory.
+export async function stopChild(child, ms = 3000) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  const exited = new Promise(r => child.once('exit', r));
+  child.kill('SIGTERM');
+  if (await Promise.race([exited.then(() => true), sleep(ms).then(() => false)])) return;
+  child.kill('SIGKILL');
+  await Promise.race([exited, sleep(ms)]);
+}
+
+// Stops every process that still names `dir` (SIGTERM, then SIGKILL), then removes the dir.
+export async function reapDir(dir) {
+  for (let i = 0; i < 30; i++) {
+    const left = pidsNaming(dir);
+    if (!left.length) break;
+    for (const pid of left) try { process.kill(pid, i < 20 ? 'SIGTERM' : 'SIGKILL'); } catch { /* gone */ }
+    await sleep(100);
+  }
+  fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+}
+
+// The same, synchronous, for a process that is about to end. A negative pid is a process group.
+export function reapDirSync(dir, pids = []) {
+  for (const pid of [...pids.filter(Number.isInteger), ...pidsNaming(dir)]) try { process.kill(pid, 'SIGKILL'); } catch { /* gone */ }
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort at exit */ }
+}
+
+// Runs `fn` when this process ends before its teardown did: at exit, or on a signal, which ends a
+// test process with no after() hook. Returns the function that cancels it.
+export function onAbnormalExit(fn) {
+  const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+  const run = () => { off(); try { fn(); } catch { /* best effort at exit */ } };
+  // The listener replaces the default action, so the signal is raised again once it is gone.
+  const onSignal = (sig) => { run(); process.kill(process.pid, sig); };
+  function off() {
+    process.off('exit', run);
+    for (const sig of SIGNALS) process.off(sig, onSignal);
+  }
+  process.once('exit', run);
+  for (const sig of SIGNALS) process.on(sig, onSignal);
+  return off;
+}
 
 // Validate an Anthropic event sequence: indexes increase in start order, deltas only target an open block.
 export function assertValidAnthropicEvents(events) {

package/tests/shim.test.mjs

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

package/tests/teardown.test.mjs

@@ -0,0 +1,84 @@
+// The browser tests start a gateway, a stand-in interceptor and a Chromium, and the gateway can
+// start a real interceptor of its own, detached. Whatever ends the run, none of them and none of
+// their temp dirs may outlive it. Each case runs in a child process with a private TMPDIR, so
+// "nothing left" is a check on that one directory.
+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 { spawn } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { skipReason } from './cdp.mjs';
+import { pidsNaming } from './helpers.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const url = (f) => JSON.stringify(pathToFileURL(path.join(HERE, f)).href);
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+const skip = process.platform === 'win32' ? 'lists processes with ps' : skipReason();
+
+// Starts the fixture and a browser, then moves the interceptor to a new port so the gateway starts
+// a real one. `awaitStart` false: the script does not wait for the gateway to record it.
+const PRELUDE = (awaitStart) => `
+  import { startDashboardFixture } from ${url('dashboard-fixture.mjs')};
+  import { launchBrowser } from ${url('cdp.mjs')};
+  import { pidsNaming } from ${url('helpers.mjs')};
+  import net from 'node:net';
+  const free = () => new Promise(r => { const s = net.createServer().listen(0, '127.0.0.1', () => { const { port } = s.address(); s.close(() => r(port)); }); });
+  const fx = await startDashboardFixture();
+  const browser = await launchBrowser();
+  await browser.newPage();
+  const cfg = fx.config();
+  cfg.blindfold.port = await free();
+  fx.writeConfig(cfg);
+  const sync = fx.api('/api/blindfold/sync', {});
+  ${awaitStart ? `const r = await sync; if (r.status !== 200) throw new Error('no interceptor: ' + JSON.stringify(r.json));` : 'sync.catch(() => {});'}
+  for (let i = 0; i < 200 && !pidsNaming(fx.dir).length; i++) await new Promise(r => setTimeout(r, 25));
+  if (!pidsNaming(fx.dir).length) throw new Error('the gateway started no interceptor');
+`;
+
+async function inPrivateTmp(t, script, act) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-teardown-'));
+  t.after(() => {
+    // A red run must not leave what it found behind.
+    for (const pid of pidsNaming(tmp)) try { process.kill(pid, 'SIGKILL'); } catch { /* gone */ }
+    fs.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+  });
+  const child = spawn(process.execPath, ['--input-type=module', '-e', script], {
+    env: { ...process.env, TMPDIR: tmp, TMP: tmp, TEMP: tmp }, stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let out = '';
+  child.stdout.on('data', d => { out += d; });
+  child.stderr.on('data', d => { out += d; });
+  const exited = new Promise(r => child.once('exit', r));
+  await act(child, () => out);
+  await Promise.race([exited, sleep(30000)]);
+  // A detached process may take a moment to die after the signal.
+  let left = pidsNaming(tmp);
+  for (let i = 0; i < 50 && left.length; i++) { await sleep(100); left = pidsNaming(tmp); }
+  return { left, files: fs.readdirSync(tmp), out: () => out };
+}
+
+test('stop() and close() remove an interceptor the gateway had not recorded yet, and every temp dir', { skip, timeout: 90000 }, async (t) => {
+  const r = await inPrivateTmp(t, `${PRELUDE(false)}
+    await fx.stop();
+    await browser.close();
+    console.log('DONE');
+  `, async () => {});
+  assert.match(r.out(), /DONE/, r.out());
+  assert.deepEqual(r.left, [], 'no process names the temp dir');
+  assert.deepEqual(r.files, [], 'no temp dir is left');
+});
+
+test('a test process stopped by SIGTERM still stops its gateway, interceptor and browser', { skip, timeout: 90000 }, async (t) => {
+  const r = await inPrivateTmp(t, `${PRELUDE(true)}
+    console.log('READY');
+    setInterval(() => {}, 1000);
+  `, async (child, out) => {
+    for (let i = 0; i < 600 && !/READY/.test(out()) && child.exitCode === null; i++) await sleep(100);
+    assert.match(out(), /READY/, out());
+    child.kill('SIGTERM');
+  });
+  assert.deepEqual(r.left, [], 'no process names the temp dir');
+  assert.deepEqual(r.files, [], 'no temp dir is left');
+});

package/tests/version.test.mjs

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

package/tests/windows.test.mjs

@@ -6,7 +6,8 @@ import path from 'node:path';
 import http from 'node:http';
 import {
   parseModelWindows, parseModelList, fetchProfileWindows,
-  resolveProfileWindows, readWindowsCache, readLocalCodexWindows
+  resolveProfileWindows, readWindowsCache, readLocalCodexWindows,
+  windowsCacheKey, cachedProfileWindows
 } from '../windows.mjs';
 
 const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-windows-'));
@@ -20,11 +21,22 @@ test('a list entry gives the whole window and the window to compress at', () =>
   assert.deepEqual(parseModelWindows({ id: 'groq/q', context_window: 131072 }), { context: 131072, compact: 0 },
     'one window is the whole window, not a threshold');
   assert.deepEqual(parseModelWindows({ id: 'or/r', context_length: 262144, top_provider: { context_length: 262144, max_completion_tokens: 32768 } }),
-    { context: 262144, compact: 0 });
+    { context: 262144, compact: 0, output: 32768 });
   assert.deepEqual(parseModelWindows({ id: 'bare' }), null, 'a model with no limits says nothing');
   assert.deepEqual(parseModelWindows({ id: 'zero', context_length: 0, compact_window: 0 }), null);
 });
 
+// The output limit lets the gateway clamp a max_tokens the model would refuse.
+test('a list entry keeps the output limit it names, and leaves it out when it names none', () => {
+  assert.deepEqual(parseModelWindows({ id: 'i/m', context_length: 200000, max_output_tokens: 8192 }),
+    { context: 200000, compact: 0, output: 8192 });
+  assert.deepEqual(parseModelWindows({ id: 'only-out', max_output_tokens: 4096 }), { context: 0, compact: 0, output: 4096 },
+    'an output limit alone is still worth keeping');
+  assert.equal('output' in parseModelWindows({ id: 'g', context_length: 131072 }), false);
+  assert.deepEqual(parseModelList({ data: [{ id: 'i/m', context_length: 200000, max_output_tokens: 8192 }] }),
+    { 'i/m': { context: 200000, compact: 0, output: 8192 } });
+});
+
 test('parseModelList keys the windows by the id a profile maps, and drops the nameless', () => {
   const out = parseModelList({ data: [{ id: 'models/big', context_length: 1048576 }, { id: 'bare' }, 'plain'] });
   assert.deepEqual(Object.keys(out), ['big'], 'a bare string carries no window, and a models/ prefix is dropped');
@@ -90,6 +102,25 @@ test('windows are cached for an hour, and a failed refresh keeps the stale answe
   }
 });
 
+test('the cache persists the output limit, and an old cache file without it still reads', async () => {
+  const dir = tmpDir();
+  const sink = http.createServer((req, res) => {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ data: [{ id: 'm', context_length: 200000, max_output_tokens: 8192 }] }));
+  });
+  await new Promise(r => sink.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${sink.address().port}/v1`;
+  try {
+    await resolveProfileWindows(dir, 'p@' + base, base, 'k', { now: 1_000 });
+    assert.equal(readWindowsCache(dir)['p@' + base].models.m.output, 8192);
+    fs.writeFileSync(path.join(dir, 'model-windows.json'), JSON.stringify({ old: { at: 1_000, baseURL: base, models: { m: { context: 200000, compact: 0 } } } }));
+    assert.deepEqual(await resolveProfileWindows(dir, 'old', base, 'k', { now: 2_000 }), { m: { context: 200000, compact: 0 } });
+  } finally {
+    sink.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('an empty cache file reads as no windows instead of throwing', () => {
   const dir = tmpDir();
   try {
@@ -122,3 +153,64 @@ test('the Codex CLI own cache is a fallback, not a source of truth', () => {
     fs.rmSync(home, { recursive: true, force: true });
   }
 });
+
+// A profile whose baseURL is spelled with another case or a trailing slash is the same address.
+test('the cache key of a profile ignores the case of scheme and host and a trailing slash', () => {
+  assert.equal(windowsCacheKey('p', 'HTTP://Api.Example.COM:8080/v1/'), 'p@http://api.example.com:8080/v1');
+  assert.equal(windowsCacheKey('p', 'http://api.example.com:8080/v1'), 'p@http://api.example.com:8080/v1');
+  assert.equal(windowsCacheKey('p', 'https://api.example.com/V1//'), 'p@https://api.example.com/V1', 'the path keeps its case');
+  assert.equal(windowsCacheKey(null, 'https://h/v1'), 'profile@https://h/v1');
+});
+
+// The output clamp reads the cache without a refresh, so it trusts only what this profile read within the hour.
+test('cachedProfileWindows answers only for its own key and only while the entry is fresh', () => {
+  const dir = tmpDir();
+  try {
+    const models = { m: { context: 200000, compact: 0, output: 8192 } };
+    fs.writeFileSync(path.join(dir, 'model-windows.json'), JSON.stringify({ 'a@http://h/v1': { at: 1_000, baseURL: 'http://h/v1', models } }));
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 1_000 + 60_000 }), models);
+    assert.deepEqual(cachedProfileWindows(dir, 'b@http://h/v1', { now: 1_000 + 60_000 }), {}, 'another profile on the same baseURL');
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 1_000 + 3_600_000 }), {}, 'an entry an hour old');
+    assert.deepEqual(cachedProfileWindows(dir, 'a@http://h/v1', { now: 2_000, ttlMs: 500 }), {});
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// A list that names only an output limit must not erase the windows an earlier read found, and an
+// output limit lives only as long as the newest list still states it.
+test('a refresh merges each model into the cached windows, but never carries an output limit forward', async () => {
+  const dir = tmpDir();
+  const lists = [
+    [{ id: 'm', context_length: 200000, compact_window: 150000, max_output_tokens: 4096 }, { id: 'n', context_length: 100000, max_output_tokens: 2048 }],
+    [{ id: 'm', context_length: 300000 }, { id: 'o', context_length: 50000 }],
+    [{ id: 'm', max_output_tokens: 8192 }]
+  ];
+  let hits = 0;
+  const sink = http.createServer((req, res) => {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ data: lists[hits++] }));
+  });
+  await new Promise(r => sink.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${sink.address().port}/v1`;
+  try {
+    await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 });
+    const second = await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 + 3_600_000 });
+    const expected = {
+      m: { context: 300000, compact: 150000 },
+      n: { context: 100000, compact: 0 },
+      o: { context: 50000, compact: 0 }
+    };
+    assert.deepEqual(second, expected, 'a changed window replaces the cached one; no output limit the list did not state');
+    assert.deepEqual(readWindowsCache(dir).p.models, expected);
+    const fresh = cachedProfileWindows(dir, 'p', { now: 1_000 + 3_600_000 + 60_000 });
+    assert.equal(fresh.m.output, undefined);
+    assert.equal(fresh.m.context, 300000);
+    const third = await resolveProfileWindows(dir, 'p', base, 'k', { now: 1_000 + 7_200_000 });
+    assert.equal(hits, 3);
+    assert.deepEqual(third.m, { context: 300000, compact: 150000, output: 8192 }, 'an output-only list keeps the windows');
+  } finally {
+    sink.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/windows.mjs

@@ -21,7 +21,8 @@ const FETCH_TIMEOUT_MS = 15000;
 
 const n = v => (Number.isFinite(v) && v > 0 ? Math.round(v) : 0);
 
-// One entry of a provider's list -> the two windows, or null when it names none.
+// One entry of a provider's list -> the two windows, plus `output` (the most the model writes)
+// when the list names it; null when it names none.
 export function parseModelWindows(m) {
   if (!m || typeof m !== 'object') return null;
   const top = m.top_provider && typeof m.top_provider === 'object' ? m.top_provider : {};
@@ -30,8 +31,9 @@ export function parseModelWindows(m) {
   // smaller of the two windows it publishes.
   const compact = n(m.compact_window) || n(m.compaction_threshold)
     || (context && n(m.context_window) && n(m.context_window) < context ? n(m.context_window) : 0);
-  if (!context && !compact) return null;
-  return { context, compact };
+  const output = n(m.max_output_tokens) || n(top.max_completion_tokens);
+  if (!context && !compact && !output) return null;
+  return output ? { context, compact, output } : { context, compact };
 }
 
 // The list as it names the models, so a caller can look one up by the id a profile maps.
@@ -82,8 +84,20 @@ export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey,
   const entry = cache[cacheKey] || {};
   const fresh = entry.at && now - entry.at < ttlMs;
   if (fresh) return entry.models || {};
-  const models = await fetchProfileWindows(baseURL, apiKey);
-  if (Object.keys(models).length) {
+  const listed = await fetchProfileWindows(baseURL, apiKey);
+  if (Object.keys(listed).length) {
+    // Merged per model and per number: a list that names only an output limit keeps the cached windows.
+    // An output limit is never carried forward: the entry is stamped now, so it must be one this list states.
+    const models = {};
+    for (const [id, w] of Object.entries(entry.models || {})) {
+      const { output: _output, ...windows } = w && typeof w === 'object' ? w : {};
+      models[id] = windows;
+    }
+    for (const [id, w] of Object.entries(listed)) {
+      const merged = { ...(models[id] || {}) };
+      for (const [k, v] of Object.entries(w)) if (v > 0 || !(merged[k] > 0)) merged[k] = v;
+      models[id] = merged;
+    }
     cache[cacheKey] = { at: now, baseURL, models };
     writeWindowsCache(stateDir, cache);
     return models;
@@ -91,6 +105,21 @@ export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey,
   return entry.models || {};
 }
 
+// One address however it is spelled: scheme and host are case-blind, and a trailing slash adds nothing.
+export function normalizeBaseURL(baseURL) {
+  return String(baseURL || '').trim().replace(/\/+$/, '').replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, m => m.toLowerCase());
+}
+
+export function windowsCacheKey(profileKey, baseURL) {
+  return `${profileKey || 'profile'}@${normalizeBaseURL(baseURL)}`;
+}
+
+// The cached windows of one profile while they are fresh, without reading the list again.
+export function cachedProfileWindows(stateDir, cacheKey, { ttlMs = DEFAULT_TTL_MS, now = Date.now() } = {}) {
+  const entry = readWindowsCache(stateDir)[cacheKey];
+  return entry?.at && now - entry.at < ttlMs ? entry.models || {} : {};
+}
+
 export function windowsCachePath(stateDir) {
   return path.join(stateDir, 'model-windows.json');
 }