llm-switcher 1.3.8 → 1.4.1

package/tests/windows.test.mjs

@@ -0,0 +1,124 @@
+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 {
+  parseModelWindows, parseModelList, fetchProfileWindows,
+  resolveProfileWindows, readWindowsCache, readLocalCodexWindows
+} from '../windows.mjs';
+
+const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-windows-'));
+
+// A Codex model publishes both windows; intact names the threshold itself. Neither is guessed.
+test('a list entry gives the whole window and the window to compress at', () => {
+  assert.deepEqual(parseModelWindows({ id: 'codex/gpt-6-astra', context_length: 872000, compact_window: 272000 }),
+    { context: 872000, compact: 272000 });
+  assert.deepEqual(parseModelWindows({ id: 'local/g', context_window: 272000, max_context_window: 872000 }),
+    { context: 872000, compact: 272000 }, 'the smaller of two Codex windows is the threshold');
+  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 });
+  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);
+});
+
+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');
+  assert.equal(out.big.context, 1048576);
+  assert.deepEqual(parseModelList({}), {});
+  assert.deepEqual(parseModelList({ models: [{ id: 'gemini', inputTokenLimit: 1000000 }] }), {});
+});
+
+test('a profile list is read over HTTP, and a failure gives no window rather than a wrong one', async () => {
+  const seen = [];
+  const sink = http.createServer((req, res) => {
+    seen.push(req.headers.authorization);
+    if (req.url === '/v1/models') {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      return res.end(JSON.stringify({ data: [{ id: 'm', context_length: 872000, compact_window: 272000 }] }));
+    }
+    res.writeHead(404); res.end();
+  });
+  await new Promise(r => sink.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${sink.address().port}/v1`;
+  try {
+    assert.deepEqual(await fetchProfileWindows(base, 'sk-x'), { m: { context: 872000, compact: 272000 } });
+    assert.ok(seen[0]?.startsWith('Bearer '), 'the profile key travels to the profile own list');
+    assert.deepEqual(await fetchProfileWindows(`${base}/gone`, 'sk-x'), {}, 'a 404 is not a window');
+    assert.deepEqual(await fetchProfileWindows('http://127.0.0.1:9/v1', 'sk-x'), {}, 'an unreachable host is not a window');
+    assert.deepEqual(await fetchProfileWindows('', 'sk-x'), {});
+  } finally {
+    sink.close();
+  }
+});
+
+// The cache exists so /v1/models costs nothing on the hot path, and so a profile whose list cannot
+// be read keeps the last windows it did see.
+test('windows are cached for an hour, and a failed refresh keeps the stale answer', async () => {
+  const dir = tmpDir();
+  let hits = 0;
+  const sink = http.createServer((req, res) => {
+    hits++;
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ data: [{ id: 'm', context_length: hits === 1 ? 872000 : 400000 }] }));
+  });
+  await new Promise(r => sink.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${sink.address().port}/v1`;
+  const key = 'p@' + base;
+  try {
+    const fresh = await resolveProfileWindows(dir, key, base, 'k', { now: 1_000 });
+    assert.equal(fresh.m.context, 872000);
+    assert.equal(hits, 1);
+    // Inside the hour: the cache answers and the list is not read again.
+    assert.equal((await resolveProfileWindows(dir, key, base, 'k', { now: 1_000 + 60_000 })).m.context, 872000);
+    assert.equal(hits, 1);
+    // Past the hour the list is read again, and the answer moves with it.
+    assert.equal((await resolveProfileWindows(dir, key, base, 'k', { now: 1_000 + 3_600_000 })).m.context, 400000);
+    assert.equal(hits, 2);
+    // A list that cannot be read keeps what the last good read found.
+    sink.closeAllConnections?.();
+    await new Promise(r => sink.close(r));
+    assert.equal((await resolveProfileWindows(dir, key, base, 'k', { now: 1_000 + 7_200_000 })).m.context, 400000);
+    assert.equal(readWindowsCache(dir)[key].models.m.context, 400000, 'and the cache still holds it');
+  } 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 {
+    assert.deepEqual(readWindowsCache(dir), {});
+    fs.writeFileSync(path.join(dir, 'model-windows.json'), 'not json');
+    assert.deepEqual(readWindowsCache(dir), {}, 'a broken cache is a cache miss, never a crash');
+    fs.writeFileSync(path.join(dir, 'model-windows.json'), '[1,2]');
+    assert.deepEqual(readWindowsCache(dir), {}, 'a shape that is not a map is a cache miss too');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// The Codex CLI keeps the numbers for its own account, so a profile that lists no limits at least
+// gets the provider's real windows instead of the template's.
+test('the Codex CLI own cache is a fallback, not a source of truth', () => {
+  const home = tmpDir();
+  try {
+    assert.deepEqual(readLocalCodexWindows({ codexHome: home }), {}, 'no cache file, no windows');
+    fs.writeFileSync(path.join(home, 'models_cache.json'), JSON.stringify({ models: [
+      { slug: 'gpt-6-astra', context_window: 272000, max_context_window: 872000 },
+      { slug: 'flat', context_window: 400000 },
+      { slug: 'bare' }
+    ] }));
+    assert.deepEqual(readLocalCodexWindows({ codexHome: home }), {
+      'gpt-6-astra': { context: 872000, compact: 272000 },
+      flat: { context: 400000, compact: 0 }
+    });
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});

package/toolvocab.mjs

@@ -0,0 +1,272 @@
+// Writing a tool call back in the vocabulary the client declared.
+//
+// A tool name is not an identifier an API checks. The client sends its tools, the model answers
+// with a name, and the client runs the call or refuses it ("No such tool available: read"). The
+// gateway converts protocols; it cannot convert the model's preference. What it can do is notice
+// that the model answered in a different vocabulary and write the call back in the client's.
+//
+// Two rules hold no matter what the name looks like:
+//
+//   1. Only a tool the client declared is a candidate. A client that never declared `Bash` cannot
+//      run a `shell` call, so rewriting it to some other name changes nothing and hides the error.
+//   2. Nothing is guessed while two declared tools are both plausible. Claude Code on macOS has no
+//      `Glob` and no `Grep`; a session with both `Bash` and `PowerShell` has two shell tools. When
+//      the choice is not clear the name stands, and the client reports the mismatch itself, which is
+//      the honest path: a wrong call runs, a refused one does not.
+//
+// The capability names below are the ones each coding tool documents, with their sources collected in
+// docs/tool-vocabulary.md. Capabilities that are not interchangeable stay apart: `apply_patch` speaks
+// a diff, Claude Code's `Edit` speaks old_string/new_string, so a patch is never rewritten into an
+// Edit. The same holds for `Monitor`, which watches a command rather than running one.
+//
+// Edit and patch are the one pair here that is a decision rather than an oversight, so it is recorded
+// in both places. Renaming `Edit` to `apply_patch` would translate a payload, not a name: a usable
+// `old_string` needs the file, and a gateway does not read one. The result would be a call that looks
+// right and fails, which is worse than a name the model got wrong. docs/tool-vocabulary.md has the
+// three ways to want this instead, and the first of them needs no translation at all: pass the
+// provider's own edit tool through — OpenAI's server-defined `apply_patch`, Anthropic's `text_editor`,
+// Gemini's `replace`.
+
+const CAP_SHELL = 'shell';
+const CAP_READ = 'read';
+const CAP_WRITE = 'write';
+const CAP_EDIT = 'edit';
+const CAP_PATCH = 'patch';
+const CAP_SEARCH = 'search';
+const CAP_GLOB = 'glob';
+const CAP_LIST = 'list';
+const CAP_PLAN = 'plan';
+const CAP_WEB = 'web';
+const CAP_WEBSEARCH = 'websearch';
+const CAP_MONITOR = 'monitor';
+const CAP_LSP = 'lsp';
+const CAP_SKILL = 'skill';
+const CAP_AGENT = 'agent';
+const CAP_ASK = 'ask';
+
+// The name each tool documents, as it stands. Case is irrelevant to a name a model reaches for, and
+// MCP servers are case-sensitive, so this is only ever read on the model's side of the boundary.
+const NAME_CAPABILITY = new Map([
+  // Claude Code — code.claude.com/docs/en/tools.md
+  ['bash', CAP_SHELL], ['powershell', CAP_SHELL], ['monitor', CAP_MONITOR],
+  ['read', CAP_READ], ['write', CAP_WRITE], ['edit', CAP_EDIT], ['multiedit', CAP_EDIT],
+  ['notebookedit', CAP_EDIT], ['notebookread', CAP_READ],
+  ['grep', CAP_SEARCH], ['glob', CAP_GLOB],
+  ['todowrite', CAP_PLAN], ['taskcreate', CAP_PLAN], ['taskget', CAP_PLAN], ['taskupdate', CAP_PLAN],
+  ['tasklist', CAP_LIST], ['taskstop', CAP_PLAN], ['taskoutput', CAP_READ],
+  ['webfetch', CAP_WEB], ['websearch', CAP_WEBSEARCH],
+  ['lsp', CAP_LSP], ['skill', CAP_SKILL], ['agent', CAP_AGENT], ['askuserquestion', CAP_ASK],
+  ['toolsearch', CAP_LIST], ['listmcpresourcestool', CAP_LIST], ['readmcpresourcetool', CAP_READ],
+
+  // Codex CLI — developers.openai.com codex prompting guide, openai/codex codex-rs
+  ['shell', CAP_SHELL], ['cmd', CAP_SHELL], ['run_terminal_cmd', CAP_SHELL], ['runterminalcmd', CAP_SHELL],
+  ['apply_patch', CAP_PATCH], ['update_plan', CAP_PLAN], ['todo_write', CAP_PLAN],
+  ['read_file', CAP_READ], ['list_dir', CAP_LIST], ['glob_file_search', CAP_GLOB], ['rg', CAP_SEARCH],
+
+  // OpenCode — opencode.ai/docs/tools/
+  ['edit', CAP_EDIT], ['write', CAP_WRITE], ['read', CAP_READ], ['grep', CAP_SEARCH],
+  ['glob', CAP_GLOB], ['todowrite', CAP_PLAN], ['webfetch', CAP_WEB], ['websearch', CAP_WEBSEARCH],
+  ['lsp', CAP_LSP], ['skill', CAP_SKILL], ['question', CAP_ASK],
+
+  // Other agents the gateway meets — bytedance/trae-agent, QwenLM/qwen-code
+  ['run_shell_command', CAP_SHELL], ['str_replace_editor', CAP_EDIT], ['str_replace_based_edit_tool', CAP_EDIT],
+  ['list_directory', CAP_LIST], ['read_file', CAP_READ], ['write_file', CAP_WRITE], ['file_search', CAP_GLOB],
+  ['web_fetch', CAP_WEB]
+].map(([name, cap]) => [name.toLowerCase(), cap]));
+
+// Tokens, for a name no tool documents. Only a token one vocabulary uses for one thing is here, so a
+// name built from these words reads as a single capability rather than as a guess. A name with no
+// capability token is not repaired at all.
+const TOKEN_CAPABILITY = new Map([
+  ['shell', CAP_SHELL], ['bash', CAP_SHELL], ['sh', CAP_SHELL], ['zsh', CAP_SHELL], ['cmd', CAP_SHELL],
+  ['command', CAP_SHELL], ['commands', CAP_SHELL], ['terminal', CAP_SHELL], ['console', CAP_SHELL],
+  ['exec', CAP_SHELL], ['execute', CAP_SHELL], ['run', CAP_SHELL], ['spawn', CAP_SHELL], ['process', CAP_SHELL],
+  ['monitor', CAP_MONITOR],
+  ['read', CAP_READ], ['cat', CAP_READ], ['view', CAP_READ], ['open', CAP_READ],
+  ['write', CAP_WRITE], ['create', CAP_WRITE], ['dump', CAP_WRITE], ['save', CAP_WRITE],
+  ['edit', CAP_EDIT], ['replace', CAP_EDIT], ['modify', CAP_EDIT], ['multiedit', CAP_EDIT],
+  ['strreplace', CAP_EDIT], ['streditor', CAP_EDIT], ['stredit', CAP_EDIT],
+  ['patch', CAP_PATCH], ['applypatch', CAP_PATCH],
+  ['grep', CAP_SEARCH], ['rg', CAP_SEARCH], ['ripgrep', CAP_SEARCH], ['ugrep', CAP_SEARCH],
+  ['grepcontent', CAP_SEARCH],
+  ['glob', CAP_GLOB], ['filesearch', CAP_GLOB], ['globfiles', CAP_GLOB],
+  ['list', CAP_LIST], ['ls', CAP_LIST], ['dir', CAP_LIST], ['directory', CAP_LIST],
+  ['plan', CAP_PLAN], ['todo', CAP_PLAN], ['todos', CAP_PLAN], ['todowrite', CAP_PLAN], ['updateplan', CAP_PLAN],
+  ['fetch', CAP_WEB], ['webfetch', CAP_WEB], ['url', CAP_WEB], ['http', CAP_WEB], ['download', CAP_WEB],
+  ['websearch', CAP_WEBSEARCH],
+  ['lsp', CAP_LSP], ['skill', CAP_SKILL],
+  ['agent', CAP_AGENT], ['subagent', CAP_AGENT],
+  ['question', CAP_ASK], ['ask', CAP_ASK]
+]);
+
+// `TodoWrite` is one word to the model that made it; `str_replace_editor` is three.
+export function tokenize(name) {
+  return String(name || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean);
+}
+
+// `mcp__github__create_issue` belongs to the github server. A namespace is kept as a whole and
+// joined by single underscores so a multi-word server name still compares.
+function namespaceOf(name) {
+  const m = /^([a-z0-9]+(?:__[a-z0-9]+)+)__([A-Za-z0-9_]+)$/.exec(String(name || ''));
+  return m ? m[1].split('__').join('_').toLowerCase() : null;
+}
+
+// What the name is for: the documented one when a tool documents this exact name, else the set of
+// capabilities its tokens carry. Empty means the name says nothing and nothing is rewritten.
+function capabilitiesOf(name) {
+  const exact = NAME_CAPABILITY.get(String(name || '').toLowerCase());
+  if (exact) return new Set([exact]);
+  const set = new Set();
+  for (const token of tokenize(name)) {
+    const cap = TOKEN_CAPABILITY.get(token.toLowerCase());
+    if (cap) set.add(cap);
+  }
+  return set;
+}
+
+// A key is the same key however it is spelled: file_path, filePath and file-path are one name.
+function normalizeKey(key) {
+  return String(key || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+function schemaKeysOf(tool) {
+  const props = tool?.parameters?.properties;
+  if (!props || typeof props !== 'object' || Array.isArray(props)) return [];
+  return Object.keys(props);
+}
+
+// Which schema key an incoming key is another way of writing. Two ways, strongest first:
+//
+//   1. the same letters: filePath, file-path and file_path are one key.
+//   2. one name inside the other: path and file_path, dir and dir_path. Only for a string value, so a
+//      number or a flag is never moved into a longer name it happens to sit inside.
+//
+// One candidate or nothing. Two schema keys that both fit is a guess, and a wrong key is an argument
+// the caller will refuse in a way that names the wrong thing.
+function schemaMatch(key, value, keys) {
+  const shape = normalizeKey(key);
+  if (!shape) return null;
+  const exact = keys.filter(k => normalizeKey(k) === shape);
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) return null;
+  if (typeof value !== 'string') return null;
+  const loose = keys.filter(k => {
+    const other = normalizeKey(k);
+    return other !== shape && (other.includes(shape) || shape.includes(other));
+  });
+  return loose.length === 1 ? loose[0] : null;
+}
+
+/**
+ * The arguments as the client's schema names them.
+ *
+ * A rename happens only when the schema names exactly one key this one is another way of writing, and
+ * that key is not already used. A key the schema does not name is left alone: the client may still
+ * read it, and a dropped key is a lost instruction. A falsy value is a value.
+ */
+function repairArgs(args, tool) {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) return args;
+  const keys = schemaKeysOf(tool);
+  if (!keys.length) return args;
+  const entries = Object.entries(args);
+  const renames = new Map();
+  for (const [key, value] of entries) {
+    if (keys.includes(key)) continue;                    // the schema already has this one
+    const target = schemaMatch(key, value, keys);
+    if (!target || Object.hasOwn(args, target)) continue; // no single fit, or the client has both
+    renames.set(key, target);
+  }
+  if (!renames.size) return args;
+  // Rebuilt in the original order, with each renamed key standing where the old one stood: an
+  // argument list is read by people in diffs, and a reordered one hides what changed.
+  const out = {};
+  for (const [key, value] of entries) {
+    const target = renames.get(key);
+    if (target) out[target] = value;
+    else out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * The vocabulary one request declared. `declared` is the client's own tool list, as `ir.tools` holds
+ * it: `{ name, parameters }`, the same names and schemas the client will check the call against.
+ *
+ * A list with no tools, or one where nothing can be confused, leaves every call untouched.
+ */
+export function createToolVocab(declared) {
+  // Only a tool the caller executes can be a rename target. A tool the provider runs answers in
+  // band and its result reaches the caller without the caller executing anything; handing such a
+  // call back as a client tool moves the work, silently, to the machine the user is sitting at.
+  const tools = (Array.isArray(declared) ? declared : [])
+    .filter(t => t && typeof t.name === 'string' && t.name && t.side !== 'provider');
+  const byName = new Map();
+  const candidates = [];
+  for (const t of tools) {
+    const caps = capabilitiesOf(t.name);
+    const entry = { tool: t, name: t.name, namespace: namespaceOf(t.name), caps };
+    // Keyed by the exact spelling: a client checks tool names exactly, so `read` is not the same
+    // tool as `Read` to it, and that difference is the whole reason this layer exists.
+    byName.set(t.name, entry);
+    candidates.push(entry);
+  }
+  // Nothing is gained when the client declared one tool and the model answered with another name:
+  // there is no second answer to pick between, so the call stands and the client reports it.
+  const useful = candidates.length >= 2 && candidates.some(c => c.caps.size > 0);
+
+  function name(upstream) {
+    if (!useful) return upstream;
+    const raw = String(upstream || '');
+    if (!raw || raw === 'tool') return upstream;
+    if (byName.has(raw)) return upstream;                 // already the client's own name
+    const ns = namespaceOf(raw);
+    if (ns) return upstream;                              // a server's tool never becomes a local one
+    const want = capabilitiesOf(raw);
+    if (!want.size) return upstream;
+    let winner = null;
+    let ties = 0;
+    for (const c of candidates) {
+      if (c.namespace) continue;                          // and the other way round
+      let covers = true;
+      for (const cap of want) {
+        if (!c.caps.has(cap)) { covers = false; break; }
+      }
+      if (!covers) continue;
+      ties++;
+      winner = c;
+    }
+    // One tool covers everything the name asks for, and only one does.
+    return ties === 1 ? winner.name : upstream;
+  }
+
+  function args(upstream, argsJson) {
+    if (!useful) return argsJson;
+    const target = byName.get(name(upstream));
+    if (!target) return argsJson;
+    let parsed;
+    try {
+      parsed = JSON.parse(argsJson || '{}');
+    } catch {
+      return argsJson;   // a truncated payload is passed through: changing bytes helps nobody
+    }
+    const repaired = repairArgs(parsed, target.tool);
+    if (repaired === parsed) return argsJson;
+    return JSON.stringify(repaired);
+  }
+
+  return {
+    name,
+    args,
+    /** Both halves at once, for a call that is already whole. */
+    repair(upstream, argsJson) {
+      const fixedName = name(upstream);
+      return { name: fixedName, args: args(fixedName, argsJson), renamed: fixedName !== upstream };
+    }
+  };
+}
+
+/** A vocabulary that never rewrites anything, for a request that declared no tools. */
+export const NULL_TOOL_VOCAB = Object.freeze({ name: n => n, args: (n, a) => a, repair: (n, a) => ({ name: n, args: a, renamed: false }) });

package/ui.html

@@ -432,7 +432,6 @@
     }
     .chip .lbl { grid-column: 1 / -1; font-size: 0.7rem; overflow-wrap: anywhere; }
     .chip .val { font-family: var(--font-mono); overflow-wrap: anywhere; }
-    .chip .b1m { font-weight: 600; font-size: 0.7rem; }
 
     .copyline {
       display: flex;
@@ -552,11 +551,8 @@
 
     /* Model slot combobox: one listbox per slot, provider prefix dimmed, match in the accent. */
     .combo { position: relative; }
-    .slot-1m-note { font-size: 0.72rem; color: var(--faint); }
-    /* Kept in the page when empty: a live region added later is often not read. */
-    .slot-1m-note:empty { margin-top: -0.25rem; }
-    .slot-1m-note.warn { color: var(--warn); }
-    .slot-1m-note.err { color: var(--err); }
+    .slot-note { font-size: 0.72rem; color: var(--faint); }    /* Kept in the page when empty: a live region added later is often not read. */
+    .slot-note:empty { margin-top: -0.25rem; }
     .combo > input { padding-right: 2.25rem; font-family: var(--font-mono); font-size: 0.8rem; }
     .combo-toggle {
       position: absolute; right: 4px; top: 4px; width: 28px; height: 28px;
@@ -1212,12 +1208,8 @@
             </div>
           </div>
 
-          <!-- TAB 3: Models & 1M -->
+          <!-- TAB 3: Models -->
           <div id="tab-models" class="tab-content" style="display:none; gap:0.9rem; flex-direction:column;">
-            <div class="badge warn" id="warn-1m-callout" style="display:none; padding:0.5rem 0.75rem; border-radius:8px;">
-              <span id="warn-1m-icon">⚠️</span> <span id="warn-1m-text">1M context flag is enabled</span>
-            </div>
-
             <div style="display:flex; justify-content:space-between; align-items:center; gap:0.75rem;">
               <h3 id="model-slot-heading" style="font-size:0.92rem; font-weight:600;">Model Slots Mapping</h3>
               <div id="models-status" class="models-status" aria-live="polite"></div>
@@ -1280,7 +1272,7 @@
     let formLoadedKey = null;
     let formDirty = false;
     let loadedModels = [];
-    let loadedLimits = {};   // model id -> { context, input, output }, as the gateway lists them
+    let loadedLimits = {};   // model id -> { context, compact, input, output }, as the gateway lists them
     let currentProfileBuffer = null;
     let renderedSlotFormat = 'auto';
     let logRefreshTimer = null;
@@ -1613,7 +1605,6 @@
       agy: {
         title: 'Antigravity CLI Agent Model (Code Assist)',
         // agy sizes its own window; * stands for the model agy picked (antigravity/* keeps it on intact).
-        no1m: true,
         slots: [
           { id: 'main', name: 'Agent Model (* = the model agy picked)', placeholder: 'antigravity/* or claude/claude-opus-5' }
         ]
@@ -1632,11 +1623,6 @@
       return defaultModels[slotId] || '';
     }
 
-    function flagForSlot(model1M, slotId) {
-      if (!model1M) return false;
-      return Boolean(model1M[slotId]);
-    }
-
     function renderModelSlots(slotFmt, p) {
       const container = document.getElementById('slot-fields');
       const heading = document.getElementById('model-slot-heading');
@@ -1649,31 +1635,24 @@
 
       for (const s of cfg.slots) {
         const val = currentProfileBuffer ? valueForSlot(currentProfileBuffer.defaultModels, s.id) : valueForSlot(p?.defaultModels, s.id);
-        const checked = currentProfileBuffer ? flagForSlot(currentProfileBuffer.model1M, s.id) : flagForSlot(p?.model1M, s.id);
 
         const slotRow = document.createElement('div');
         slotRow.style.cssText = 'display:flex; flex-direction:column; gap:0.25rem;';
         slotRow.innerHTML = `
-          <div style="display:flex; justify-content:space-between; align-items:center;">
-            <label for="p-${s.id}" style="font-size:0.82rem; font-weight:500;">${escapeHtml(s.name)}</label>
-            ${cfg.no1m ? '' : `<label style="display:flex; align-items:center; gap:0.35rem; font-size:0.75rem; color:var(--accent); cursor:pointer;">
-              <input type="checkbox" id="p-${s.id}-1m" aria-label="1M context for ${escapeHtml(s.name)}" aria-describedby="p-${s.id}-1m-note" style="width:13px; height:13px; min-height:0;" onchange="update1mWarnings()" ${checked ? 'checked' : ''}>
-              1M context
-            </label>`}
-          </div>
+          <label for="p-${s.id}" style="font-size:0.82rem; font-weight:500;">${escapeHtml(s.name)}</label>
           <div class="combo">
-            <input type="text" id="p-${s.id}" oninput="update1mWarnings()" role="combobox" aria-autocomplete="list" aria-expanded="false" aria-controls="p-${s.id}-list" autocomplete="off" spellcheck="false" placeholder="${escapeHtml(s.placeholder)}" value="${escapeHtml(val)}">
+            <input type="text" id="p-${s.id}" oninput="updateWindowNotes()" role="combobox" aria-autocomplete="list" aria-expanded="false" aria-controls="p-${s.id}-list" autocomplete="off" spellcheck="false" placeholder="${escapeHtml(s.placeholder)}" value="${escapeHtml(val)}">
             <button type="button" class="combo-toggle" tabindex="-1" aria-label="Show models for ${escapeHtml(s.name)}">
               <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 6l4 4 4-4"/></svg>
             </button>
             <ul class="combo-list" id="p-${s.id}-list" role="listbox" aria-label="${escapeHtml(s.name)} models" hidden></ul>
           </div>
-          <div class="slot-1m-note" id="p-${s.id}-1m-note" role="status" aria-live="polite"></div>
+          <div class="slot-note" id="p-${s.id}-note" role="status" aria-live="polite"></div>
         `;
         container.appendChild(slotRow);
         wireCombo(slotRow.querySelector('.combo'));
       }
-      update1mWarnings();
+      updateWindowNotes();
     }
 
     function onToolChange() {
@@ -1685,31 +1664,20 @@
       const cfg = getActiveSlotConfig(renderedSlotFormat);
       if (!currentProfileBuffer) currentProfileBuffer = {};
       const defaultModels = { ...(currentProfileBuffer.defaultModels || {}) };
-      const model1M = { ...(currentProfileBuffer.model1M || {}) };
       for (const s of cfg.slots) {
         const inp = document.getElementById('p-' + s.id);
-        const chk = document.getElementById('p-' + s.id + '-1m');
         if (inp) {
           const val = inp.value.trim();
           if (val) defaultModels[s.id] = val;
           else delete defaultModels[s.id];
         }
-        if (chk) {
-          if (chk.checked) model1M[s.id] = true;
-          else delete model1M[s.id];
-        }
       }
       currentProfileBuffer.defaultModels = defaultModels;
-      currentProfileBuffer.model1M = model1M;
-      return { defaultModels, model1M };
-    }
+      // An old config can still carry the retired 1M flags. They are dropped on the next save
+      // instead of being written back: the window is the model's own now.
+      delete currentProfileBuffer.model1M;
+      return { defaultModels };
 
-    // A window known to be under 1M locks the box; an unknown one only warns, since many
-    // gateways list no limits at all.
-    function contextVerdict(l) {
-      const window = (l && (l.context || l.input)) || 0;
-      if (!window) return { kind: 'unknown', window: 0 };
-      return { kind: window >= 1000000 ? 'ok' : 'small', window };
     }
 
     // 128000 reads as 128K and 262144 as 256K: a round decimal count keeps base 1000.
@@ -1718,32 +1686,24 @@
       return n >= b * b ? +(n / b / b).toFixed(1) + 'M' : n >= b ? Math.round(n / b) + 'K' : String(n);
     }
 
-    function update1mWarnings() {
-      const cfg = getActiveSlotConfig(renderedSlotFormat);
-      let any1m = false;
-      for (const s of cfg.slots) {
-        const chk = document.getElementById('p-' + s.id + '-1m');
-        const note = document.getElementById('p-' + s.id + '-1m-note');
+    // The window each listed model has, as the gateway reports it: the whole one and the smaller
+    // one to compress at. Shown, never a setting: the tool sizes the session from it.
+    function windowLine(model) {
+      const l = loadedLimits[model];
+      if (!l || !(l.context || l.compact)) return '';
+      const parts = [];
+      if (l.context) parts.push(fmtTokens(l.context) + ' context');
+      if (l.compact && l.compact < (l.context || 0)) parts.push('compacts at ' + fmtTokens(l.compact));
+      return parts.join(', ');
+    }
+
+    function updateWindowNotes() {
+      for (const s of getActiveSlotConfig(renderedSlotFormat).slots) {
+        const note = document.getElementById('p-' + s.id + '-note');
+        if (!note) continue;
         const model = document.getElementById('p-' + s.id)?.value.trim() || '';
-        if (!chk) continue;
-        const v = contextVerdict(model ? loadedLimits[model] : null);
-        const locked = v.kind === 'small';
-        if (locked) chk.checked = false;
-        chk.disabled = locked;
-        chk.closest('label').style.opacity = locked ? '0.5' : '';
-        chk.closest('label').style.cursor = locked ? 'not-allowed' : 'pointer';
-        if (note) {
-          let text = '', cls = '';
-          if (locked) { text = `Context ${fmtTokens(v.window)} is under 1M, so 1M context is off for this model.`; cls = 'err'; }
-          else if (v.kind === 'ok') text = `Context ${fmtTokens(v.window)}.`;
-          else if (chk.checked && model) { text = 'The gateway does not list this model\'s context. Make sure it takes 1M tokens.'; cls = 'warn'; }
-          note.textContent = text;
-          note.className = 'slot-1m-note' + (cls ? ' ' + cls : '');
-        }
-        if (chk.checked) any1m = true;
+        note.textContent = model ? windowLine(model) : '';
       }
-      const warnCallout = document.getElementById('warn-1m-callout');
-      if (warnCallout) warnCallout.style.display = any1m ? 'inline-flex' : 'none';
     }
 
     // Prefetch Counts for Nav Badges
@@ -1888,8 +1848,7 @@
         const modelChips = pCfg.slots.map(s => {
           const val = valueForSlot(p.defaultModels, s.id);
           if (!val) return '';
-          const has1m = flagForSlot(p.model1M, s.id);
-          return '<div class="chip"><span class="faint lbl">' + escapeHtml(s.name) + '</span><span class="val">' + escapeHtml(val) + '</span>' + (has1m ? '<b class="b1m">1M</b>' : '') + '</div>';
+          return '<div class="chip"><span class="faint lbl">' + escapeHtml(s.name) + '</span><span class="val">' + escapeHtml(val) + '</span></div>';
         }).filter(Boolean).join('');
 
         card.innerHTML = `
@@ -2018,8 +1977,7 @@
         outFormat: 'openai-chat',
         mode: 'convert',
         thinkingMode: 'auto',
-        defaultModels: {},
-        model1M: {}
+        defaultModels: {}
       };
 
       document.getElementById('form-title').textContent = 'Add New Provider Profile';
@@ -2163,8 +2121,6 @@
       };
       // A save with no edit must leave the profile as it was: write a default only where the profile
       // already had the key.
-      const model1M = { ...(currentProfileBuffer?.model1M || {}) };
-      if (Object.keys(model1M).length || existing.model1M) profilePayload.model1M = model1M;
       const thinkingMode = document.getElementById('p-thinking-mode').value;
       if (thinkingMode !== 'auto' || existing.thinkingMode) profilePayload.thinkingMode = thinkingMode;
 
@@ -2369,7 +2325,7 @@
         setModelsStatus('error', 'Models not loaded: ' + err.message, 'Retry');
       }
       document.querySelectorAll('.combo[data-open]').forEach(renderComboOptions);
-      update1mWarnings();
+      updateWindowNotes();
     }
 
     // Slot combobox (ARIA combobox with a listbox). Typing filters; the arrow opens the full list.
@@ -2487,7 +2443,7 @@
       combo.querySelector('input').value = model;
       formDirty = true;
       closeCombo(combo);
-      update1mWarnings();
+      updateWindowNotes();
     }
 
     function onComboKeydown(e) {