@chatpanel/gateway 0.6.64 → 0.6.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.64",
+  "version": "0.6.65",
   "description": "Local privacy gateway — redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/router.js

@@ -112,6 +112,44 @@ export function aggregateModels(cfg) {
   return { object: 'list', data };
 }
 
+/**
+ * The models each installed agent can be asked for.
+ *
+ * A CLI agent is not one model — Claude Code takes opus/sonnet/haiku, others enumerate their
+ * own — and listing only the agent id meant a user picked `claude` and got whatever default
+ * the CLI had. When that default is newer than the installed CLI, the answer is a version
+ * error about a model the user never chose.
+ *
+ * Asked of the bridge, which is the only thing that knows what each CLI supports, and only
+ * for agents that are actually INSTALLED: enumerating models for a CLI that is not there
+ * spends a subprocess per agent to describe something unusable.
+ */
+async function bridgeAgentModels(cfg, installed, timeoutMs) {
+  const base = String(cfg?.bridge?.url || '').replace(/\/$/, '');
+  if (!base || !installed) return new Map();
+  const token = readBridgeToken(cfg.bridge?.token);
+  const ids = [...installed.entries()].filter(([, ok]) => ok).map(([id]) => id);
+  const out = new Map();
+  await Promise.all(ids.map(async (id) => {
+    try {
+      const res = await fetch(`${base}/list-models`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+        body: JSON.stringify({ agent: id }),
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+      if (!res.ok) return;
+      const body = await res.json();
+      const models = (Array.isArray(body?.models) ? body.models : [])
+        .map((m) => (typeof m === 'string' ? m : m?.id || m?.name || ''))
+        .map((m) => String(m).trim())
+        .filter(Boolean);
+      if (models.length) out.set(id, models.slice(0, 40));
+    } catch { /* an agent that will not enumerate still works under its bare id */ }
+  }));
+  return out;
+}
+
 /** id → installed, from the bridge's own /health. `null` when it could not be asked. */
 async function bridgeAgentAvailability(cfg, timeoutMs) {
   const base = String(cfg?.bridge?.url || '').replace(/\/$/, '');
@@ -158,6 +196,27 @@ export async function aggregateModelsAsync(cfg, { timeoutMs = 4000 } = {}) {
     }
   }
 
+  // Each installed agent's own models, listed as `agent/model` beside the bare id. The bare
+  // id stays and still means "the agent's default", so nothing that already works breaks.
+  const agentModels = await bridgeAgentModels(cfg, agentAvailability, timeoutMs);
+  for (const [agent, models] of agentModels) {
+    const parent = base.data.find((m) => m.id === agent);
+    if (!parent) continue;
+    for (const model of models) {
+      const id = `${agent}/${model}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      base.data.push({
+        ...parent,
+        id,
+        // `model` is what the picker shows under the agent's heading; the agent stays the
+        // provider, so the grouping puts them together without any id parsing.
+        model,
+        available: true,
+      });
+    }
+  }
+
   const dests = listDestinations(cfg).filter((d) => d.type === 'api' && d.baseUrl);
   await Promise.all(dests.map(async (d) => {
     const ctrl = new AbortController();

package/src/server.js

@@ -55,7 +55,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.64';
+export const VERSION = '0.6.65';
 
 // WARM search tier — SQLite + FTS5 record store (falls back to an encrypted-JSON
 // store if SQLite can't load), fed by the extension's ingest sync + backup-ingest.
@@ -204,8 +204,31 @@ function route(pathname, headers, cfg) {
   return { kind: 'openai', adapter: openai, redactable: openai.matches(pathname), base: cfg.upstreams?.openai?.baseUrl };
 }
 
+/**
+ * An agent id, and the model to run it with.
+ *
+ * A CLI agent is not one model. Claude Code takes `opus`, `sonnet` or `haiku`; the others
+ * have their own lists. Picking `claude` alone leaves the CLI on whatever default it has,
+ * which is how a user gets "this version does not support that model" from a tool they never
+ * chose a model for. So `claude/opus` names both, and the slash is the only new syntax.
+ *
+ * A bare agent id still works and still means "the agent's own default" — every client that
+ * predates this keeps working, which is the whole reason the model is a SUFFIX rather than a
+ * change to the id.
+ */
+export function parseAgentModel(model, cfg) {
+  const raw = String(model || '');
+  if (KNOWN_AGENTS.has(raw)) return { agent: raw, agentModel: '' };
+  const slash = raw.indexOf('/');
+  if (slash > 0) {
+    const head = raw.slice(0, slash);
+    if (KNOWN_AGENTS.has(head)) return { agent: head, agentModel: raw.slice(slash + 1) };
+  }
+  return { agent: cfg.bridge.agent, agentModel: '' };
+}
+
 function pickAgent(model, cfg) {
-  return KNOWN_AGENTS.has(model) ? model : cfg.bridge.agent;
+  return parseAgentModel(model, cfg).agent;
 }
 
 // A follow-up request carrying a tool result for a PARKED relay session. Such a
@@ -393,7 +416,13 @@ async function handleBridge(req, res, { kind, adapter, redactable, pathname, age
   const ac = new AbortController();
   req.on('close', () => ac.abort());
 
-  const turn = { bridgeUrl: cfg.bridge.url, agent, token, messages, system, signal: ac.signal };
+  // The model half of `claude/opus`, handed to the CLI as its `--model`. Absent for a bare
+  // agent id, which leaves the agent on its own default exactly as before.
+  const { agentModel } = parseAgentModel(body?.model, cfg);
+  const turn = {
+    bridgeUrl: cfg.bridge.url, agent, token, messages, system, signal: ac.signal,
+    ...(agentModel ? { options: { model: agentModel } } : {}),
+  };
 
   if (!wantStream) {
     try {