bloby-bot 0.25.1 → 0.25.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "releaseNotes": [
     "1. new stuff",
     "2. ",

package/supervisor/channels/manager.ts

@@ -70,6 +70,8 @@ export class ChannelManager {
   private customerBuffers = new Map<string, BufferedMessage[]>();
   /** Debounce buffers per sender (keyed by "channel:sender") */
   private debounceBuffers = new Map<string, DebounceEntry>();
+  /** Dynamic reply target for the admin live conversation (updated before each pushMessage) */
+  private waReplyTarget: { channel: ChannelType; rawSender: string; assistantBufferKey?: string } | null = null;
 
   constructor(opts: ChannelManagerOpts) {
     this.opts = opts;
@@ -245,7 +247,7 @@ export class ChannelManager {
 
   /** Format a bot reply with the agent's name prefix (for admin & assistant messages, NOT customer) */
   private formatBotReply(text: string, botName: string): string {
-    return `🤖 *${botName}:*\n\n${text}`;
+    return `🤖 *${botName}:*\n\n\`${text}\``;
   }
 
   private handleStatusChange(status: ChannelStatus) {
@@ -362,19 +364,57 @@ export class ChannelManager {
       return;
     }
 
-    // Assistant mode — triggered message in someone else's chat
+    // Assistant mode — triggered message in someone else's chat → route through admin (shared brain)
     if (mode === 'assistant') {
+      const phone = sender.replace(/@.*/, '');
+      const bufferKey = `${channel}:${phone}`;
+      const buffer = this.customerBuffers.get(bufferKey) || [];
+
+      // Strip trigger prefix
+      const cfgBotName = loadConfig().username || 'bloby';
+      const triggerRegex = new RegExp(`@${cfgBotName}[:\\s]+`, 'i');
+      const triggerMatch = combinedText.match(triggerRegex);
+      let cleanText = combinedText;
+      if (triggerMatch && triggerMatch.index !== undefined) {
+        cleanText = combinedText.slice(triggerMatch.index + triggerMatch[0].length).trim();
+      }
+
+      // Load skill context (SCRIPT.md + contact memory)
+      const scriptPrompt = this.loadActiveScript(channelConfig);
+      let contactMemory = '';
+      try {
+        const customerDataDir = this.getSkillCustomerDataDir(channelConfig);
+        if (customerDataDir) {
+          const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${phone}.md`);
+          if (fs.existsSync(memoryPath)) {
+            contactMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
+          }
+        }
+      } catch {}
+
+      // Build enriched text: skill instructions + conversation context + command
+      let enrichedText = '';
+      if (scriptPrompt) enrichedText += `# Assistant Skill Instructions\n${scriptPrompt}\n\n---\n`;
+      if (contactMemory) enrichedText += `# Contact Memory (${phone})\n${contactMemory}\n\n---\n`;
+      if (buffer.length > 0) {
+        enrichedText += `# Recent conversation with ${senderName || phone}\n`;
+        enrichedText += buffer.map((m) => m.content).join('\n');
+        enrichedText += '\n\n---\n';
+      }
+      enrichedText += cleanText;
+
       const message: InboundMessage = {
         channel,
-        sender: sender.replace(/@.*/, ''),
+        sender: phone,
         senderName,
         role: 'assistant',
-        text: combinedText,
+        text: enrichedText,
         rawSender: sender,
         attachments: attachments.length > 0 ? attachments : undefined,
       };
-      log.info(`[channels] Assistant mode | triggered in chat with ${message.sender} | "${combinedText.slice(0, 60)}"`);
-      await this.handleAssistantMessage(message, channelConfig);
+
+      log.info(`[channels] Assistant mode | triggered in chat with ${phone} | buffer=${buffer.length} msgs | "${cleanText.slice(0, 60)}"`);
+      await this.handleAdminMessage(message);
       return;
     }
 
@@ -415,7 +455,7 @@ export class ChannelManager {
     return 'customer';
   }
 
-  /** Handle message from an admin — mirrors to chat conversation, uses main system prompt */
+  /** Handle message from an admin (or assistant trigger) — mirrors to chat conversation, uses main system prompt */
   private async handleAdminMessage(msg: InboundMessage) {
     const { workerApi, broadcastBloby, getModel } = this.opts;
     const model = getModel();
@@ -474,8 +514,10 @@ export class ChannelManager {
       }
     } catch {}
 
-    // Channel context — tells the agent this is a WhatsApp message, respond naturally
-    const channelContext = `[WhatsApp | ${msg.sender} | admin]\n`;
+    // Channel context — dynamic role (admin for self-chat, assistant for triggered messages)
+    const roleTag = msg.senderName && msg.role === 'assistant'
+      ? `${msg.role} | ${msg.senderName}` : msg.role;
+    const channelContext = `[WhatsApp | ${msg.sender} | ${roleTag}]\n`;
 
     // Convert inbound attachments to agent format
     const agentAttachments: AgentAttachment[] | undefined = msg.attachments?.map((att) => ({
@@ -485,7 +527,7 @@ export class ChannelManager {
       data: att.data,
     }));
 
-    // Show "typing..." while the agent processes
+    // Show "typing..." in the correct chat
     this.startTyping(msg.channel, msg.rawSender);
 
     // Track text chunks for WhatsApp — lives for the conversation lifetime
@@ -501,24 +543,37 @@ export class ChannelManager {
           waChunkBuf += eventData.token;
         }
 
+        // Use dynamic reply target (self-chat or contact's chat depending on latest push)
+        const target = this.waReplyTarget;
+        if (!target) return;
+
         // Agent paused to use a tool — send accumulated text as an intermediate WhatsApp message
         if (type === 'bot:tool' && waChunkBuf.trim()) {
-          this.sendMessage(msg.channel, msg.rawSender, this.formatBotReply(waChunkBuf.trim(), botName)).catch((err) => {
+          this.sendMessage(target.channel, target.rawSender, this.formatBotReply(waChunkBuf.trim(), botName)).catch((err) => {
             log.warn(`[channels] Failed to send WhatsApp chunk: ${err.message}`);
           });
           waChunkBuf = '';
         }
 
         if (type === 'bot:response' && eventData.content) {
-          // Send remaining text
+          // Send remaining text to the correct chat
           const remaining = waChunkBuf.trim();
           if (remaining) {
-            this.sendMessage(msg.channel, msg.rawSender, this.formatBotReply(remaining, botName)).catch((err) => {
+            this.sendMessage(target.channel, target.rawSender, this.formatBotReply(remaining, botName)).catch((err) => {
               log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
             });
             waChunkBuf = '';
           }
 
+          // If this was an assistant response, store in the contact's context buffer
+          if (target.assistantBufferKey) {
+            const buf = this.customerBuffers.get(target.assistantBufferKey);
+            if (buf) {
+              buf.push({ role: 'assistant', content: eventData.content });
+              if (buf.length > MAX_BUFFER_MESSAGES) buf.splice(0, buf.length - MAX_BUFFER_MESSAGES);
+            }
+          }
+
           // Save response to DB
           workerApi(`/api/conversations/${convId}/messages`, 'POST', {
             role: 'assistant',
@@ -540,6 +595,13 @@ export class ChannelManager {
       }, { botName, humanName }, recentMessages);
     }
 
+    // Set reply target BEFORE pushing — callback reads this to know where to send
+    this.waReplyTarget = {
+      channel: msg.channel,
+      rawSender: msg.rawSender,
+      assistantBufferKey: msg.role === 'assistant' ? `${msg.channel}:${msg.sender}` : undefined,
+    };
+
     // Push the message into the live conversation
     const channelContent = channelContext + msg.text;
     pushMessage(convId, channelContent, agentAttachments);
@@ -702,146 +764,6 @@ export class ChannelManager {
     log.info(`[channels] Assistant context stored: ${bufferKey} | ${buffer.length} msgs | [${label}]: "${text.slice(0, 60)}"`);
   }
 
-  /** Handle a triggered assistant message — runs one-shot agent with conversation context */
-  private async handleAssistantMessage(msg: InboundMessage, channelConfig: ChannelConfig) {
-    const agentKey = `${msg.channel}:${msg.sender}`;
-
-    // Check concurrent limit
-    if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
-      log.info(`[channels] Max concurrent agents reached — queuing assistant message for ${msg.sender}`);
-      this.messageQueue.push(msg);
-      return;
-    }
-
-    const { workerApi, getModel } = this.opts;
-    const model = getModel();
-
-    // Extract command after trigger: "Ok.\n\n@bloby: do X" → "do X"
-    const config = loadConfig();
-    const botName = config.username || 'bloby';
-    const triggerRegex = new RegExp(`@${botName}[:\\s]+`, 'i');
-    const triggerMatch = msg.text.match(triggerRegex);
-    let cleanText = msg.text;
-    if (triggerMatch && triggerMatch.index !== undefined) {
-      cleanText = msg.text.slice(triggerMatch.index + triggerMatch[0].length).trim();
-    }
-
-    // Load SCRIPT.md from configured skill
-    const scriptPrompt = this.loadActiveScript(channelConfig);
-
-    // Fetch agent name
-    let agentBotName = 'Bloby', humanName = 'Human';
-    try {
-      const status = await workerApi('/api/onboard/status');
-      agentBotName = status.agentName || 'Bloby';
-      humanName = status.userName || 'Human';
-    } catch {}
-
-    // Get conversation buffer (already populated by storeAssistantContext)
-    let buffer = this.customerBuffers.get(agentKey);
-    if (!buffer) {
-      buffer = [];
-      this.customerBuffers.set(agentKey, buffer);
-    }
-
-    log.info(`[channels] Assistant trigger: agentKey=${agentKey} | buffer=${buffer.length} msgs | cleanText="${cleanText.slice(0, 80)}"`);
-    if (buffer.length > 0) {
-      log.info(`[channels] Assistant context preview: ${buffer.slice(-5).map((m) => `[${m.role}] ${m.content.slice(0, 50)}`).join(' | ')}`);
-    }
-
-    // All buffered messages are context for the agent
-    const recentMessages: RecentMessage[] = buffer.map((m) => ({
-      role: m.role,
-      content: m.content,
-    }));
-
-    // Load per-contact memory from the skill's customer_data directory
-    let contactMemory = '';
-    try {
-      const customerDataDir = this.getSkillCustomerDataDir(channelConfig);
-      if (customerDataDir) {
-        const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${msg.sender}.md`);
-        if (fs.existsSync(memoryPath)) {
-          contactMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
-        }
-      }
-    } catch {}
-
-    // Build enriched script with contact memory
-    let enrichedScript = scriptPrompt;
-    if (contactMemory && enrichedScript) {
-      enrichedScript += `\n\n---\n# Contact History (${msg.sender})\n\n${contactMemory}`;
-    }
-
-    const channelContext = `[WhatsApp | ${msg.sender} | assistant${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
-
-    // Convert inbound attachments to agent format
-    const agentAttachments: AgentAttachment[] | undefined = msg.attachments?.map((att) => ({
-      type: 'image' as const,
-      name: `whatsapp_image.${att.mediaType.split('/')[1] || 'jpg'}`,
-      mediaType: att.mediaType,
-      data: att.data,
-    }));
-
-    // Stable convId per contact
-    const convId = `channel-${agentKey}`;
-
-    this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
-
-    // Show "typing..." while the agent processes
-    this.startTyping(msg.channel, msg.rawSender);
-
-    // Track text chunks for WhatsApp
-    let waChunkBuf = '';
-
-    startBlobyAgentQuery(
-      convId,
-      channelContext + cleanText,
-      model,
-      (type, eventData) => {
-        // Accumulate text tokens
-        if (type === 'bot:token' && eventData.token) {
-          waChunkBuf += eventData.token;
-        }
-
-        // Agent paused to use a tool — send accumulated text as intermediate message
-        if (type === 'bot:tool' && waChunkBuf.trim()) {
-          this.sendMessage(msg.channel, msg.rawSender, this.formatBotReply(waChunkBuf.trim(), agentBotName)).catch((err) => {
-            log.warn(`[channels] Failed to send assistant chunk: ${err.message}`);
-          });
-          waChunkBuf = '';
-        }
-
-        if (type === 'bot:response' && eventData.content) {
-          // Add response to buffer for continuity across triggers
-          buffer!.push({ role: 'assistant', content: eventData.content });
-          if (buffer!.length > MAX_BUFFER_MESSAGES) {
-            buffer!.splice(0, buffer!.length - MAX_BUFFER_MESSAGES);
-          }
-
-          // Send remaining text
-          const remaining = waChunkBuf.trim();
-          if (remaining) {
-            this.sendMessage(msg.channel, msg.rawSender, this.formatBotReply(remaining, agentBotName)).catch((err) => {
-              log.warn(`[channels] Failed to send assistant reply: ${err.message}`);
-            });
-            waChunkBuf = '';
-          }
-        }
-
-        if (type === 'bot:done') {
-          this.activeAgents.delete(agentKey);
-          if (eventData.usedFileTools) this.opts.restartBackend();
-          this.processQueue();
-        }
-      },
-      agentAttachments,
-      undefined,
-      { botName: agentBotName, humanName },
-      recentMessages,
-      enrichedScript,
-    );
-  }
 
   /** Transcribe audio via the existing whisper endpoint */
   private async transcribeAudio(audioBase64: string): Promise<string | null> {