llm-switcher 1.3.8 → 1.4.0

package/proxy.mjs

@@ -23,9 +23,11 @@ import {
   isProfileActive, profileAcceptsTarget, applyLaunchState, readLaunchFlags, redactConfig, MASKED_KEY,
   modelForSlot, primaryModel, codexPublicModel, isSafeModelName, parsePort, CODEX_MODEL_SLOTS,
   ensureAdminToken, ensureGatewaySecret, relayProof, identityProof, reconcileBlindfold, checkBlindfoldTarget,
-  codexModelEntry, smallestWindows, publicModelWindows, model1MForSlot,
+  codexModelEntry,
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
+import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows } from './windows.mjs';
+import { createToolVocab } from './toolvocab.mjs';
 import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
 import { checkForUpdate } from './version.mjs';
 import { applyUpdate } from './update.mjs';
@@ -487,12 +489,26 @@ function parsePayloadLine(line) {
   try { return JSON.parse(s); } catch { return null; }
 }
 
+// The tool vocabulary the caller declared, so a model that answers with a name from its own
+// training is written back in the caller's words instead of ending the turn with "No such tool
+// available". Built once per request from the tools the caller actually sent, so a request that
+// declared none pays nothing and a turn where the model agreed with the list changes nothing.
+let toolVocabCache = null;
+let toolVocabForIr = null;
+function toolVocabFor(ir) {
+  if (toolVocabForIr !== ir) {
+    toolVocabForIr = ir;
+    toolVocabCache = createToolVocab(ir?.tools);
+  }
+  return toolVocabCache;
+}
+
 function clientRenderer(clientFormat, res, model, opts = {}) {
-  if (clientFormat === 'anthropic') return createAnthropicStream((e, d) => sendSSE(res, e, d), model);
+  if (clientFormat === 'anthropic') return createAnthropicStream((e, d) => sendSSE(res, e, d), model, opts);
   if (clientFormat === 'responses') return createResponsesStream((e, d) => sendSSE(res, e, d), model, opts);
   if (clientFormat === 'vertex') return createVertexStream((e, d) => sendSSE(res, null, d), model);
   if (clientFormat === 'codeassist') return createCodeAssistStream((e, d) => sendSSE(res, null, d), model);
-  return createChatStream((e, d) => sendSSE(res, null, d), model);
+  return createChatStream((e, d) => sendSSE(res, null, d), model, opts);
 }
 
 function clientMessage(clientFormat, args) {
@@ -942,7 +958,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       const out = clientMessage(clientFormat, {
         model: requestedModel || mappedModel, think, text: [split.text], tools, toolMeta: ir.toolMeta,
         finish: col.finish, prompt: col.prompt, completion, cached: col.cached,
-        reasoning: col.reasoning, sig: col.sig
+        reasoning: col.reasoning, sig: col.sig, vocab: toolVocabFor(ir)
       });
       sendJson(res, 200, out);
       answered = true;
@@ -959,7 +975,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
       'Connection': 'keep-alive',
       'X-Accel-Buffering': 'no'
     });
-    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta });
+    const renderer = clientRenderer(clientFormat, res, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir) });
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));
     const streamError = await pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal: ac.signal, sink: res, tag: profileKey });
@@ -1227,15 +1243,18 @@ async function fetchModels(body, cfg) {
 }
 
 // A listed model's token limits, as intact and OpenRouter write them. Null when the list gives none.
+// The two windows come from windows.mjs, so /api/fetch-models and /v1/models cannot read a model
+// differently.
 function modelLimits(m) {
   if (!m || typeof m !== 'object') return null;
+  const w = parseModelWindows(m);
   const n = v => (Number.isFinite(v) && v > 0 ? v : 0);
   const top = m.top_provider && typeof m.top_provider === 'object' ? m.top_provider : {};
   const out = {};
-  const context = n(m.context_length) || n(top.context_length) || n(m.context_window);
   const input = n(m.max_input_tokens);
   const output = n(m.max_output_tokens) || n(top.max_completion_tokens);
-  if (context) out.context = context;
+  if (w?.context) out.context = w.context;
+  if (w?.compact) out.compact = w.compact;
   if (input) out.input = input;
   if (output) out.output = output;
   return Object.keys(out).length ? out : null;
@@ -1339,12 +1358,12 @@ async function route(req, res) {
   // Without publicModels, fall back to the deduplicated mapped upstream IDs.
   if (method === 'GET' && (pathname === '/v1/models' || pathname === '/models')) {
     checkVersionAndRefresh(req.headers['anthropic-version'] ? 'claude' : 'codex', req.headers, STATE_DIR);
-    const { ids, windows } = servedModels(req);
+    const { ids, windows } = await servedModels(req);
     const created = Math.floor(Date.now() / 1000);
     return sendJson(res, 200, {
       object: 'list',
       data: ids.map(id => ({ id, object: 'model', created, owned_by: 'system' })),
-      models: ids.map(id => ({ ...codexModelEntry(id, windows.get(id)), id, object: 'model', created, owned_by: 'system' }))
+      models: ids.map(id => ({ ...codexModelEntry(id, windows[id]), id, object: 'model', created, owned_by: 'system' }))
     });
   }
 
@@ -1352,8 +1371,8 @@ async function route(req, res) {
   if (method === 'GET' && (pathname.startsWith('/v1/models/') || pathname.startsWith('/models/'))) {
     const modelId = decodeURIComponent(pathname.replace(/^\/(v1\/)?models\//, ''));
     if (modelId) {
-      const { windows } = servedModels(req);
-      return sendJson(res, 200, { ...codexModelEntry(modelId, windows.get(modelId)), id: modelId, object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'system' });
+      const { windows } = await servedModels(req);
+      return sendJson(res, 200, { ...codexModelEntry(modelId, windows[modelId]), id: modelId, object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'system' });
     }
   }
 
@@ -1501,15 +1520,28 @@ function passthroughCodeAssist(req, res, body) {
   else req.pipe(up);
 }
 
-// The names /v1/models serves, and the window of each. Official names when the profile publishes
-// them, otherwise the mapped upstream IDs; each window follows model1M of its slot.
-function servedModels(req) {
-  const { profile } = getFirstActiveProfile(['responses', 'anthropic'], req);
+// The names /v1/models serves, and the real window of each. Official names when the profile
+// publishes them, otherwise the mapped upstream IDs.
+//
+// The window is what the model really has, so the tool sizes its own session: the profile's list
+// first (intact serves context_length and compact_window), then the list the Codex CLI cached for
+// its account, and the template only when neither names a window.
+async function servedModels(req) {
+  const { profileKey, profile } = getFirstActiveProfile(['responses', 'anthropic'], req);
+  const windows = await modelWindowsFor(profileKey, profile);
   if (Array.isArray(profile?.publicModels) && profile.publicModels.length) {
-    return { ids: [...new Set(profile.publicModels.filter(Boolean))], windows: publicModelWindows(profile) };
+    return { ids: [...new Set(profile.publicModels.filter(Boolean))], windows };
   }
-  const windows = smallestWindows(Object.entries(profile?.defaultModels || {}).map(([slot, id]) => [id, model1MForSlot(profile, slot)]));
-  return { ids: [...windows.keys()], windows };
+  return { ids: [...new Set(Object.values(profile?.defaultModels || {}).filter(Boolean))], windows };
+}
+
+// The windows of every model the profile serves. A profile that names no model in its own list
+// still gets the cached numbers, because an entry with the template window is better than none.
+async function modelWindowsFor(profileKey, profile) {
+  if (!profile?.baseURL) return {};
+  const listed = await resolveProfileWindows(STATE_DIR, `${profileKey || 'profile'}@${profile.baseURL}`, profile.baseURL, profile.apiKey);
+  if (Object.keys(listed).length) return listed;
+  return readLocalCodexWindows();
 }
 
 async function routeApi(req, res, method, pathname) {
@@ -1687,6 +1719,10 @@ async function routeConfigApi(res, method, pathname, body) {
     for (const k of ['outFormat', 'optimizerURL', 'thinkingMode']) {
       if (Object.hasOwn(profile, k) && !profile[k]) delete merged[k];
     }
+    // The merge above keeps a key the payload does not mention, so a retired one has to be dropped
+    // here: the window comes from the model's own list now, and a flag left in config.json would
+    // be read by nothing while still telling the next reader that the window is a choice.
+    delete merged.model1M;
     cfg.profiles[key] = merged;
 
     // A target assigned to this profile whose new inFormat no longer supports it -> unassign that target.
@@ -2031,7 +2067,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
       if (socket.writable) {
         socket.write(encodeWsFrame(JSON.stringify(d)));
       }
-    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta });
+    }, requestedModel || mappedModel, { toolMeta: ir.toolMeta, vocab: toolVocabFor(ir) });
 
     renderer.start();
     const splitter = createThinkTagSplitter(t => renderer.think(t), t => renderer.text(t));

package/skills/llm-switcher/SKILL.md

@@ -1,93 +1,93 @@
----
-name: llm-switcher
-description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
----
-
-# LLM Switcher Edge Gateway Skill
-
-This skill governs how AI coding agents (Claude Code, Codex, the Antigravity CLI `agy`, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
-
-## 1. The Core Directive
-
-> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
-> 
-> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
->
-> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
-
-```
-[Client CLI / Agent]
-         │
-         ▼
-[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
-         │
-         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
-[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
-         │
-         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
-[Internet / intact (Recommended) / 9Router / Upstream LLM]
-```
-
-## 2. Why This is Mandatory
-
-Direct outbound calls from token compressors will break the developer environment for several reasons:
-
-1. **Schema Breakage & The Healer Engine:**
-   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
-   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
-   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
-2. **Thinking / Reasoning Protection:**
-   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
-   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
-3. **Official Context Windows & Dynamic Model Discovery:**
-   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
-4. **Server Gateway Synergy (intact / 9Router):**
-   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
-
-## 3. Configuring Token Compression Tools
-
-When setting up or assisting the user with token compression tools, apply these exact configurations:
-
-### A. Headroom (Prompt Compression Proxy)
-When configuring Headroom's upstream endpoint:
-- In Headroom config (`headroom.yaml` or environment variables):
-  ```bash
-  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
-  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
-  ```
-- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
-
-### B. RTK (Rust Token Killer / Repomix)
-- In RTK configuration or execution flags:
-  ```bash
-  # Ensure RTK's target upstream proxy is LLM Switcher
-  export UPSTREAM_URL="http://127.0.0.1:3456"
-  ```
-
-### C. Ponytail / Custom Proxies
-- Always set the proxy's upstream host to:
-  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
-
-### D. Sub-Agents & Spawned Terminal Commands
-When an agent spawns sub-processes that call LLM CLIs:
-- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
-  more, so sourcing one changes nothing — and a stale variable an older version once wrote
-  would still point the tool at a port where nothing listens.
-- Run `switch claude <profile>`, `switch codex <profile>` or `switch agy <profile>` instead. The
-  shims in `~/.llm-switcher/bin` inject the gateway variables into the tool process itself and
-  clear anything stale first. For `agy` the variable is `CLOUD_CODE_URL`, not a proxy.
-- `claude`, `codex` and `agy` on `PATH` already are those shims: invoke them normally, and never
-  wrap them in another script.
-
-## 4. Operational Rules for AI Agents
-
-1. **NEVER edit `~/.claude/settings.json` directly.**
-   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
-2. **Check Gateway Health Before Complex Operations:**
-   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
-   - LLM Switcher is active on port `3456`.
-   - The active profile matches the intended CLI target (Claude Code, Codex, or the Antigravity CLI).
-3. **Verify Routing When Errors Occur:**
-   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
-   - Run `switch doctor` to audit port collisions and environment variables.
-   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.
+---
+name: llm-switcher
+description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
+---
+
+# LLM Switcher Edge Gateway Skill
+
+This skill governs how AI coding agents (Claude Code, Codex, the Antigravity CLI `agy`, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
+
+## 1. The Core Directive
+
+> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
+> 
+> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
+>
+> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
+
+```
+[Client CLI / Agent]
+         │
+         ▼
+[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
+         │
+         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
+[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
+         │
+         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
+[Internet / intact (Recommended) / 9Router / Upstream LLM]
+```
+
+## 2. Why This is Mandatory
+
+Direct outbound calls from token compressors will break the developer environment for several reasons:
+
+1. **Schema Breakage & The Healer Engine:**
+   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
+   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
+   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
+2. **Thinking / Reasoning Protection:**
+   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
+   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
+3. **Official Context Windows & Dynamic Model Discovery:**
+   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
+4. **Server Gateway Synergy (intact / 9Router):**
+   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
+
+## 3. Configuring Token Compression Tools
+
+When setting up or assisting the user with token compression tools, apply these exact configurations:
+
+### A. Headroom (Prompt Compression Proxy)
+When configuring Headroom's upstream endpoint:
+- In Headroom config (`headroom.yaml` or environment variables):
+  ```bash
+  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
+  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
+  ```
+- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
+
+### B. RTK (Rust Token Killer / Repomix)
+- In RTK configuration or execution flags:
+  ```bash
+  # Ensure RTK's target upstream proxy is LLM Switcher
+  export UPSTREAM_URL="http://127.0.0.1:3456"
+  ```
+
+### C. Ponytail / Custom Proxies
+- Always set the proxy's upstream host to:
+  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
+
+### D. Sub-Agents & Spawned Terminal Commands
+When an agent spawns sub-processes that call LLM CLIs:
+- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
+  more, so sourcing one changes nothing — and a stale variable an older version once wrote
+  would still point the tool at a port where nothing listens.
+- Run `switch claude <profile>`, `switch codex <profile>` or `switch agy <profile>` instead. The
+  shims in `~/.llm-switcher/bin` inject the gateway variables into the tool process itself and
+  clear anything stale first. For `agy` the variable is `CLOUD_CODE_URL`, not a proxy.
+- `claude`, `codex` and `agy` on `PATH` already are those shims: invoke them normally, and never
+  wrap them in another script.
+
+## 4. Operational Rules for AI Agents
+
+1. **NEVER edit `~/.claude/settings.json` directly.**
+   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
+2. **Check Gateway Health Before Complex Operations:**
+   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
+   - LLM Switcher is active on port `3456`.
+   - The active profile matches the intended CLI target (Claude Code, Codex, or the Antigravity CLI).
+3. **Verify Routing When Errors Occur:**
+   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
+   - Run `switch doctor` to audit port collisions and environment variables.
+   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.

package/state.mjs

@@ -371,14 +371,6 @@ function getClaudeSlots(p) {
   return slots;
 }
 
-function getClaude1M(p) {
-  const flags = {};
-  for (const s of CLAUDE_MODEL_SLOTS) {
-    if (p.model1M && Object.hasOwn(p.model1M, s)) flags[s] = p.model1M[s];
-  }
-  return flags;
-}
-
 function getCodexSlots(p) {
   const slots = {};
   for (const s of CODEX_MODEL_SLOTS) {
@@ -387,17 +379,11 @@ function getCodexSlots(p) {
   return slots;
 }
 
-function getCodex1M(p) {
-  const flags = {};
-  for (const s of CODEX_MODEL_SLOTS) {
-    if (p.model1M && Object.hasOwn(p.model1M, s)) flags[s] = p.model1M[s];
-  }
-  return flags;
-}
-
 function createClaudeHalf(p) {
   const half = {};
   for (const [k, v] of Object.entries(p)) {
+    // model1M is dropped as well: the window is the model's own now, so a flag left in an old
+    // config is read by nothing and would only mislead whoever opens the dashboard.
     if (['inFormat', 'blindfold', 'blindfoldPort', 'blindfoldHost', 'blindfoldPrefix', 'defaultModels', 'model1M', 'publicModels', 'codexRoles'].includes(k)) {
       continue;
     }
@@ -414,14 +400,6 @@ function createClaudeHalf(p) {
   }
   if (p.defaultModels && typeof p.defaultModels === 'object') half.defaultModels = dm;
 
-  const m1m = {};
-  if (p.model1M && typeof p.model1M === 'object') {
-    for (const slot of CLAUDE_MODEL_SLOTS) {
-      if (Object.hasOwn(p.model1M, slot)) m1m[slot] = p.model1M[slot];
-    }
-  }
-  if (Object.keys(m1m).length > 0) half.model1M = m1m;
-
   return half;
 }
 
@@ -459,27 +437,6 @@ function createCodexHalf(p) {
   if (Object.hasOwn(srcDm, 'default')) dm.default = srcDm.default;
   if (Object.keys(dm).length > 0) half.defaultModels = dm;
 
-  const m1m = {};
-  const srcM1m = p.model1M && typeof p.model1M === 'object' ? p.model1M : {};
-  for (const slot of CODEX_MODEL_SLOTS) {
-    if (Object.hasOwn(srcM1m, slot)) m1m[slot] = srcM1m[slot];
-  }
-  if (!Object.hasOwn(m1m, 'main') && Object.hasOwn(srcM1m, 'opus')) {
-    m1m.main = srcM1m.opus;
-  }
-  if (!Object.hasOwn(m1m, 'review') && Object.hasOwn(srcM1m, 'sonnet')) {
-    m1m.review = srcM1m.sonnet;
-  }
-  if (!Object.hasOwn(m1m, 'subagent')) {
-    for (const k of ['fast', 'fallback', 'haiku', 'fable']) {
-      if (Object.hasOwn(srcM1m, k)) {
-        m1m.subagent = srcM1m[k];
-        break;
-      }
-    }
-  }
-  if (Object.keys(m1m).length > 0) half.model1M = m1m;
-
   return half;
 }
 
@@ -595,11 +552,9 @@ export function migrateConfigInMemory(rawConfig) {
     }
 
     const claudeSlots = getClaudeSlots(p);
-    const claude1M = getClaude1M(p);
     const codexSlots = getCodexSlots(p);
-    const codex1M = getCodex1M(p);
-    const hasClaude = Object.keys(claudeSlots).length > 0 || Object.keys(claude1M).length > 0;
-    const hasCodex = Object.keys(codexSlots).length > 0 || Object.keys(codex1M).length > 0
+    const hasClaude = Object.keys(claudeSlots).length > 0;
+    const hasCodex = Object.keys(codexSlots).length > 0
       || (Array.isArray(p.publicModels) && p.publicModels.length > 0)
       || (p.codexRoles && Object.keys(p.codexRoles).length > 0);
 
@@ -1079,15 +1034,6 @@ export function modelForSlot(profile, slot) {
   return '';
 }
 
-export function model1MForSlot(profile, slot) {
-  const flags = profile?.model1M || {};
-  if (Object.hasOwn(flags, slot)) return Boolean(flags[slot]);
-  for (const k of legacyKeysForSlot(slot)) {
-    if (Object.hasOwn(flags, k)) return Boolean(flags[k]);
-  }
-  return false;
-}
-
 // ---------------- Codex-facing model names ----------------
 //
 // Codex must never be handed a switcher-internal name. It can display whatever it
@@ -1178,32 +1124,28 @@ function codexCatalogTemplate() {
 
 // One catalog entry. /v1/models and the OpenAI-Model handshake both use it, so they cannot drift.
 // model-catalog.json itself is no longer written (R9: publicModels stays the gateway's mapping table).
-export function codexModelEntry(name, is1M) {
+//
+// The window comes from the model, never from a setting: `win` is what the profile's own list says
+// ({ context, compact }), and the entry then carries the same pair the official Codex catalog
+// publishes — the window to compress at as context_window, the whole one as max_context_window. A
+// model that lists no window keeps the template's.
+export function codexModelEntry(name, win) {
   // The template copies a real OpenAI model. Its Responses Lite and code modes send the tools in a
   // form made for OpenAI's own tools, and an upstream then gets none (LS-5).
   const { tool_mode, ...template } = structuredClone(codexCatalogTemplate() || {});
-  return {
+  const out = {
     ...template,
     use_responses_lite: false,
     slug: name,
-    display_name: name,
-    ...(is1M ? { context_window: 1000000, max_context_window: 1000000 } : {})
+    display_name: name
   };
-}
-
-// name -> is1M. The picker sizes a session from this window, so when two slots share a name the
-// smaller window wins: overstating it makes Codex plan against space it does not have.
-export function smallestWindows(pairs) {
-  const windows = new Map();
-  for (const [name, is1M] of pairs) {
-    if (!name) continue;
-    if (!windows.has(name) || !is1M) windows.set(name, Boolean(is1M));
+  const context = Number(win?.context) || 0;
+  const compact = Number(win?.compact) || 0;
+  if (context > 0) {
+    out.max_context_window = context;
+    out.context_window = compact > 0 && compact < context ? compact : context;
   }
-  return windows;
-}
-
-export function publicModelWindows(profile) {
-  return smallestWindows(CODEX_MODEL_SLOTS.map(slot => [codexPublicModel(profile, slot), model1MForSlot(profile, slot)]));
+  return out;
 }
 
 export function parsePort(value) {
@@ -1342,17 +1284,6 @@ function writeOrRemove(file, content) {
   }
 }
 
-// The main session model. Haiku is left out on purpose: a haiku-only 1M profile would otherwise
-// move the main session to Haiku. claude1MTiers reports every tier, haiku included.
-function claudeTier1M(profile) {
-  const m = profile?.model1M || {};
-  return m.opus ? 'opus[1m]' : m.sonnet ? 'sonnet[1m]' : m.fable ? 'fable[1m]' : null;
-}
-
-function anyTier1M(profile) {
-  return modelSlotsForProfile(profile).some(slot => model1MForSlot(profile, slot));
-}
-
 export function primaryModel(profile) {
   const slots = modelSlotsForProfile(profile);
   for (const slot of slots) {
@@ -1362,13 +1293,14 @@ export function primaryModel(profile) {
   return '';
 }
 
-// What a person needs at launch: which profile took the traffic, the host it goes to, the model it
-// maps to, and whether the 1M window is on, because that changes what the session costs. Never the
-// API key: a desktop notification reads this line, and so can any shell.
+// What a person needs at launch: which profile took the traffic, the host it goes to, and the
+// model it maps to. Never the API key: a desktop notification reads this line, and so can any
+// shell. No window goes with it: the tool sizes the session from the model's own window, which the
+// profile's list reports (see windows.mjs).
 function routeLine(tool, key, profile) {
   let host = '';
   try { host = new URL(profile.baseURL).host; } catch { /* a profile may carry no address yet */ }
-  return [`${tool} -> ${key}`, host, primaryModel(profile), anyTier1M(profile) ? '1M' : '']
+  return [`${tool} -> ${key}`, host, primaryModel(profile)]
     .filter(Boolean).join(' | ');
 }
 

package/switch.cmd

@@ -1,2 +1,2 @@
-@echo off
-node "%~dp0switch.mjs" %*
+@echo off
+node "%~dp0switch.mjs" %*

package/switch.mjs

@@ -7,7 +7,7 @@ import {
   ROOT_DIR, STATE_DIR, TOOLS, configPath, hasPlaceholder, claudeSettingsPath, paths, certCoversHost, loadConfig, getConfigLoadError, saveConfig,
   resolvePort, parsePort, findProfileKey, getActiveMap, setTargetProfile, activateProfile, deactivateAll,
   applyLaunchState, clearLaunchState, computeLaunchState,
-  modelSlotsForProfile, modelForSlot, model1MForSlot, readAdminToken, adminTokenPath, openLog,
+  modelSlotsForProfile, modelForSlot, readAdminToken, adminTokenPath, openLog,
   probeGateway, probeBlindfold, ensureBlindfoldCerts, stopRecordedBlindfold, writeDashboardLauncher,
   contractLabSettings, codexPublicModelsWarning,
   getMigrationError, getMigrationCollision, getLastLoadError,
@@ -342,7 +342,7 @@ function printProfile(profile) {
   console.log(`Upstream:     ${show(profile.baseURL || '(not set)')}`);
   for (const slot of modelSlotsForProfile(profile)) {
     const model = modelForSlot(profile, slot);
-    if (model) console.log(`${(slot[0].toUpperCase() + slot.slice(1) + ':').padEnd(14)}${show(model)}${model1MForSlot(profile, slot) ? '  [1M]' : ''}`);
+    if (model) console.log(`${(slot[0].toUpperCase() + slot.slice(1) + ':').padEnd(14)}${show(model)}`);
   }
 }
 

package/tests/dashboard.e2e.test.mjs

@@ -480,20 +480,19 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       assert.equal(models.haiku, 'my-own-model');
     });
 
-    it('locks the 1M box for a model under 1M, and saves the box for a model that has it', async () => {
+    it('shows the window each listed model has, and offers no window switch', async () => {
       await act(() => editProfile('intact-claude'));
       await act(() => tab('models'));
       await page.waitFor(`document.querySelector('#models-status')?.dataset.state === 'ready'`, 'the model list');
       await page.type('#p-sonnet', 'up-alpha');    // window 200000
-      assert.equal(await page.evaluate(`document.getElementById('p-sonnet-1m').disabled`), true, 'the box is free for a 200K model');
-      assert.match(await page.text('#p-sonnet-1m-note'), /200K.*under 1M/);
+      assert.match(await page.text('#p-sonnet-note'), /200K context/);
       await page.type('#p-opus', 'up-beta');       // window 1000000
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').disabled`), false);
-      await page.click('label:has(#p-opus-1m)');
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').checked`), true);
+      assert.match(await page.text('#p-opus-note'), /1M context/);
+      assert.equal(await page.evaluate(`document.querySelectorAll('#slot-fields input[type=checkbox]').length`), 0, 'no window switch is offered');
       await act(() => saveForm());
-      assert.equal(profiles()['intact-claude'].model1M?.opus, true);
-      assert.notEqual(profiles()['intact-claude'].model1M?.sonnet, true);
+      const saved = profiles()['intact-claude'];
+      assert.equal(saved.defaultModels.opus, 'up-beta');
+      assert.equal(saved.model1M, undefined, 'and nothing window-shaped is saved');
     });
 
     it('says why the list did not load and loads it on Retry', async () => {
@@ -508,7 +507,7 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       assert.equal(await modelsStatus(), '3 models');
     });
 
-    it('clears a model slot and a 1M box that the person emptied', async () => {
+    it('clears a model slot the person emptied, and drops the retired 1M flags', async () => {
       const cfg = fx.config();
       cfg.profiles['intact-claude'].model1M = { opus: true };
       fx.writeConfig(cfg);
@@ -517,14 +516,12 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       await act(() => tab('models'));
       await page.waitFor(`document.querySelector('#models-status')?.dataset.state === 'ready'`, 'the model list');
       await page.type('#p-sonnet', '');
-      await page.key('Escape');    // the list of suggestions covers the boxes below until it closes
-      await page.click('label:has(#p-opus-1m)');
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').checked`), false);
+      await page.key('Escape');    // the list of suggestions covers the row below until it closes
       await act(() => saveForm());
       const saved = profiles()['intact-claude'];
       assert.equal(saved.defaultModels.sonnet, undefined, 'the emptied slot came back');
       assert.equal(saved.defaultModels.opus, 'up-opus');
-      assert.ok(!saved.model1M?.opus, 'the unticked 1M box came back');
+      assert.equal(saved.model1M, undefined, 'the retired flags are not written back');
     });
 
     it('shows the slots of the tool that the profile serves', async () => {