llm-switcher 1.3.8 → 1.4.0

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) {

package/windows.mjs

@@ -0,0 +1,141 @@
+// The real window of every model a profile serves.
+//
+// A coding tool sizes a session, and its auto-compact point, from the window its own catalog
+// gives it. So the gateway reports what the model really has instead of a number someone picked
+// in a checkbox. Two numbers come out of a provider's list:
+//
+//   context  the whole window the model accepts
+//   compact  the window to compress at, which a Codex model publishes as `context_window`
+//            next to `max_context_window` (272K against 872K)
+//
+// A model whose list gives only one window has no compact window, and a provider that lists no
+// limits at all leaves both unknown: the caller then falls back to its own template rather than
+// inventing a number.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const ONE_HOUR_MS = 60 * 60 * 1000;
+const DEFAULT_TTL_MS = ONE_HOUR_MS;
+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.
+export function parseModelWindows(m) {
+  if (!m || typeof m !== 'object') return null;
+  const top = m.top_provider && typeof m.top_provider === 'object' ? m.top_provider : {};
+  const context = n(m.max_context_window) || n(m.context_length) || n(top.context_length) || n(m.context_window);
+  // intact serves the threshold under its own name; a Codex-shaped list carries it as the
+  // 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 };
+}
+
+// The list as it names the models, so a caller can look one up by the id a profile maps.
+export function parseModelList(data) {
+  const entries = Array.isArray(data?.data) ? data.data
+    : Array.isArray(data) ? data
+    : Array.isArray(data?.models) ? data.models
+    : [];
+  const out = {};
+  for (const m of entries) {
+    const id = String(typeof m === 'string' ? m : (m?.id || m?.name || '')).replace(/^models\//, '');
+    if (!id) continue;
+    const w = parseModelWindows(m);
+    if (w) out[id] = w;
+  }
+  return out;
+}
+
+/**
+ * Reads a provider's model list for its windows. Returns {} on any failure: a profile whose
+ * upstream cannot be reached keeps the last answer, never a wrong window.
+ */
+export async function fetchProfileWindows(baseURL, apiKey, { timeoutMs = FETCH_TIMEOUT_MS } = {}) {
+  const base = String(baseURL || '').replace(/\/+$/, '');
+  if (!base) return {};
+  try {
+    const headers = { accept: 'application/json' };
+    if (apiKey) {
+      headers.authorization = `Bearer ${apiKey}`;
+      headers['x-api-key'] = apiKey;
+    }
+    const res = await fetch(`${base}/models`, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return {};
+    return parseModelList(await res.json());
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The windows of a profile's models, from the cache when it is fresh and from the profile's own
+ * list when it is not. A failed read keeps the stale answer, because an old window only sizes a
+ * session slightly wrong, while an empty one would hand the tool a template window it may not
+ * have. Never throws.
+ */
+export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey, { ttlMs = DEFAULT_TTL_MS, now = Date.now() } = {}) {
+  const cache = readWindowsCache(stateDir);
+  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) {
+    cache[cacheKey] = { at: now, baseURL, models };
+    writeWindowsCache(stateDir, cache);
+    return models;
+  }
+  return entry.models || {};
+}
+
+export function windowsCachePath(stateDir) {
+  return path.join(stateDir, 'model-windows.json');
+}
+
+export function readWindowsCache(stateDir) {
+  try {
+    const d = JSON.parse(fs.readFileSync(windowsCachePath(stateDir), 'utf8'));
+    return d && typeof d === 'object' && !Array.isArray(d) ? d : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeWindowsCache(stateDir, cache) {
+  const p = windowsCachePath(stateDir);
+  const tmp = `${p}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(cache), 'utf8');
+    fs.renameSync(tmp, p);
+    return true;
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+    return false;
+  }
+}
+
+/**
+ * The windows the Codex CLI itself cached for its signed-in account. It is the fallback for a
+ * profile that lists no limits: those numbers came from the provider the CLI uses, so they are
+ * better than the template and never a guess. Returns {} when the tool keeps no list.
+ */
+export function readLocalCodexWindows(sources = {}) {
+  const codexHome = sources.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(codexHome, 'models_cache.json'), 'utf8'));
+    const models = Array.isArray(d?.models) ? d.models : [];
+    const out = {};
+    for (const m of models) {
+      const id = m && typeof m.slug === 'string' ? m.slug : '';
+      const context = n(m?.max_context_window) || n(m?.context_window);
+      const compact = context && n(m.context_window) < context ? n(m.context_window) : 0;
+      if (id && context) out[id] = { context, compact };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}