@chatpanel/gateway 0.6.64 → 0.6.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.64",
+  "version": "0.6.66",
   "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

@@ -86,6 +86,32 @@ function apiShapeOf(d) {
   return { api: 'openai', endpoints: ['/v1/chat/completions', '/v1/responses'] };
 }
 
+/**
+ * CAN THIS DESTINATION ANSWER AT ALL — before anyone sends a turn to it.
+ *
+ * This list is a ROUTING TABLE. It names every model the gateway would forward to, and a
+ * provider that lists four hundred can be configured with no key at all — so the list is
+ * mostly names that cannot answer. A user picks one, and finds out at 08:00 when a scheduled
+ * job comes back `Missing Authentication header` or `upstream fetch failed`, quoting undici
+ * about a destination they never knowingly chose.
+ *
+ * Local endpoints are the exception that must NOT be marked unconfigured: llama.cpp, Ollama
+ * and LM Studio take no key, and greying them out would hide the one setup that needs
+ * nothing. So this asks only the question it can answer honestly — "is a credential
+ * required here, and is one saved" — and says nothing about whether the server is up.
+ *
+ * Returns `''` when there is nothing to report.
+ */
+const LOCAL_HOST = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0|[^/]*\.local)(:|\/|$)/i;
+function unconfiguredReason(d) {
+  if (!d || d.type === 'agent') return '';
+  const base = String(d.baseUrl || '');
+  if (!base) return 'no endpoint URL is set for this provider';
+  if (LOCAL_HOST.test(base)) return '';        // a local server needs no key
+  if (d.apiKey || d.hasKey) return '';
+  return `no API key is saved for ${d.id}`;
+}
+
 export function aggregateModels(cfg) {
   const data = [];
   const seen = new Set();
@@ -93,10 +119,15 @@ export function aggregateModels(cfg) {
     if (!id || seen.has(id)) return;
     seen.add(id);
     const shape = apiShapeOf(d);
+    const blocked = unconfiguredReason(d);
     data.push({
       id,
       object: 'model',
       owned_by: owner,
+      // `configured` is about SETUP, not liveness: false means a turn sent here is known to
+      // fail for a reason the user can fix in Settings. Absent liveness is deliberate — the
+      // gateway does not probe every provider to draw a list.
+      ...(blocked ? { configured: false, reason: blocked } : {}),
       // Additive fields an OpenAI client ignores and a ChatPanel client uses to decide how
       // to call, and to group a picker by provider instead of by a flat list of ids.
       provider: d.id,
@@ -112,6 +143,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 +227,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();
@@ -178,10 +268,12 @@ export async function aggregateModelsAsync(cfg, { timeoutMs = 4000 } = {}) {
         if (id && !seen.has(id)) {
           seen.add(id);
           const shape = apiShapeOf(d);
+          const blocked = unconfiguredReason(d);
           base.data.push({
             id, object: 'model', owned_by: d.id, provider: d.id,
             provider_type: d.protocol === 'anthropic' ? 'anthropic' : 'openai',
             api: shape.api, endpoints: shape.endpoints,
+            ...(blocked ? { configured: false, reason: blocked } : {}),
           });
         }
       }

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.66';
 
 // 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 {