@chatpanel/gateway 0.6.69 → 0.6.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.69",
+  "version": "0.6.71",
   "description": "Local privacy gateway \u2014 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/bridge.js

@@ -17,6 +17,47 @@ import os from 'node:os';
 
 const DEFAULT_TOKEN_PATH = join(os.homedir(), '.chatpanel', 'bridge-token');
 
+export const DEFAULT_BRIDGE_URL = 'http://127.0.0.1:4319';
+const BRIDGE_PROBE_TTL_MS = 10_000;
+let bridgeResolved = { at: 0, cfgUrl: '', url: '', fell: false };
+
+async function bridgeAnswers(url, timeoutMs) {
+  try {
+    const r = await fetch(`${url}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    return r.ok;
+  } catch { return false; }
+}
+
+/**
+ * Where the bridge is, checked rather than believed.
+ *
+ * The persisted bridge.url was found pointing at an ephemeral port nothing answered on,
+ * while the real bridge sat on 4319: every agent showed unavailable, every agent turn failed,
+ * and the startup line said so in a log nobody was reading. A configured address that does
+ * not answer while the default one does is a stale setting, not a decision, so the default
+ * is used and the fall-back is logged. Probed at most every ten seconds.
+ */
+export async function resolveBridgeUrl(cfg, { fallback, timeoutMs = 1500, now = Date.now() } = {}) {
+  // CHATPANEL_BRIDGE_FALLBACK=off disables the fallback: the test suite sets it, because a
+  // test whose fake bridge has gone away would otherwise find the developer's REAL bridge on
+  // 4319 and send its turns to a live coding agent.
+  if (fallback === undefined) fallback = process.env.CHATPANEL_BRIDGE_FALLBACK === 'off' ? '' : DEFAULT_BRIDGE_URL;
+  const cfgUrl = String(cfg?.bridge?.url || '').replace(/\/$/, '');
+  if (bridgeResolved.url && bridgeResolved.cfgUrl === cfgUrl && now - bridgeResolved.at < BRIDGE_PROBE_TTL_MS) return bridgeResolved.url;
+  let url = cfgUrl || fallback;
+  let fell = false;
+  if (fallback && url !== fallback && !(await bridgeAnswers(url, timeoutMs)) && await bridgeAnswers(fallback, timeoutMs)) {
+    url = fallback;
+    fell = true;
+    if (!bridgeResolved.fell || bridgeResolved.cfgUrl !== cfgUrl) console.log(`[gateway] bridge.url ${cfgUrl} is not answering; the bridge on ${fallback} is — using it (fix the address in Settings to silence this)`);
+  }
+  bridgeResolved = { at: now, cfgUrl, url, fell };
+  return url;
+}
+
+/** Test seam. */
+export function resetBridgeResolution() { bridgeResolved = { at: 0, cfgUrl: '', url: '', fell: false }; }
+
 export function readBridgeToken(cfgToken, tokenPath = DEFAULT_TOKEN_PATH) {
   if (cfgToken) return cfgToken;
   try {

package/src/configstore.js

@@ -83,6 +83,21 @@ export function applyNerModelSelection(cfg, id) {
 }
 
 // Merge an editable patch into the live cfg. Only known fields; ignores the rest.
+/**
+ * Is this API destination the gateway itself? A loop: a turn routed there comes straight
+ * back in. It arrived once from a backup import — the extension keeps the gateway in its own
+ * endpoint list, and the desktop copied that list into the gateway's destinations — and its
+ * model ids (the agents') then shadowed the real agents. Refused at the door, with a log line.
+ */
+export function isSelfDestination(d, cfg = {}) {
+  if (!d || d.type !== 'api') return false;
+  let u;
+  try { u = new URL(String(d.baseUrl || '')); } catch { return false; }
+  const loop = /^(127\.0\.0\.1|localhost|\[::1\]|0\.0\.0\.0)$/i.test(u.hostname);
+  const port = Number(u.port) || (u.protocol === 'https:' ? 443 : 80);
+  return loop && port === (Number(cfg.port) || 4320);
+}
+
 export function applyConfigPatch(cfg, patch = {}) {
   if (patch.backend === 'bridge' || patch.backend === 'api') cfg.backend = patch.backend;
   if (Array.isArray(patch.destinations)) {
@@ -91,6 +106,7 @@ export function applyConfigPatch(cfg, patch = {}) {
     const prev = new Map((Array.isArray(cfg.destinations) ? cfg.destinations : []).map((d) => [d.id, d]));
     cfg.destinations = patch.destinations
       .filter((d) => d && typeof d.id === 'string' && (d.type === 'agent' || d.type === 'api'))
+      .filter((d) => { const self = isSelfDestination(d, cfg); if (self) console.log(`[gateway] refusing destination "${d.id}": ${d.baseUrl} is this gateway — a loop`); return !self; })
       .map((d) => {
         const out = { id: d.id, type: d.type, models: Array.isArray(d.models) ? d.models.filter((m) => typeof m === 'string' && m) : [] };
         if (d.type === 'agent') out.agent = d.agent || d.id;

package/src/router.js

@@ -12,7 +12,7 @@
 //   }
 
 import { secureFetch } from './secure-fetch.js';
-import { readBridgeToken } from './bridge.js';
+import { readBridgeToken, resolveBridgeUrl } from './bridge.js';
 //
 // /v1/models aggregates every destination's models so clients can discover them.
 
@@ -29,10 +29,15 @@ const KNOWN_AGENTS = ['codex', 'claude', 'opencode', 'pi', 'kiro', 'antigravity'
 export function listDestinations(cfg) {
   const configured = (Array.isArray(cfg.destinations) ? cfg.destinations : []).filter(Boolean);
   const haveId = new Set(configured.map((d) => d.id));
-  const out = [...configured];
-  for (const a of KNOWN_AGENTS) {
-    if (!haveId.has(a)) out.push({ id: a, type: 'agent', agent: a, models: [a] });
-  }
+  // AGENTS FIRST. The model list de-duplicates by id in this order, and resolveDestination
+  // takes the first destination that serves a model — so an API destination that happened to
+  // list "codex" or "claude" (a gateway pointed at itself did exactly that) used to swallow
+  // the agents: they vanished from the picker and a turn for one was proxied to the loop.
+  const out = [
+    ...configured.filter((d) => d.type === 'agent'),
+    ...KNOWN_AGENTS.filter((a) => !haveId.has(a)).map((a) => ({ id: a, type: 'agent', agent: a, models: [a] })),
+    ...configured.filter((d) => d.type !== 'agent'),
+  ];
   if (cfg.backend === 'api' && !configured.some((d) => d.type === 'api')) {
     out.push({ id: 'openai', type: 'api', protocol: 'openai', baseUrl: cfg.upstreams?.openai?.baseUrl, models: [] });
     out.push({ id: 'anthropic', type: 'api', protocol: 'anthropic', baseUrl: cfg.upstreams?.anthropic?.baseUrl, models: [] });
@@ -156,7 +161,7 @@ export function aggregateModels(cfg) {
  * spends a subprocess per agent to describe something unusable.
  */
 async function bridgeAgentModels(cfg, installed, timeoutMs) {
-  const base = String(cfg?.bridge?.url || '').replace(/\/$/, '');
+  const base = await resolveBridgeUrl(cfg);
   if (!base || !installed) return new Map();
   const token = readBridgeToken(cfg.bridge?.token);
   const ids = [...installed.entries()].filter(([, ok]) => ok).map(([id]) => id);
@@ -183,7 +188,7 @@ async function bridgeAgentModels(cfg, installed, timeoutMs) {
 
 /** 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(/\/$/, '');
+  const base = await resolveBridgeUrl(cfg);
   if (!base) return null;
   try {
     const token = readBridgeToken(cfg.bridge?.token);

package/src/server.js

@@ -24,6 +24,7 @@ import { redactSegments, segment } from './redact.js';
 import { pipeRestoredStream, pipeRestoredOpenAIStream, makeTokenRestorer, restoreDeep } from './stream.js';
 import { restoreText, gatedDictionary, narrowSpecs, makeToolHarness, placeholderToolNote, assertEndpointUrl } from '@chatpanel/pii';
 import { ensureGatewayToken, isAdminAuthorized } from './gateway-token.js';
+import { resolveBridgeUrl } from './bridge.js';
 import { secureFetch } from './secure-fetch.js';
 import { streamBridgeChat, readBridgeToken, openBridgeChat } from './bridge.js';
 import { createRelaySession, getRelaySession, endRelaySession, pumpBridgeStream, deliverToolResult, toolsToSpecs, parseToolCallId } from './toolrelay.js';
@@ -55,7 +56,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.69';
+export const VERSION = '0.6.71';
 
 // 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.
@@ -356,13 +357,14 @@ async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg,
   // Full tier for everyone here (the free allowance is enforced in the main
   // handler), but the custom dictionary stays capped for free.
   const redactOpts = { tier: cfg.redaction.tier === 'full' ? 'full' : 'basic', dictionary: gatedDictionary(cfg.redaction, isPro), entities: [] };
-  const s = createRelaySession({ vault, redactOpts, bridgeUrl: cfg.bridge.url, token, harness });
+  const bridgeUrl = await resolveBridgeUrl(cfg);
+  const s = createRelaySession({ vault, redactOpts, bridgeUrl, token, harness });
   const ttl = setTimeout(() => endRelaySession(s.id), 135_000); // bridge tool-call timeout is 120s
   // The placeholder note is already in `system` (injected into the body after
   // redaction in the main handler), so toTurn() carried it here — nothing to add.
   let resp;
   try {
-    resp = await openBridgeChat({ bridgeUrl: cfg.bridge.url, agent, token, messages, system, specs: toolsToSpecs(tools), options: {}, signal: undefined });
+    resp = await openBridgeChat({ bridgeUrl, agent, token, messages, system, specs: toolsToSpecs(tools), options: {}, signal: undefined });
   } catch (e) { clearTimeout(ttl); endRelaySession(s.id); trace?.commit(); return sendJson(res, 502, { error: { message: `bridge: ${e.message}`, type: 'bridge_error' } }); }
   s.reader = resp.body.getReader();
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
@@ -420,7 +422,7 @@ async function handleBridge(req, res, { kind, adapter, redactable, pathname, age
   // 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,
+    bridgeUrl: await resolveBridgeUrl(cfg), agent, token, messages, system, signal: ac.signal,
     ...(agentModel ? { options: { model: agentModel } } : {}),
   };
 
@@ -1541,7 +1543,7 @@ export function createGateway(cfg = loadConfig()) {
     // modes for one screen; and the direct-to-bridge path is the one with no policy in front
     // of it, so making it necessary for a feature is how it becomes the habit.
     if (req.method === 'GET' && pathname === '/skills') {
-      const base = String(cfg.bridge?.url || '').replace(/\/$/, '');
+      const base = await resolveBridgeUrl(cfg);
       if (!base) return sendJson(res, 503, { error: { message: 'no bridge is configured', type: 'no_bridge' } });
       const token = readBridgeToken(cfg.bridge?.token);
       try {
@@ -1572,7 +1574,7 @@ export function createGateway(cfg = loadConfig()) {
       if (!id || id === '.' || id === '..' || id.includes('/') || id.includes('\\')) {
         return sendJson(res, 400, { error: { message: 'not a skill id', type: 'invalid_request' } });
       }
-      const base = String(cfg.bridge?.url || '').replace(/\/$/, '');
+      const base = await resolveBridgeUrl(cfg);
       if (!base) return sendJson(res, 503, { error: { message: 'no bridge is configured', type: 'no_bridge' } });
       const token = readBridgeToken(cfg.bridge?.token);
       try {

package/src/stt-engine.js

@@ -422,6 +422,18 @@ async function decodeSession(s, { flush = false } = {}) {
   const tooLong = audio.length >= MAX_SEGMENT_S * SAMPLE_RATE;
   const overflow = audio.length >= MAX_BUFFER_S * SAMPLE_RATE;
   if (flush || trailingQuiet || tooLong || overflow) {
+    // WHY THIS SEGMENT WAS COMMITTED — and it is not always because the speaker finished.
+    //
+    // Four situations produced an identical `final`, and a client could not tell them apart:
+    // the session ending and a trailing pause are the end of a TURN; the length and buffer
+    // caps are this engine cutting a segment it cannot hold any longer, mid-sentence, while
+    // the speaker is still going. In dictation the difference does not matter — either way
+    // the text is appended. In a voice CONVERSATION every final is SENT, so a long sentence
+    // was cut at twelve seconds and half of it asked as a question:
+    //   "…you should just continuously listen to it and then" → sent, answered, lost.
+    // Both fields are ADDITIVE: an older client ignores them and behaves exactly as before.
+    const reason = flush ? 'flush' : trailingQuiet ? 'silence' : overflow ? 'overflow' : 'length';
+    const endOfTurn = reason === 'flush' || reason === 'silence';
     // Commit: the open segment becomes a final; the buffer restarts empty.
     s.chunks = []; s.samples = 0; s.lastInterim = '';
     // Diarize this committed segment (opt-in): embed its audio, cluster → speaker.
@@ -433,7 +445,7 @@ async function decodeSession(s, { flush = false } = {}) {
         speaker = s.diarizer.assign(vec, { pinnedLabel: s.speakerLabel });
       } catch { /* diarization is additive — a failure never drops the transcript */ }
     }
-    emit(s, speaker ? { type: 'final', text, speaker } : { type: 'final', text });
+    emit(s, { type: 'final', text, reason, endOfTurn, ...(speaker ? { speaker } : {}) });
   } else if (text !== s.lastInterim) {
     s.lastInterim = text;
     emit(s, { type: 'interim', text });