bloby-bot 0.48.3 → 0.49.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.48.3",
+  "version": "0.49.1",
   "releaseNotes": [
     "1. Something great..",
     "2. ",

package/supervisor/app-ws.js

@@ -16,6 +16,25 @@
   var intentionalClose = false;
   var originalFetch = window.fetch;
 
+  // Chat pub/sub state — bot:* / chat:* events forwarded from the supervisor's chat
+  // broadcaster. Listeners are independent of WS lifecycle: when the WS reconnects we
+  // re-send the subscribe message automatically.
+  var chatListeners = [];
+  var chatSubscribed = false;
+  var chatClientId = null;
+
+  function emitChatEvent(eventType, data) {
+    for (var i = 0; i < chatListeners.length; i++) {
+      try { chatListeners[i](eventType, data); } catch (err) { console.error('[app-ws] chat listener error', err); }
+    }
+  }
+
+  function sendChatSubscribe() {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify({ type: 'chat:subscribe', data: { clientId: chatClientId } }));
+    console.log('[app-ws] chat:subscribe sent clientId=' + chatClientId);
+  }
+
   function buildWsUrl() {
     var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
     return proto + '//' + location.host + '/app/ws';
@@ -56,6 +75,7 @@
       reconnectDelay = RECONNECT_BASE;
       startHeartbeat();
       console.log('[app-ws] Connected to /app/ws');
+      if (chatSubscribed) sendChatSubscribe();
     };
 
     ws.onmessage = function (e) {
@@ -68,6 +88,16 @@
         return;
       }
 
+      if (msg.type === 'chat:event' && msg.data) {
+        emitChatEvent(msg.data.eventType, msg.data.eventData);
+        return;
+      }
+
+      if (msg.type === 'chat:subscribed') {
+        console.log('[app-ws] chat:subscribed ack clientId=' + (msg.data && msg.data.clientId));
+        return;
+      }
+
       if (msg.type === 'app:api:response' && msg.data && msg.data.id) {
         var pending = pendingRequests[msg.data.id];
         if (pending) {
@@ -194,6 +224,29 @@
     connected: function () {
       return connected;
     },
+    // Subscribe to chat events (bot:typing, bot:token, bot:response, chat:sync, …).
+    // Returns an unsubscribe function. Multiple listeners are supported. The underlying
+    // subscribe message is sent on first listener registration and re-sent on reconnect.
+    onChatEvent: function (handler) {
+      chatListeners.push(handler);
+      if (!chatSubscribed) {
+        chatSubscribed = true;
+        chatClientId =
+          (typeof crypto !== 'undefined' && crypto.randomUUID)
+            ? crypto.randomUUID()
+            : 'ws-' + Math.random().toString(36).slice(2);
+        if (ws && ws.readyState === WebSocket.OPEN) sendChatSubscribe();
+      }
+      return function unsubscribe() {
+        var i = chatListeners.indexOf(handler);
+        if (i >= 0) chatListeners.splice(i, 1);
+      };
+    },
+    // Stable per-tab clientId used to identify this subscriber to the server. Useful
+    // when calling /api/agent/chat/message so the server can skip echoing chat:sync back.
+    clientId: function () {
+      return chatClientId;
+    },
   };
 
   connect();

package/supervisor/channels/manager.ts

@@ -85,6 +85,15 @@ export interface WaStreamState {
   chunkBuf: string;
 }
 
+/** Agent-turn events that carry per-turn content. Broadcast only for dashboard surfaces
+ *  ('workspace' / 'chat'); suppressed for WhatsApp/Alexa turns so their replies don't
+ *  bleed into the chat-bubble UI. Non-turn events (bot:idle, bot:error, channel:*) are
+ *  always broadcast. */
+const CHAT_TURN_EVENTS = new Set([
+  'bot:token', 'bot:response', 'bot:tool',
+  'bot:task-created', 'bot:task-progress', 'bot:task-done',
+]);
+
 export class ChannelManager {
   private providers = new Map<ChannelType, ChannelProvider>();
   private opts: ChannelManagerOpts;
@@ -377,7 +386,7 @@ export class ChannelManager {
       q = [];
       this.routingQueues.set(convId, q);
     }
-    q.push(target);
+    q.push({ ...target, pushedAt: Date.now() });
     pushMessage(convId, content, attachments, savedFiles);
   }
 
@@ -395,9 +404,18 @@ export class ChannelManager {
     if (!q || q.length === 0) return undefined;
     const target = q.shift();
     if (q.length === 0) this.routingQueues.delete(convId);
+    if (target?.pushedAt && Date.now() - target.pushedAt > 30_000) {
+      log.warn(`[channels] Stale route popped: surface=${target.surface}, age=${Math.round((Date.now() - target.pushedAt) / 1000)}s, to=${target.waSendTo || 'none'}, queueDepth=${q?.length ?? 0}`);
+    }
     return target;
   }
 
+  /** Return the surface of the current turn's routing target without consuming it.
+   *  Used by broadcast guards to suppress chat-bubble events for non-dashboard turns. */
+  peekCurrentSurface(convId: string): RoutingTarget['surface'] | undefined {
+    return this.routingQueues.get(convId)?.[0]?.surface;
+  }
+
   /** Drop all pending routes for a conversation — used when the live conversation ends.
    *  Accepts undefined for ergonomics in callers that hold a possibly-undefined convId. */
   clearRoutes(convId: string | undefined): void {
@@ -883,8 +901,9 @@ export class ChannelManager {
           return;
         }
 
-        // Mirror streaming + task events to chat clients
-        broadcastBloby(type, eventData);
+        // Mirror non-turn events (bot:idle, bot:error, channel:*) to chat clients.
+        // Turn events (tokens, response, tools) go to WhatsApp only via the routing FIFO.
+        if (!CHAT_TURN_EVENTS.has(type)) broadcastBloby(type, eventData);
       }, { botName, humanName }, recentMessages);
     }
 
@@ -1006,7 +1025,8 @@ export class ChannelManager {
           return;
         }
 
-        broadcastBloby(type, eventData);
+        // Turn events go to Alexa only via the routing FIFO; suppress from chat-bubble.
+        if (!CHAT_TURN_EVENTS.has(type)) broadcastBloby(type, eventData);
       }, { botName, humanName }, recentMessages);
     }
 

package/supervisor/channels/types.ts

@@ -86,6 +86,8 @@ export interface RoutingTarget {
   assistantBufferKey?: string;
   /** Original inbound WA message key — kept opaque here, used by the channel to react/quote. */
   inboundKey?: unknown;
+  /** Unix ms when this target was pushed — used to detect stale queue entries. */
+  pushedAt?: number;
 }
 
 export interface ChannelProvider {

package/supervisor/chat/src/hooks/useBlobyChat.ts

@@ -197,6 +197,7 @@ export function useBlobyChat(ws: WsClient | null, triggerReload?: number, enable
         });
       }),
       ws.on('bot:response', (data: { conversationId: string; messageId?: string; content: string }) => {
+        if (conversationIdRef.current && data.conversationId !== conversationIdRef.current) return;
         setConversationId(data.conversationId);
 
         // Strip text that was already committed as a partial message

package/supervisor/index.ts

@@ -1451,10 +1451,13 @@ mint();
             const ownPhone = waStatus?.connected ? (waStatus.info?.phoneNumber as string | undefined) : undefined;
             const waMirrorTo = ownPhone ? `${ownPhone}@s.whatsapp.net` : undefined;
 
+            // Channel tag so the agent knows the message came from the dashboard workspace
+            // (parallel to [WhatsApp ...] and [Alexa ...] tags). DB + chat:sync use the raw
+            // content so user-facing UIs show what was typed.
             channelManager.pushWithRouting(
               convId,
               { surface: 'workspace', waSendTo: waMirrorTo, isSelfChat: true },
-              content,
+              `[workspace]\n${content}`,
               agentAttachments,
               savedFiles,
             );
@@ -1660,6 +1663,12 @@ mint();
   appWss.on('connection', (ws) => {
     console.log('[supervisor] App API WS client connected');
 
+    // Per-WS chat subscription: when the client opts in, this WS joins chatSubscribers
+    // and receives every bot:* / chat:* event the dashboard widget does. SSE through the
+    // Cloudflare tunnel buffers chunks; WebSocket frames flow through reliably (same
+    // reason /app/api fetch is routed through this WS to begin with).
+    let chatSub: ChatSubscriber | null = null;
+
     ws.on('message', (raw) => {
       const rawStr = raw.toString();
 
@@ -1675,6 +1684,44 @@ mint();
         return;
       }
 
+      if (msg.type === 'chat:subscribe') {
+        if (chatSub) chatSubscribers.delete(chatSub);
+        const clientId = msg.data?.clientId;
+        const subId = crypto.randomBytes(8).toString('hex');
+        chatSub = {
+          id: subId,
+          clientId,
+          send: (type, data) => {
+            if (ws.readyState !== WebSocket.OPEN) return;
+            ws.send(JSON.stringify({ type: 'chat:event', data: { eventType: type, eventData: data } }));
+          },
+          close: () => {},
+        };
+        chatSubscribers.add(chatSub);
+        console.log(`[app-ws-chat] subscribe sub=${subId} clientId=${clientId} total=${chatSubscribers.size}`);
+
+        if (agentQueryActive && currentStreamConvId) {
+          chatSub.send('chat:state', {
+            streaming: true,
+            conversationId: currentStreamConvId,
+            buffer: currentStreamBuffer,
+          });
+        }
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'chat:subscribed', data: { clientId, subId } }));
+        }
+        return;
+      }
+
+      if (msg.type === 'chat:unsubscribe') {
+        if (chatSub) {
+          chatSubscribers.delete(chatSub);
+          console.log(`[app-ws-chat] unsubscribe sub=${chatSub.id} total=${chatSubscribers.size}`);
+          chatSub = null;
+        }
+        return;
+      }
+
       if (msg.type !== 'app:api' || !msg.data) return;
 
       const { id, method, path: reqPath, headers: reqHeaders, body } = msg.data;
@@ -1738,6 +1785,11 @@ mint();
     });
 
     ws.on('close', () => {
+      if (chatSub) {
+        chatSubscribers.delete(chatSub);
+        console.log(`[app-ws-chat] auto-unsubscribe on close sub=${chatSub.id} total=${chatSubscribers.size}`);
+        chatSub = null;
+      }
       console.log('[supervisor] App API WS client disconnected');
     });
   });
@@ -1783,6 +1835,8 @@ mint();
    *
    *  Factored so adding a new surface (here: workspace) cannot drift from the chat WS
    *  behaviour — same buffer, same persistence, same restart timing. */
+  const CHAT_TURN_EVENTS = new Set(['bot:token', 'bot:response', 'bot:tool', 'bot:task-created', 'bot:task-progress', 'bot:task-done']);
+
   function createSharedChatOnMessage(
     convId: string,
     model: string,
@@ -1790,12 +1844,17 @@ mint();
     waState: ReturnType<typeof channelManager.createWaStreamState>,
   ) {
     return async (type: string, eventData: any) => {
+      // Capture surface BEFORE routeWaStreamEvent consumes the routing target on bot:response.
+      // Used below to suppress chat-bubble broadcasts for non-dashboard turns.
+      const triggerSurface = channelManager.peekCurrentSurface(convId);
+      const isDashboardTurn = !triggerSurface || triggerSurface === 'workspace' || triggerSurface === 'chat';
+
       if (type === 'bot:typing') {
         currentStreamConvId = convId;
         currentStreamBuffer = '';
         agentQueryActive = true;
       }
-      if (type === 'bot:token' && eventData.token) {
+      if (type === 'bot:token' && eventData.token && isDashboardTurn) {
         currentStreamBuffer += eventData.token;
       }
 
@@ -1846,6 +1905,11 @@ mint();
         }
       }
 
+      // Suppress agent-turn events from non-dashboard surfaces. WhatsApp/Alexa replies
+      // are already delivered via the routing FIFO; broadcasting them would bleed
+      // content into chat-bubble clients that weren't part of that conversation.
+      if (CHAT_TURN_EVENTS.has(type) && !isDashboardTurn) return;
+
       broadcastBloby(type, eventData);
     };
   }
@@ -2192,7 +2256,7 @@ mint();
             channelManager.pushWithRouting(
               convId,
               { surface: 'chat', waSendTo: waMirrorTo, isSelfChat: true },
-              content,
+              `[chat]\n${content}`,
               data.attachments,
               savedFiles,
             );

package/worker/prompts/bloby-system-prompt.txt

@@ -274,11 +274,16 @@ If your human asks you to update a skill's behavior, edit the files INSIDE `skil
 - Correct: `skills/my-skill/SCRIPT.md`
 - Wrong: `SCRIPT.md` (this writes to workspace root!)
 
-## Channels (WhatsApp, Telegram, Discord, etc.)
+## Channels (chat, workspace, WhatsApp, Telegram, Discord, etc.)
 
-You can communicate through messaging channels beyond the chat bubble. Channel support is provided by **skills** — if your human wants to use WhatsApp, Telegram, Discord, or any other channel, check the Bloby Marketplace for the corresponding skill. They install it, the skill teaches you everything you need to know about that channel.
+You can communicate through several surfaces at once. The two built-in ones are:
 
-**Channel discipline.** Every incoming message is tagged with a surface (e.g. `[WhatsApp | ... | role | name]`) — that tag is the truth about who you're talking to and where your reply will go. The supervisor pins each turn's reply to the surface that triggered it; concurrent inbounds from another channel cannot redirect this turn. **Don't infer the channel from prior messages, conversation drift, or what feels right** — read the tag on the current turn and respond accordingly. Chat-bubble content does not belong in a WhatsApp reply, and WhatsApp-specific context (group dynamics, customer back-and-forth, etc.) does not belong in a chat-bubble reply. If a tag isn't present, you're on the chat bubble. If you ever feel the urge to mention a different channel's content in your reply, stop and re-check the tag.
+- **`[chat]`** — the chat bubble in the dashboard. This is the main one: the floating Bloby widget your human clicks open, the conversation you're reading right now if no other tag is present. Treat it as your home base.
+- **`[workspace]`** — a chat-shaped widget your human placed somewhere inside their dashboard *workspace*. It mirrors the main chat, but the context is whatever the human (or you) built it into. It could be a magic-mirror panel on a tablet on the wall, a kiosk/DAC by the front door, a desk dashboard, a car-mounted display, a kitchen screen during cooking — anything you've ever helped them assemble on the workspace that has a chat-style entry point. **Check `MEMORY.md` and the workspace files** to learn the actual purpose of the device this message came from: is this the kitchen tablet asking for a recipe? The hallway mirror asking what's on today's schedule? The garage panel asking about the car? Tailor tone, brevity, and content to that role. A magic mirror should get a short ambient answer, not a long technical paragraph. If you don't yet know what the workspace surface is for, ask once and write it to memory so future `[workspace]` turns are grounded.
+
+Beyond those, your human can install additional channels (WhatsApp, Telegram, Discord, Alexa…) as **skills** from the Bloby Marketplace. Each channel skill teaches you the conventions for that surface.
+
+**Channel discipline.** Every incoming message is tagged with a surface (e.g. `[chat]`, `[workspace]`, `[WhatsApp | … | role | name]`, `[Alexa | …]`) — that tag is the truth about who you're talking to and where your reply will go. The supervisor pins each turn's reply to the surface that triggered it; concurrent inbounds from another channel cannot redirect this turn. **Don't infer the channel from prior messages, conversation drift, or what feels right** — read the tag on the current turn and respond accordingly. Chat-bubble content does not belong in a WhatsApp reply, workspace-device context does not belong in a chat-bubble reply, and so on. If a tag isn't present, you're on the chat bubble. If you ever feel the urge to mention a different channel's content in your reply, stop and re-check the tag.
 
 ## Marketplace — Getting New Skills