@chatpanel/gateway 0.6.81 → 0.6.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.81",
+  "version": "0.6.83",
   "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/server.js

@@ -27,7 +27,7 @@ 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';
+import { createRelaySession, getRelaySession, endRelaySession, pumpBridgeStream, deliverToolResult, toolsToSpecs, parseToolCallId, touchRelaySession } from './toolrelay.js';
 import { shaperFor } from './shape.js';
 import { startNer, ensureNer } from './ner.js';
 import { installTimestampedConsole } from './log.js';
@@ -58,7 +58,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.81';
+export const VERSION = '0.6.83';
 
 // 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.
@@ -380,9 +380,9 @@ async function pumpRelay(res, s, shaper, trace) {
   let first = true;
   const tick = () => { if (trace && first) { trace.lap('upstream', t0); sStart = trace.clock(); first = false; } };
   await pumpBridgeStream(s, {
-    onText: (text) => { tick(); const r = restorer.push(text); if (r) res.write(shaper.sseDelta(r)); },
+    onText: (text) => { tick(); touchRelaySession(s.id); const r = restorer.push(text); if (r) res.write(shaper.sseDelta(r)); },
     onToolRequest: ({ name, restoredArgs, toolId }) => {
-      tick();
+      tick(); touchRelaySession(s.id);
       const tail = restorer.flush(); if (tail) res.write(shaper.sseDelta(tail));
       res.write(shaper.sseToolCalls([{ id: toolId, name, arguments: JSON.stringify(restoredArgs) }]));
       res.write(shaper.sseToolFinish());
@@ -403,14 +403,15 @@ async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg,
   // 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 bridgeUrl = await resolveBridgeUrl(cfg);
+  // The session's life is idle time, re-armed on every round (toolrelay.js) — not a flat
+  // clock from here, which ended every long tool-using turn at 135 s.
   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, agent, token, messages, system, specs: toolsToSpecs(tools), options: bridgeAgentOptions(cfg), signal: undefined });
-  } catch (e) { clearTimeout(ttl); endRelaySession(s.id); trace?.commit(); return sendJson(res, 502, { error: { message: `bridge: ${e.message}`, type: 'bridge_error' } }); }
+  } catch (e) { 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' });
   res.write(shaper.sseHead());
@@ -421,6 +422,7 @@ async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg,
 // The relay redacts the tool result with ITS vault (the main handler skips
 // redaction for a relay-resume), so time that here as the 'redact' leg.
 async function resumeRelay(res, s, toolContent, model, trace = null) {
+  touchRelaySession(s.id); s.rounds = (s.rounds || 0) + 1;
   try {
     const rd0 = trace ? trace.clock() : 0;
     await deliverToolResult(s, toolContent);

package/src/team-store.js

@@ -87,6 +87,9 @@ export function applyEvent(run, ev) {
       if (type === 'board.thread-status' && p.status !== 'waiting' && run.status === 'waiting' && !(run.threads.threads || []).some((t) => t.kind === 'ask' && t.status === 'waiting')) run.status = 'answered';
       break;
     case 'task.waiting': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) { t.status = 'waiting'; t.waitingOn = p.threadId; } break; }
+    case 'task.model': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.model = p.model; break; }
+    case 'task.tool': { const t = run.tasks.find((x) => x.id === p.taskId); if (t) t.tools = (t.tools || 0) + 1; break; }
+    case 'run.usage': run.usage = p.usage || run.usage; break;
     case 'run.waiting': run.status = 'running'; break;
     case 'run.resumed': run.status = 'running'; run.endedAt = null; run.checkpoint = null; break;
     default: break;

package/src/toolrelay.js

@@ -35,15 +35,32 @@ export function toolsToSpecs(tools) {
     .map((t) => ({ name: t.function.name, description: t.function.description || '', parameters: t.function.parameters || { type: 'object', properties: {} } }));
 }
 
-export function createRelaySession({ vault, redactOpts, bridgeUrl, token, harness = null }) {
+// A parked session lives while something is happening on it. The limit is IDLE time —
+// re-armed on every tool result the client brings back and every chunk the agent sends —
+// not time since the turn began: a flat 135 s from the start killed every relayed turn
+// with more than a handful of tool rounds, at 135.1 s exactly, and the client read the
+// empty resume as "the model returned no answer". A team member's turn is many rounds.
+export const RELAY_IDLE_MS = 135_000; // the bridge's own tool-call timeout is 120 s
+
+export function createRelaySession({ vault, redactOpts, bridgeUrl, token, harness = null, idleMs = RELAY_IDLE_MS }) {
   const id = randomUUID().slice(0, 8);
-  const s = { id, reader: null, decoder: new TextDecoder(), buf: '', bridgeSessionId: null, toolId: null, vault: vault || createVault(), redactOpts: redactOpts || { tier: 'basic' }, bridgeUrl, token, harness, done: false };
+  const s = { id, reader: null, decoder: new TextDecoder(), buf: '', bridgeSessionId: null, toolId: null, vault: vault || createVault(), redactOpts: redactOpts || { tier: 'basic' }, bridgeUrl, token, harness, done: false, idleMs, ttl: null, startedAt: Date.now(), rounds: 0 };
   sessions.set(id, s);
+  touchRelaySession(id);
   return s;
 }
 export const getRelaySession = (id) => sessions.get(id);
+/** Something happened on the session: the idle clock starts over. */
+export function touchRelaySession(id) {
+  const s = sessions.get(id);
+  if (!s) return;
+  if (s.ttl) clearTimeout(s.ttl);
+  s.ttl = setTimeout(() => endRelaySession(id), s.idleMs);
+  if (typeof s.ttl.unref === 'function') s.ttl.unref();
+}
 export function endRelaySession(id) {
   const s = sessions.get(id);
+  if (s?.ttl) clearTimeout(s.ttl);
   if (s?.reader) { try { s.reader.cancel(); } catch { /* ignore */ } }
   sessions.delete(id);
 }