llm-switcher 1.6.3 → 1.6.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.5 — 2026-10-08
+
+- **Automatic Tether Gate Disable for Claude Code (`CLAUDE_CODE_TETHER_LIVE=0`):** Automatically inject `CLAUDE_CODE_TETHER_LIVE=0` into `env-claude.sh` and `env-claude.cmd` whenever the Claude route is active, ensuring Claude Code runs in stateless mode and prevents `message-threads` validation failures on non-Anthropic upstreams. The shim cleans the variable on route deactivation, and the gateway safely rejects unexpected thread requests with `thread_unsupported_request` (HTTP 400).
+- **Two-way Safe Tool Name Sanitization (64-char limit):** Automatically sanitize and shorten tool names exceeding 64 characters (e.g. MCP plugin tools such as `mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages`) into collision-free 64-character identifiers (`^[a-zA-Z0-9_-]{1,64}$`) with embedded SHA-256 hashes for OpenAI Chat and Vertex/Gemini upstreams. The gateway vocabulary bidirectional mapping seamlessly restores the original MCP tool name in responses to Claude Code without buffering delays.
+
+## Release 1.6.4 — 2026-10-08
+
+- **Dynamic Model Provider Source for Idle Compaction:** Query live model listings directly from the selected profile's `baseURL` via `/models` instead of hardcoding provider URLs or static model lists.
+- **Clean Model Combobox without Slot Aliases:** Eliminate hardcoded quick preset buttons, popular model arrays, and slot aliases from the summarization model combobox. Models are loaded dynamically from the upstream provider, sorted alphabetically with context limits, with support for instant search filtering and deterministic heuristic truncation (`""`).
+
 ## Release 1.6.3 — 2026-10-08
 
 - **Interactive Summarization Model Selection & Presets:** Replace raw text input for Idle Compaction's summarization model with a fully searchable combobox dropdown and quick 1-click preset chips. Users can pick directly from deterministic heuristic mode (`""`), slot aliases (`haiku`, `subagent`, `sonnet`, `main`), configured profile models (`zencore/*`, `codex/*`), and discovered catalog models, or type to filter in real-time. Selection automatically saves and updates active highlights across both light and dark themes.

package/formats.mjs

@@ -24,6 +24,8 @@
 // }
 // ============================================================
 
+import { sanitizeToolName } from './toolvocab.mjs';
+
 export const OUT_FORMATS = ['openai-chat', 'anthropic', 'vertex'];
 
 // ---------------- stop reasons ----------------
@@ -910,7 +912,7 @@ function repairToolCall(tc, vocab) {
 function toolNamesNotice(ir, systemText) {
   const names = (ir.tools || [])
     .filter(t => t && typeof t.name === 'string' && t.name && t.side !== 'provider')
-    .map(t => t.name);
+    .map(t => sanitizeToolName(t.name));
   if (names.length < 2) return '';
   const missing = names.filter(n => !String(systemText || '').includes(n));
   if (!missing.length) return '';
@@ -1055,7 +1057,7 @@ function irToChatBody(ir, model, opts = {}) {
     if (m.content !== undefined) out.content = m.content;
     if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
       out.tool_calls = m.toolCalls.map(tc => {
-        const call = { id: tc.id, type: 'function', function: { name: tc.name, arguments: stringifyArgs(tc.args) } };
+        const call = { id: tc.id, type: 'function', function: { name: sanitizeToolName(tc.name), arguments: stringifyArgs(tc.args) } };
         const sig = tc.sig || lookupToolSignature(tc.id);
         if (sig) call.extra_content = { google: { thought_signature: sig } };
         return call;
@@ -1072,14 +1074,14 @@ function irToChatBody(ir, model, opts = {}) {
   if (tools.length) {
     body.tools = tools.map(t => ({
       type: 'function',
-      function: { name: t.name, description: t.description || '', parameters: sanitizeJsonSchema(t.parameters || {}) }
+      function: { name: sanitizeToolName(t.name), description: t.description || '', parameters: sanitizeJsonSchema(t.parameters || {}) }
     }));
   }
   if (ir.toolChoice) {
     if (typeof ir.toolChoice === 'string') {
       body.tool_choice = ir.toolChoice === 'required' ? 'required' : ir.toolChoice;
     } else if (ir.toolChoice.name) {
-      body.tool_choice = { type: 'function', function: { name: ir.toolChoice.name } };
+      body.tool_choice = { type: 'function', function: { name: sanitizeToolName(ir.toolChoice.name) } };
     }
   }
   if (typeof ir.params.maxTokens === 'number') {
@@ -1176,7 +1178,7 @@ function irToAnthropicBody(ir, model, opts = {}) {
     if (m.role === 'assistant') {
       const blocks = contentToAnthropicBlocks(m.content).filter(b => b.type === 'text');
       for (const tc of (m.toolCalls || [])) {
-        blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: parseArgs(tc.args) });
+        blocks.push({ type: 'tool_use', id: tc.id, name: sanitizeToolName(tc.name), input: parseArgs(tc.args) });
       }
       if (blocks.length) messages.push({ role: 'assistant', content: blocks });
       continue;
@@ -1220,7 +1222,7 @@ function irToAnthropicBody(ir, model, opts = {}) {
   const anthropicTools = clientTools(ir);
   if (anthropicTools.length) {
     body.tools = anthropicTools.map(t => ({
-      name: t.name, description: t.description || '',
+      name: sanitizeToolName(t.name), description: t.description || '',
       input_schema: sanitizeJsonSchema(t.parameters || {})
     }));
   }
@@ -1228,7 +1230,7 @@ function irToAnthropicBody(ir, model, opts = {}) {
     if (typeof ir.toolChoice === 'string') {
       body.tool_choice = ir.toolChoice === 'required' ? { type: 'any' } : { type: ir.toolChoice };
     } else if (ir.toolChoice.name) {
-      body.tool_choice = { type: 'tool', name: ir.toolChoice.name };
+      body.tool_choice = { type: 'tool', name: sanitizeToolName(ir.toolChoice.name) };
     }
   }
   if (ir.params.parallelToolCalls === false && body.tool_choice) body.tool_choice.disable_parallel_tool_use = true;
@@ -1327,13 +1329,13 @@ function irToVertexBody(ir, model, opts = {}) {
         resp = (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : { result: parsed ?? '' };
       } catch { resp = { result: m.content ?? '' }; }
       // Gemini API & Vertex only accept roles 'user' | 'model' (functionResponse lives in the 'user' role).
-      push('user', [{ functionResponse: { name: m.name || 'tool', response: resp } }]);
+      push('user', [{ functionResponse: { name: sanitizeToolName(m.name || 'tool', { allowHyphens: false }), response: resp } }]);
       continue;
     }
     if (m.role === 'assistant') {
       const parts = textPartsOf(m.content).filter(p => p.text);
       (m.toolCalls || []).forEach((tc, j) => {
-        const part = { functionCall: { name: tc.name, args: parseArgs(tc.args) } };
+        const part = { functionCall: { name: sanitizeToolName(tc.name, { allowHyphens: false }), args: parseArgs(tc.args) } };
         const sig = tc.sig || lookupToolSignature(tc.id);
         if (sig) part.thoughtSignature = sig;
         // Only the first functionCall of each step in the current turn is checked.
@@ -1354,7 +1356,7 @@ function irToVertexBody(ir, model, opts = {}) {
   if (vertexTools.length) {
     body.tools = [{
       functionDeclarations: vertexTools.map(t => ({
-        name: t.name, description: t.description || '',
+        name: sanitizeToolName(t.name, { allowHyphens: false }), description: t.description || '',
         parameters: toGeminiSchema(t.parameters || { type: 'object', properties: {} })
       }))
     }];
@@ -1362,7 +1364,7 @@ function irToVertexBody(ir, model, opts = {}) {
   if (ir.toolChoice) {
     const mode = ir.toolChoice === 'none' ? 'NONE' : ir.toolChoice === 'auto' ? 'AUTO' : 'ANY';
     const fcc = { mode };
-    if (typeof ir.toolChoice === 'object' && ir.toolChoice.name) fcc.allowedFunctionNames = [ir.toolChoice.name];
+    if (typeof ir.toolChoice === 'object' && ir.toolChoice.name) fcc.allowedFunctionNames = [sanitizeToolName(ir.toolChoice.name, { allowHyphens: false })];
     if (body.tools) body.toolConfig = { functionCallingConfig: fcc };
   }
   const gc = {};
@@ -2071,10 +2073,11 @@ function createAnthropicStream(emit, model, opts = {}) {
       if (!st) {
         closeOpen();
         const fixed = vocab ? vocab.name(tc.name) : tc.name;
+        const isShort = Boolean(vocab && typeof vocab.isShortened === 'function' && vocab.isShortened(tc.name));
         st = {
           index: nextIndex++, id: tc.id || `toolu_${rand(24)}`, name: fixed || 'tool', closed: false,
-          // Only a renamed name needs the arguments held back.
-          buffered: '', held: Boolean(vocab && fixed && fixed !== tc.name)
+          // Only a renamed name needs the arguments held back. Shortened names use caller's schema.
+          buffered: '', held: Boolean(vocab && fixed && fixed !== tc.name && !isShort)
         };
         tools.set(key, st);
         emit('content_block_start', {
@@ -2186,7 +2189,8 @@ function createChatStream(emit, model, opts = {}) {
       const idx = tc.index ?? 0;
       if (!seenTools.has(idx)) {
         const name = vocab ? vocab.name(tc.name) : tc.name;
-        seenTools.set(idx, { idx, name, buffered: '', held: Boolean(vocab && name && name !== tc.name) });
+        const isShort = Boolean(vocab && typeof vocab.isShortened === 'function' && vocab.isShortened(tc.name));
+        seenTools.set(idx, { idx, name, buffered: '', held: Boolean(vocab && name && name !== tc.name && !isShort) });
         chunk([{ index: 0, delta: { tool_calls: [{ index: idx, id: tc.id || `call_${rand(24)}`, type: 'function', function: { name: name || 'tool', arguments: '' } }] }, finish_reason: null }]);
       }
       const st = seenTools.get(idx);
@@ -2394,10 +2398,11 @@ function createResponsesStream(emit, model, opts = {}) {
         // Codex runs a tool on output_item.done, and the name is in that item. A renamed call
         // therefore cannot be streamed argument by argument: the keys are only known once the whole
         // object exists, so its arguments are held and go out with the item.
+        const isShort = Boolean(vocab && typeof vocab.isShortened === 'function' && vocab.isShortened(tc.name));
         st = {
           id: `${prefix}_${rand(24)}`, callId: tc.id || `call_${rand(24)}`, index: nextOutput++,
           name: name || '', args: '', done: false, kind, upstream: tc.name,
-          held: Boolean(vocab && name && name !== tc.name)
+          held: Boolean(vocab && name && name !== tc.name && !isShort)
         };
         tools.set(key, st);
         if (kind !== 'local_shell') {
@@ -2598,5 +2603,5 @@ export {
   createResponsesStream, buildResponsesMessage,
   vertexFinish, createVertexStream, buildVertexMessage,
   createCodeAssistStream, buildCodeAssistMessage,
-  isAntigravityModel
+  isAntigravityModel, sanitizeToolName
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -27,7 +27,7 @@ import {
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
 import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows } from './windows.mjs';
-import { createToolVocab } from './toolvocab.mjs';
+import { createToolVocab, NULL_TOOL_VOCAB } from './toolvocab.mjs';
 import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
 import { checkForUpdate } from './version.mjs';
 import { applyUpdate } from './update.mjs';
@@ -498,14 +498,10 @@ function parsePayloadLine(line) {
 // 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;
+  if (!ir || typeof ir !== 'object') return NULL_TOOL_VOCAB;
+  if (!ir._vocab) ir._vocab = createToolVocab(ir.tools);
+  return ir._vocab;
 }
 
 function clientRenderer(clientFormat, res, model, opts = {}) {
@@ -918,6 +914,21 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
     return;
   }
 
+  // Handle Claude Code tether (message threads): reject with thread_unsupported_request
+  // so Claude Code immediately falls back to stateless mode and retries.
+  if (clientFormat === 'anthropic' && (payload?.thread || ((req.headers['anthropic-beta'] || '').includes('message-threads') && payload?.thread))) {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      type: 'error',
+      error: {
+        type: 'invalid_request_error',
+        message: 'Message threads (tether) are not supported by this upstream gateway.',
+        error_code: 'thread_unsupported_request'
+      }
+    }));
+    return;
+  }
+
   const wantIn = profile.inFormat || 'auto';
   if (wantIn !== 'auto' && wantIn !== clientFormat) {
     sendClientError(res, clientFormat, 400, `Profile "${profileKey}" expects "${wantIn}" input, got "${clientFormat}"`);

package/shim.mjs

@@ -185,6 +185,7 @@ if tier_is_stale "$ANTHROPIC_DEFAULT_FABLE_MODEL" fable; then unset ANTHROPIC_DE
 [ "\${CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT:-}" = "1" ] && unset CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT
 [ "\${CLAUDE_CODE_AUTO_COMPACT_WINDOW:-}" = "900000" ] && unset CLAUDE_CODE_AUTO_COMPACT_WINDOW
 [ "\${OPENAI_MAX_CONTEXT_TOKENS:-}" = "1000000" ] && unset OPENAI_MAX_CONTEXT_TOKENS
+[ "\$TOOL_ACTIVE" != "1" ] && [ "\${CLAUDE_CODE_TETHER_LIVE:-}" = "0" ] && unset CLAUDE_CODE_TETHER_LIVE
 
 # LLM_SWITCHER_CODEX_* was always a shim input, never the user's. Every OTHER LLM_SWITCHER_*
 # name is a user setting and is kept.
@@ -301,6 +302,7 @@ if defined ANTHROPIC_DEFAULT_FABLE_MODEL call :SCRUB_TIER ANTHROPIC_DEFAULT_FABL
 if "%CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT%"=="1" set "CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT="
 if "%CLAUDE_CODE_AUTO_COMPACT_WINDOW%"=="900000" set "CLAUDE_CODE_AUTO_COMPACT_WINDOW="
 if "%OPENAI_MAX_CONTEXT_TOKENS%"=="1000000" set "OPENAI_MAX_CONTEXT_TOKENS="
+if not "%TOOL_ACTIVE%"=="1" if "%CLAUDE_CODE_TETHER_LIVE%"=="0" set "CLAUDE_CODE_TETHER_LIVE="
 for /f "tokens=1 delims==" %%V in ('set LLM_SWITCHER_CODEX_ 2^>nul ^| findstr /b /c:"LLM_SWITCHER_CODEX_"') do set "%%V="
 ${caBlock}
 

package/state.mjs

@@ -1365,7 +1365,8 @@ export function computeLaunchState(cfg, port) {
 
   // NODE_EXTRA_CA_CERTS is deliberately absent from env-claude: the shim decides it at launch,
   // because only then does it know whether the user brought a CA of their own (R2).
-  if (claude) state.envClaude = proxyPairs();
+  // When Claude route is ON, disable tether (message threads) so Claude Code operates stateless.
+  if (claude) state.envClaude = [...proxyPairs(), ['CLAUDE_CODE_TETHER_LIVE', '0']];
   // Codex builds its TLS client from CODEX_CA_CERTIFICATE the moment it starts, and a path it cannot
   // read is fatal: it dies before its first request, and its long-lived daemon then fails its own
   // update with "Failed to read CA certificate file". So the CA is only offered when it is really

package/tests/state.test.mjs

@@ -139,7 +139,7 @@ test('computeLaunchState derives launch state per target profile, not from one g
   const names = (pairs) => pairs.map(([k]) => k).sort();
   // R2: exactly these names, each tool in its own file. Nothing here names an endpoint, a
   // model or a context window, so no tool can be reconfigured and none can capture the other.
-  assert.deepEqual(names(st.envClaude), ['HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
+  assert.deepEqual(names(st.envClaude), ['CLAUDE_CODE_TETHER_LIVE', 'HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
   assert.deepEqual(names(st.envCodex),
     ['CODEX_CA_CERTIFICATE', 'HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
   // The proxy is the interceptor, not the gateway itself (R3).
@@ -261,6 +261,10 @@ test('every active tool is routed through the interceptor with only the variable
   for (const [label, pairs] of [['claude', st.envClaude], ['codex', st.envCodex]]) {
     for (const [k, v] of pairs) {
       assert.ok(!/_URL$|BASE_URL/.test(k), `${label}: ${k} would print an override banner`);
+      if (k === 'CLAUDE_CODE_TETHER_LIVE') {
+        assert.equal(v, '0', `${label}: tether must be disabled`);
+        continue;
+      }
       assert.ok(!/MODEL|CONTEXT|WINDOW|CLAUDE_CODE_|OPENAI_/.test(k), `${label}: ${k} names a model`);
       assert.ok(typeof v === 'string' && v.length > 0, `${label}: ${k} must have a value`);
     }
@@ -382,6 +386,7 @@ test('the launch state writes no 1M tag or model variable, whatever model1M says
     const st = computeLaunchState(cfg, 4000);
     assert.equal(st.active, true, 'the profile is active whatever it marks 1M');
     for (const [k] of [...st.envClaude, ...st.envCodex]) {
+      if (k === 'CLAUDE_CODE_TETHER_LIVE') continue;
       assert.ok(!/ANTHROPIC|CLAUDE_CODE|OPENAI_|MODEL|1M|CONTEXT|WINDOW/.test(k),
         `${k} must not be written for ${JSON.stringify(model1M)}`);
     }

package/tests/tool-repair.test.mjs

@@ -2,7 +2,7 @@
 // declared. Sources for every name here are collected in docs/tool-vocabulary.md.
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { createToolVocab, NULL_TOOL_VOCAB, tokenize } from '../toolvocab.mjs';
+import { createToolVocab, NULL_TOOL_VOCAB, tokenize, sanitizeToolName } from '../toolvocab.mjs';
 import {
   anthropicToIR, responsesToIR, irToChatBody, buildAnthropicMessage, buildChatMessage, buildResponsesMessage,
   createAnthropicStream, createChatStream, createResponsesStream
@@ -278,3 +278,112 @@ test('the notice and the think guide coexist', () => {
   assert.ok(sys.includes('<think> and </think>'), `the think guide is missing: ${sys}`);
   assert.match(sys, /use exactly these names/i);
 });
+
+// Tool names longer than 64 characters (e.g. MCP plugin tools) must be sanitized for OpenAI/Gemini
+// APIs (<= 64 chars, ^[a-zA-Z0-9_-]{1,64}$) and mapped back in responses.
+test('sanitizeToolName: enforces 1-64 character length and valid identifier charset', () => {
+  assert.equal(sanitizeToolName('Bash'), 'Bash');
+  assert.equal(sanitizeToolName('Read'), 'Read');
+  assert.equal(sanitizeToolName('mcp__github__create_issue'), 'mcp__github__create_issue');
+
+  const name64 = 'a'.repeat(64);
+  assert.equal(sanitizeToolName(name64), name64);
+
+  // Exact problematic tool from chrome-devtools MCP (70 chars)
+  const chromeDevToolsTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  assert.equal(chromeDevToolsTool.length, 70);
+  const sanitized = sanitizeToolName(chromeDevToolsTool);
+  assert.ok(sanitized.length <= 64, `length must be <= 64, got ${sanitized.length}`);
+  assert.equal(sanitized.length, 64);
+  assert.match(sanitized, /^[a-zA-Z0-9_-]{1,64}$/);
+  assert.ok(sanitized.startsWith('mcp__plugin_chrome-devtools-mcp_'));
+  assert.ok(sanitized.endsWith('_list_console_messages'));
+
+  // Another long tool with different suffix gets a distinct hash
+  const networkTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_network_requests';
+  const sanitizedNetwork = sanitizeToolName(networkTool);
+  assert.equal(sanitizedNetwork.length, 64);
+  assert.notEqual(sanitized, sanitizedNetwork);
+
+  // allowHyphens: false for Vertex/Gemini
+  const vertexSanitized = sanitizeToolName(chromeDevToolsTool, { allowHyphens: false });
+  assert.equal(vertexSanitized.length, 64);
+  assert.match(vertexSanitized, /^[a-zA-Z_][a-zA-Z0-9_]*$/);
+  assert.ok(!vertexSanitized.includes('-'));
+});
+
+test('createToolVocab: round-trips >64 char tool names back to client declared name', () => {
+  const longName = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const ir = anthropicToIR({
+    model: 'claude-opus-4-6', messages: [{ role: 'user', content: 'check console' }],
+    tools: [
+      { name: longName, input_schema: { properties: { count: { type: 'number' } } } }
+    ]
+  });
+
+  const vocab = createToolVocab(ir.tools);
+  const upstreamSafe = sanitizeToolName(longName);
+  assert.notEqual(upstreamSafe, longName);
+  assert.equal(upstreamSafe.length, 64);
+
+  // Model answers with the sanitized name -> vocab recovers original declared name
+  assert.equal(vocab.name(upstreamSafe), longName);
+  assert.ok(vocab.isShortened(upstreamSafe));
+
+  // Streaming does not hold arguments for shortened names (they keep caller's schema)
+  const deltas = [];
+  const renderer = createAnthropicStream((event, data) => deltas.push({ event, data }), 'claude-opus-4-6', { vocab });
+  renderer.start();
+  renderer.tool({ index: 0, id: 'call_1', name: upstreamSafe, args: '{"count": 10}' });
+  renderer.finish('stop');
+
+  const startBlock = deltas.find(d => d.event === 'content_block_start');
+  assert.equal(startBlock.data.content_block.name, longName);
+
+  const jsonDelta = deltas.find(d => d.event === 'content_block_delta' && d.data.delta.type === 'input_json_delta');
+  assert.ok(jsonDelta, 'input_json_delta should be emitted');
+  assert.equal(jsonDelta.data.delta.partial_json, '{"count": 10}');
+
+  // Non-streaming builder also restores the original name
+  const msg = buildAnthropicMessage({
+    model: 'claude-opus-4-6',
+    tools: [{ index: 0, id: 'call_1', name: upstreamSafe, args: '{"count": 10}' }],
+    finish: 'tool_calls',
+    vocab
+  });
+  const toolUse = msg.content.find(c => c.type === 'tool_use');
+  assert.equal(toolUse.name, longName);
+});
+
+test('irToChatBody: serializes long tool names, assistant history, and toolChoice within 64 chars', () => {
+  const longName = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const ir = anthropicToIR({
+    model: 'gpt-4o',
+    messages: [
+      { role: 'user', content: 'first turn' },
+      { role: 'assistant', content: [{ type: 'tool_use', id: 'call_1', name: longName, input: { count: 5 } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'call_1', content: 'ok' }] }
+    ],
+    tools: [
+      { name: longName, input_schema: { properties: { count: { type: 'number' } } } }
+    ]
+  });
+  ir.toolChoice = { name: longName };
+
+  const body = irToChatBody(ir, 'gpt-4o');
+
+  // Declared tools must have <=64 char function names matching regex
+  assert.ok(body.tools && body.tools.length === 1);
+  const toolFn = body.tools[0].function;
+  assert.ok(toolFn.name.length <= 64);
+  assert.match(toolFn.name, /^[a-zA-Z0-9_-]{1,64}$/);
+  assert.equal(toolFn.name, sanitizeToolName(longName));
+
+  // Assistant turn in history must have its tool call name shortened too
+  const asstMsg = body.messages.find(m => m.role === 'assistant');
+  assert.ok(asstMsg && asstMsg.tool_calls && asstMsg.tool_calls.length === 1);
+  assert.equal(asstMsg.tool_calls[0].function.name, sanitizeToolName(longName));
+
+  // toolChoice must be shortened
+  assert.equal(body.tool_choice.function.name, sanitizeToolName(longName));
+});

package/toolvocab.mjs

@@ -1,3 +1,5 @@
+import crypto from 'node:crypto';
+
 // 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
@@ -191,6 +193,27 @@ function repairArgs(args, tool) {
   return out;
 }
 
+/**
+ * Sanitize a tool name to conform to upstream API length and character constraints.
+ * OpenAI Chat: 1-64 letters, digits, underscores or hyphens (^[a-zA-Z0-9_-]{1,64}$).
+ * Vertex AI / Gemini: 1-64 alphanumeric or underscore (^[a-zA-Z_][a-zA-Z0-9_]*$).
+ * If length > 64, preserves a 32-char head, 22-char tail, and embeds an 8-char sha256 hash.
+ */
+export function sanitizeToolName(name, { allowHyphens = true } = {}) {
+  if (typeof name !== 'string' || !name) return 'tool';
+  const pattern = allowHyphens ? /[^a-zA-Z0-9_-]/g : /[^a-zA-Z0-9_]/g;
+  let cleaned = name.replace(pattern, '_');
+  if (!allowHyphens && /^[0-9]/.test(cleaned)) {
+    cleaned = `_${cleaned}`;
+  }
+  if (cleaned.length <= 64 && cleaned === name) return name;
+  if (cleaned.length <= 64) return cleaned;
+  const hash = crypto.createHash('sha256').update(name).digest('hex').slice(0, 8);
+  const head = cleaned.slice(0, 32);
+  const tail = cleaned.slice(-22);
+  return `${head}_${hash}_${tail}`;
+}
+
 /**
  * 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.
@@ -205,8 +228,18 @@ export function createToolVocab(declared) {
     .filter(t => t && typeof t.name === 'string' && t.name && t.side !== 'provider');
   const byName = new Map();
   const candidates = [];
+  const shortenedToOriginal = new Map();
+
   for (const t of tools) {
     const caps = capabilitiesOf(t.name);
+    const safeChat = sanitizeToolName(t.name, { allowHyphens: true });
+    const safeVertex = sanitizeToolName(t.name, { allowHyphens: false });
+    if (safeChat !== t.name) {
+      shortenedToOriginal.set(safeChat, t.name);
+    }
+    if (safeVertex !== t.name) {
+      shortenedToOriginal.set(safeVertex, 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.
@@ -217,11 +250,17 @@ export function createToolVocab(declared) {
   // 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 isShortened(upstream) {
+    const raw = String(upstream || '');
+    return shortenedToOriginal.has(raw);
+  }
+
   function name(upstream) {
-    if (!useful) return upstream;
     const raw = String(upstream || '');
     if (!raw || raw === 'tool') return upstream;
+    if (shortenedToOriginal.has(raw)) return shortenedToOriginal.get(raw);
     if (byName.has(raw)) return upstream;                 // already the client's own name
+    if (!useful) return upstream;
     const ns = namespaceOf(raw);
     if (ns) return upstream;                              // a server's tool never becomes a local one
     const want = capabilitiesOf(raw);
@@ -243,8 +282,9 @@ export function createToolVocab(declared) {
   }
 
   function args(upstream, argsJson) {
-    if (!useful) return argsJson;
-    const target = byName.get(name(upstream));
+    const fixedName = name(upstream);
+    if (!useful && !shortenedToOriginal.has(String(upstream || ''))) return argsJson;
+    const target = byName.get(fixedName);
     if (!target) return argsJson;
     let parsed;
     try {
@@ -260,13 +300,19 @@ export function createToolVocab(declared) {
   return {
     name,
     args,
+    isShortened,
     /** 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 };
+      return { name: fixedName, args: args(upstream, 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 }) });
+export const NULL_TOOL_VOCAB = Object.freeze({
+  name: n => n,
+  args: (n, a) => a,
+  isShortened: () => false,
+  repair: (n, a) => ({ name: n, args: a, renamed: false })
+});

package/ui.html

@@ -1105,12 +1105,23 @@
                 </div>
               </div>
 
+              <div class="row">
+                <div class="who">
+                  <div class="l">Model Provider Source</div>
+                  <div class="meta" id="idle-compact-source-meta">Profile Base URL queried via /models to list upstream models</div>
+                </div>
+                <div style="display:flex; align-items:center; gap:0.5rem; margin-left:auto; min-width:18rem; max-width:26rem;">
+                  <select id="idle-compact-source-profile" onchange="onCompactSourceProfileChange()" style="flex:1; font-size:0.8rem;"></select>
+                  <button type="button" class="btn btn-outline btn-sm" id="btn-reload-compact-models" onclick="reloadCompactModels(true)" title="Fetch live models from provider Base URL">Reload</button>
+                </div>
+              </div>
+
               <div class="row" style="align-items:flex-start;">
                 <div class="who" style="padding-top:0.25rem;">
                   <div class="l">Summarization Model</div>
-                  <div class="meta">Select from discovered/profile models or enter custom ID (empty = deterministic truncation)</div>
+                  <div class="meta" id="idle-compact-models-status">Select model from provider URL or enter custom ID (empty = deterministic truncation)</div>
                 </div>
-                <div style="min-width:18rem; flex:1; max-width:28rem; margin-left:auto; display:flex; flex-direction:column; gap:0.4rem;">
+                <div style="min-width:18rem; flex:1; max-width:26rem; margin-left:auto;">
                   <div class="combo" id="combo-compact-model">
                     <input type="text" id="idle-compact-model" placeholder="empty = deterministic truncation" maxlength="512" onchange="saveIdleCompact()" role="combobox" aria-autocomplete="list" aria-expanded="false" aria-controls="idle-compact-model-list" autocomplete="off" spellcheck="false" style="font-family:var(--font-mono); font-size:0.8rem;" title="Upstream model used to generate turn summary text">
                     <button type="button" class="combo-toggle" tabindex="-1" aria-label="Show available summary models">
@@ -1118,9 +1129,6 @@
                     </button>
                     <ul class="combo-list" id="idle-compact-model-list" role="listbox" aria-label="Available summarization models" hidden></ul>
                   </div>
-                  <div id="compact-model-presets" style="display:flex; flex-wrap:wrap; align-items:center; gap:0.35rem;">
-                    <!-- Quick Presets rendered dynamically -->
-                  </div>
                 </div>
               </div>
 
@@ -2072,10 +2080,7 @@
       const elKb = document.getElementById('idle-compact-kb');
       if (elKb) elKb.value = (c.minBytes ?? 65536) / 1024;
       const elModel = document.getElementById('idle-compact-model');
-      if (elModel) {
-        elModel.value = c.model || '';
-        updateCompactModelPresets(c.model || '');
-      }
+      if (elModel) elModel.value = c.model || '';
       const elCodex = document.getElementById('idle-compact-codex');
       if (elCodex) elCodex.checked = !!c.codex;
       const elKeep = document.getElementById('idle-compact-keep');
@@ -2125,66 +2130,107 @@
       }
     }
 
-    async function ensureCatalogLoaded() {
-      if (cachedCatalog) return cachedCatalog;
-      try {
-        const res = await api('/api/catalog');
-        if (res.ok) cachedCatalog = await res.json();
-      } catch {}
-      return cachedCatalog;
+    let compactLoadedModels = [];
+    let compactLoadedLimits = {};
+    let compactSourceProfileKey = '';
+
+    function populateCompactSourceProfiles() {
+      const sel = document.getElementById('idle-compact-source-profile');
+      if (!sel) return;
+      const profiles = state.config?.profiles || {};
+      const activeClaude = state.config?.activeProfiles?.claude;
+      const activeCodex = state.config?.activeProfiles?.codex;
+      const keys = Object.keys(profiles);
+
+      if (!compactSourceProfileKey || !profiles[compactSourceProfileKey]) {
+        compactSourceProfileKey = activeClaude || activeCodex || keys[0] || '';
+      }
+
+      if (!keys.length) {
+        sel.innerHTML = '<option value="">(No profiles configured)</option>';
+        return;
+      }
+
+      sel.innerHTML = keys.map(k => {
+        const p = profiles[k];
+        const isActive = (k === activeClaude || k === activeCodex);
+        const prefix = isActive ? '★ ' : '';
+        const selected = (k === compactSourceProfileKey) ? 'selected' : '';
+        return `<option value="${escapeHtml(k)}" ${selected}>${escapeHtml(prefix + (p.name || k))} (${escapeHtml(p.baseURL || 'no URL')})</option>`;
+      }).join('');
+
+      updateCompactSourceMeta();
     }
 
-    function setCompactModel(model) {
-      const inp = document.getElementById('idle-compact-model');
-      if (inp) {
-        inp.value = model;
-        saveIdleCompact();
-        updateCompactModelPresets(model);
+    function updateCompactSourceMeta() {
+      const meta = document.getElementById('idle-compact-source-meta');
+      const p = state.config?.profiles?.[compactSourceProfileKey];
+      if (meta && p) {
+        meta.textContent = `${p.baseURL || 'No Base URL configured'} · ${p.outFormat || p.mode || 'convert'}`;
       }
     }
 
-    function updateCompactModelPresets(currentModel) {
-      const container = document.getElementById('compact-model-presets');
-      if (!container) return;
-      if (currentModel === undefined) {
-        currentModel = document.getElementById('idle-compact-model')?.value.trim() || '';
+    async function onCompactSourceProfileChange() {
+      const sel = document.getElementById('idle-compact-source-profile');
+      if (sel) {
+        compactSourceProfileKey = sel.value;
+        updateCompactSourceMeta();
+        await reloadCompactModels(true);
       }
+    }
 
-      const presets = [
-        { id: '', label: 'Deterministic (none)' },
-        { id: 'haiku', label: 'haiku' },
-        { id: 'subagent', label: 'subagent' }
-      ];
+    async function reloadCompactModels(force = false) {
+      const p = state.config?.profiles?.[compactSourceProfileKey];
+      const statusEl = document.getElementById('idle-compact-models-status');
+      const reloadBtn = document.getElementById('btn-reload-compact-models');
+      if (!p || !p.baseURL) {
+        compactLoadedModels = [];
+        compactLoadedLimits = {};
+        if (statusEl) statusEl.textContent = 'Configure a Base URL on the profile to load live models';
+        return;
+      }
 
-      const profiles = state.config?.profiles || {};
-      let added = 0;
-      for (const p of Object.values(profiles)) {
-        if (p.defaultModels) {
-          for (const [slot, m] of Object.entries(p.defaultModels)) {
-            if (m && added < 2 && !presets.some(x => x.id === m)) {
-              presets.push({ id: m, label: m.includes('/') ? m.split('/')[1] : m });
-              added++;
-            }
+      if (statusEl) statusEl.textContent = `Loading models from ${p.baseURL}...`;
+      if (reloadBtn) reloadBtn.disabled = true;
+
+      try {
+        const res = await api('/api/fetch-models', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ baseURL: p.baseURL, apiKey: MASKED_KEY, key: compactSourceProfileKey })
+        });
+        const data = await res.json();
+        if (data.ok && Array.isArray(data.models)) {
+          compactLoadedModels = data.models;
+          compactLoadedLimits = data.limits || {};
+          if (statusEl) {
+            statusEl.textContent = `${compactLoadedModels.length} models loaded from ${p.baseURL}. Select from list or enter model ID.`;
+          }
+        } else {
+          compactLoadedModels = [];
+          compactLoadedLimits = {};
+          if (statusEl) {
+            statusEl.textContent = `Models not loaded: ${modelsError(data.error)}`;
           }
         }
+      } catch (err) {
+        compactLoadedModels = [];
+        compactLoadedLimits = {};
+        if (statusEl) statusEl.textContent = `Failed to load models: ${err.message}`;
+      } finally {
+        if (reloadBtn) reloadBtn.disabled = false;
+        const combo = document.getElementById('combo-compact-model');
+        if (combo && combo.hasAttribute('data-open')) renderComboOptions(combo);
       }
-
-      container.innerHTML = `<span class="hint" style="font-size:0.75rem; align-self:center; margin-right:0.2rem;">Quick Presets:</span>` +
-        presets.map(p => {
-          const active = (p.id === currentModel);
-          const style = active
-            ? 'padding:0.18rem 0.5rem; font-size:0.75rem; border-color:var(--accent); color:var(--accent); background:var(--accent-soft); font-weight:600;'
-            : 'padding:0.18rem 0.5rem; font-size:0.75rem;';
-          return `<button type="button" class="btn btn-outline btn-sm" style="${style}" onclick="setCompactModel('${escapeHtml(p.id)}')">${escapeHtml(p.label)}</button>`;
-        }).join('');
     }
 
     async function loadIdleCompact() {
-      ensureCatalogLoaded();
+      populateCompactSourceProfiles();
       try {
         const r = await api('/api/idle-compact');
         if (r.ok) showIdleCompact((await r.json()).idleCompact);
       } catch { /* the card stays at its defaults; nothing here is required to route */ }
+      await reloadCompactModels();
     }
 
     async function saveIdleCompact() {
@@ -2861,9 +2907,6 @@
         combo.dataset.filter = '1';
         combo.activeIndex = -1;
         openCombo(combo);
-        if (input.id === 'idle-compact-model') {
-          updateCompactModelPresets(input.value.trim());
-        }
       });
       input.addEventListener('keydown', onComboKeydown);
       input.addEventListener('blur', () => closeCombo(combo));
@@ -2971,54 +3014,16 @@
       // 1. Deterministic option (empty string)
       add('', 'Deterministic Truncation (no external call)', 'Pure heuristic context truncation · Zero latency & zero tokens', 'Deterministic');
 
-      // 2. Profile role/slot aliases (recommended for routing)
-      add('haiku', 'haiku (Claude Haiku Slot)', 'Auto-resolves to active profile Claude Haiku model', 'Slot Aliases');
-      add('subagent', 'subagent (Codex Subagent Slot)', 'Auto-resolves to active profile Codex Subagent model', 'Slot Aliases');
-      add('sonnet', 'sonnet (Claude Sonnet Slot)', 'Auto-resolves to active profile Claude Sonnet model', 'Slot Aliases');
-      add('main', 'main (Codex Main Slot)', 'Auto-resolves to active profile Codex Main model', 'Slot Aliases');
-
-      // 3. Models configured in current profiles
-      const profiles = state.config?.profiles || {};
-      for (const [profKey, p] of Object.entries(profiles)) {
-        const profName = p.name || profKey;
-        if (p.defaultModels) {
-          for (const [slot, m] of Object.entries(p.defaultModels)) {
-            if (m) add(m, m, `${profName} · ${slot} slot`, 'Profile Models');
-          }
-        }
-        if (Array.isArray(p.publicModels)) {
-          for (const m of p.publicModels) {
-            if (m) add(m, m, `${profName}`, 'Profile Models');
-          }
-        }
-      }
-
-      // 4. Discovered Catalog models
-      if (cachedCatalog) {
-        if (Array.isArray(cachedCatalog.claude?.models)) {
-          for (const m of cachedCatalog.claude.models) {
-            if (m.id) add(m.id, m.id, `Claude Catalog · ${m.tier || ''}`, 'Catalog');
-          }
-        }
-        if (Array.isArray(cachedCatalog.codex?.models)) {
-          for (const m of cachedCatalog.codex.models) {
-            if (m.id) add(m.id, m.id, `Codex Catalog · ${m.role || ''}`, 'Catalog');
-          }
+      // 2. Models fetched live from the provider Base URL
+      const prof = state.config?.profiles?.[compactSourceProfileKey];
+      if (Array.isArray(compactLoadedModels) && compactLoadedModels.length) {
+        for (const m of compactLoadedModels) {
+          const l = compactLoadedLimits[m];
+          const info = l?.context ? `${Math.round(l.context / 1000)}k context` : (prof?.name || 'Upstream');
+          add(m, m, info, 'Upstream Model');
         }
       }
 
-      // 5. Popular lightweight models
-      const popular = [
-        { id: 'zencore/muse-spark-1.3-contributor-free', desc: 'ZenCore contributor fast model' },
-        { id: 'zencore/exo-free', desc: 'ZenCore free pool fast model' },
-        { id: 'claude-3-5-haiku-20241022', desc: 'Anthropic lightweight summarizer' },
-        { id: 'gpt-4o-mini', desc: 'OpenAI low-cost summarizer' },
-        { id: 'gemini-2.5-flash', desc: 'Google Gemini fast summarizer' }
-      ];
-      for (const p of popular) {
-        add(p.id, p.id, p.desc, 'Recommended');
-      }
-
       return items;
     }
 
@@ -3030,13 +3035,13 @@
       const filtered = allItems.filter(item => {
         if (!q) return true;
         if (item.id === '' && ('deterministic'.includes(q) || 'none'.includes(q) || 'empty'.includes(q) || 'heuristic'.includes(q))) return true;
-        return item.id.toLowerCase().includes(q) || item.label.toLowerCase().includes(q) || item.desc.toLowerCase().includes(q);
+        return item.id.toLowerCase().includes(q) || item.label.toLowerCase().includes(q);
       }).slice(0, 150);
 
       combo.matches = filtered.map(item => item.id);
 
       if (!filtered.length) {
-        list.innerHTML = '<li class="combo-empty">No matching model found. The typed model will be used directly.</li>';
+        list.innerHTML = '<li class="combo-empty">No matching model found. The typed model ID will be used directly.</li>';
         return;
       }
 
@@ -3048,8 +3053,7 @@
         const isSelected = item.id === current;
         let badgeClass = 'badge outline';
         if (item.category === 'Deterministic') badgeClass = 'badge ok';
-        else if (item.category === 'Slot Aliases') badgeClass = 'badge accent';
-        else if (item.category === 'Profile Models') badgeClass = 'badge';
+        else if (item.category === 'Upstream Model') badgeClass = 'badge';
 
         const cut = item.id.lastIndexOf('/') + 1;
         const prefix = cut ? `<span class="pfx">${markMatch(item.id.slice(0, cut), q)}</span>` : '';
@@ -3098,7 +3102,6 @@
       updateWindowNotes();
       if (input.id === 'idle-compact-model') {
         saveIdleCompact();
-        updateCompactModelPresets(model);
       }
     }