@chatpanel/bridge 0.11.5 → 0.11.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.11.5",
+  "version": "0.11.7",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine \u2014 Claude Code (CLI), Codex (CLI), and Antigravity CLI (formerly Gemini CLI, which remains available for business/enterprise) \u2014 to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/src/channels/adapters/telegram.js

@@ -38,6 +38,29 @@ const HELP = [
  * it needs is injected — a bot token, the bridge address+token, a pairing store, an event sink
  * — so nothing here reads a secret or reaches for global state.
  */
+// What a turn driven from a phone can actually DO, told to the agent up front.
+//
+// Without this the agent plans as if it were sitting at a terminal: asked to create a note it
+// announced it would look for a notes folder, discovered writes were not enabled, said "let me
+// check what notes tools are available" — and stopped mid-thought, having done nothing and
+// explained nothing. The ceiling is real and enforced elsewhere (reach caps the toolset); the
+// agent simply had no way to know about it, so it spent a turn discovering it and left the
+// user staring at half a sentence.
+export function channelSystem(userSystem, reach) {
+  const limits = !reach || reach === 'any' ? '' : [
+    "You are answering a message sent from the user's PHONE, relayed to this machine.",
+    reach === 'device'
+      ? 'You cannot read files, run commands, browse the web, or change anything.'
+      : "You can READ files and search the user's ChatPanel history. You cannot write or edit "
+        + 'files, run shell commands, or browse the web — those are switched off for messages '
+        + 'from a phone, and no tool will grant them.',
+    'If a request needs something you cannot do, say so plainly in your FIRST reply and offer '
+      + 'what you can do instead. Never begin work you cannot finish.',
+    'Answers are read on a phone: be brief, and put the answer first.',
+  ].join(' ');
+  return [limits, userSystem].filter(Boolean).join('\n\n');
+}
+
 export function startTelegram({
   botToken,
   baseUrl,
@@ -52,7 +75,17 @@ export function startTelegram({
   // which it has: both expose chat()/cancel() and fold into one reply state.
   transport = bridge,
   model = '',
+  provider = '',
   system = '',
+  // Read at the START OF EACH MESSAGE rather than captured when the loop starts.
+  //
+  // `chats` below holds every conversation's history AND its privacy vault, and it lives only
+  // as long as this loop. Settings used to be baked in at start, so changing the model — or
+  // the privacy mode, or anything else — had to stop and respawn the loop, which silently threw
+  // all of that away: the next message arrived as "a fresh session with no prior conversation",
+  // and PERSON_1 stopped meaning the same person. Switching which model answers is not a
+  // reason to forget what you were talking about.
+  route = null,
   redact = { tier: 'basic' },
   privacy = 'standard',
   logger = console,
@@ -119,7 +152,7 @@ export function startTelegram({
     }
     if (name === 'stop') {
       const st = chatState(norm.chatId);
-      const ok = await transport.cancel(st.runId, { baseUrl, token });
+      const ok = await ((route && route().transport) || transport).cancel(st.runId, { baseUrl, token });
       st.runId = null;
       return void send(norm.chatId, ok ? '⏹ stopped.' : 'nothing running.');
     }
@@ -156,11 +189,22 @@ export function startTelegram({
     // on the bridge renders all-but-last as history and the last as "answer this now".
     const messages = [...st.history, { role: 'user', content: redacted }];
 
+    // Whatever the settings say RIGHT NOW — see `route` above.
+    const live = (route && route()) || {};
+    const useTransport = live.transport || transport;
     try {
-      const finalState = await transport.chat(
-        { agent, model, system, messages, images, options: { reach } },
+      const finalState = await useTransport.chat(
+        {
+          agent: live.agent ?? agent,
+          model: live.model ?? model,
+          provider: live.provider ?? provider,
+          system: channelSystem(live.system ?? system, reach),
+          messages,
+          images,
+          options: { reach },
+        },
         {
-          baseUrl, token, signal,
+          baseUrl: live.baseUrl || baseUrl, token, signal,
           onEvent: (ev, state) => {
             if (state.runId) st.runId = state.runId;
             // Driven by the folded STATE, not by an event's `type`: the bridge emits

package/src/channels/gateway.js

@@ -40,7 +40,7 @@ const inflight = new Map();
  * not know which transport it has: streams events to onEvent(ev, state) and returns the folded
  * final state.
  */
-export async function chat({ model = '', system = '', messages = [], options = {} }, {
+export async function chat({ model = '', provider = '', system = '', messages = [], options = {} }, {
   baseUrl, signal, onEvent = () => {},
 } = {}) {
   const runId = `gw_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
@@ -57,7 +57,18 @@ export async function chat({ model = '', system = '', messages = [], options = {
   try {
     const res = await fetch(`${String(baseUrl).replace(/\/$/, '')}/v1/chat/completions`, {
       method: 'POST',
-      headers: { 'content-type': 'application/json' },
+      headers: {
+        'content-type': 'application/json',
+        // ChatPanel's routing metadata goes in HEADERS, never in the request body. It rode the
+        // body first and NVIDIA answered "unsupported parameters": OpenAI-compatible providers
+        // validate the body strictly and reject unknown fields, while ignoring unknown headers.
+        // The gateway strips x-chatpanel-* before forwarding, so the provider never sees it.
+        ...(options?.reach ? { 'x-chatpanel-reach': options.reach } : {}),
+        // WHICH provider, not just which model. A model id is not a unique key — two providers
+        // can serve the same one — so without this the gateway picks whichever destination it
+        // lists first and the call goes out on a key the user never chose.
+        ...(provider ? { 'x-chatpanel-destination': provider } : {}),
+      },
       body: JSON.stringify({
         model,
         stream: true,
@@ -65,9 +76,6 @@ export async function chat({ model = '', system = '', messages = [], options = {
           ...(system ? [{ role: 'system', content: system }] : []),
           ...messages.map((m) => ({ role: m.role, content: String(m.content ?? '') })),
         ],
-        // Carried through so a capped phone's reach still reaches the router. The gateway
-        // ignores what it does not know, which is what keeps an older gateway working.
-        ...(options?.reach ? { chatpanel: { reach: options.reach } } : {}),
       }),
       signal: ac.signal,
     });

package/src/channels/service.js

@@ -41,7 +41,8 @@ const TELEGRAM_API = 'https://api.telegram.org';
 // its own bridge backend, the same agents. They are mutually exclusive: update() clears one
 // when the other is set, because "which thing answers" is one choice, not two.
 export const DEFAULT_SETTINGS = Object.freeze({
-  agent: 'claude', model: '', gatewayUrl: DEFAULT_GATEWAY_URL, privacy: 'standard', tier: 'basic',
+  agent: 'claude', model: '', provider: '', gatewayUrl: DEFAULT_GATEWAY_URL,
+  privacy: 'standard', tier: 'basic',
 });
 
 // Restart backoff. A long-poll that dies (network drop, laptop asleep, Telegram hiccup) must
@@ -131,13 +132,28 @@ export function createChannelService({
   function spawnLoop(botToken) {
     controller = new AbortController();
     running = true;
-    // One choice, resolved here so the adapter never has to ask "which kind am I?".
-    const viaGateway = !!settings.model;
+    // Resolved PER MESSAGE, not once at start. The loop owns every conversation's history and
+    // privacy vault, so restarting it to pick up a settings change threw away the thing the
+    // user came for. Now nothing needs a restart: the next message simply reads this.
+    const route = () => {
+      const viaGateway = !!settings.model;
+      return {
+        transport: viaGateway ? gateway : bridgeTransport,
+        agent: viaGateway ? '' : settings.agent,
+        model: viaGateway ? settings.model : '',
+        provider: viaGateway ? (settings.provider || '') : '',
+        baseUrl: viaGateway ? (settings.gatewayUrl || DEFAULT_GATEWAY_URL) : bridge.baseUrl,
+        system: settings.system || '',
+        privacy: settings.privacy,
+      };
+    };
     const done = startAdapter({
       botToken,
-      transport: viaGateway ? gateway : bridgeTransport,
-      model: viaGateway ? settings.model : '',
-      baseUrl: viaGateway ? (settings.gatewayUrl || DEFAULT_GATEWAY_URL) : bridge.baseUrl,
+      route,
+      transport: route().transport,
+      model: route().model,
+      provider: route().provider,
+      baseUrl: route().baseUrl,
       token: bridge.token,
       pairing,
       savePairing,
@@ -247,17 +263,19 @@ export function createChannelService({
     async update(patch = {}) {
       await load();
       const next = { ...settings };
-          for (const k of ['agent', 'model', 'gatewayUrl', 'privacy', 'tier', 'system']) {
+          for (const k of ['agent', 'model', 'provider', 'gatewayUrl', 'privacy', 'tier', 'system']) {
         if (patch[k] != null) next[k] = patch[k];
       }
       // Picking one target unpicks the other. Without this a stale `model` would silently win
       // over the agent the user just chose, and the screen would disagree with the machine.
-      if (patch.agent != null && patch.model == null) next.model = '';
+      if (patch.agent != null && patch.model == null) { next.model = ''; next.provider = ''; }
       if (patch.model) next.agent = '';
       settings = next;
       await saveSettings();
-      // Settings are read when the loop starts, so a change only lands on a restart.
-      if (running) { await this.stop(); await start(); }
+      // NO RESTART. The loop reads settings per message through `route`, and restarting it
+      // would discard every conversation's history and vault — which is exactly what made
+      // changing the model answer the next question with "this looks like a fresh session".
+      // The only change that still needs a restart is a new bot token, and connect() does that.
       return { settings: { ...settings } };
     },
 
@@ -297,6 +315,7 @@ export function createChannelService({
         settings: {
           agent: settings.agent,
           model: settings.model || '',
+          provider: settings.provider || '',
           gatewayUrl: settings.gatewayUrl || DEFAULT_GATEWAY_URL,
           privacy: settings.privacy,
           tier: settings.tier,

package/src/server.js

@@ -67,7 +67,7 @@ import {
 // Hardcoded (not read from package.json) so it survives Bun's single-file
 // --compile, where package.json isn't on a readable FS. CI fails the publish if
 // this drifts from package.json, so the two can't silently diverge.
-const VERSION = '0.11.5';
+const VERSION = '0.11.7';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;