@tjamescouch/agentchat-mcp 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/agentchat-mcp",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "MCP server for AgentChat - real-time AI agent communication",
   "main": "index.js",
   "type": "module",
@@ -27,8 +27,8 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@tjamescouch/agentchat": "^0.23.1",
-    "zod": "^3.25.0"
+    "@tjamescouch/agentchat": "^0.22.2",
+    "zod": "^3.25.5"
   },
   "peerDependencies": {
     "zod": "^3.25.0"

package/state.js

@@ -12,9 +12,8 @@ export let keepaliveInterval = null;
 // Message tracking - timestamp of last message we returned to the caller
 export let lastSeenTimestamp = 0;
 
-// Message buffer - captures messages between listen() calls
-const MAX_BUFFER_SIZE = 200;
-let messageBuffer = [];
+// Exponential backoff - tracks consecutive idle nudges
+let consecutiveIdleCount = 0;
 
 // Default server
 export const DEFAULT_SERVER_URL = (() => {
@@ -88,27 +87,24 @@ export function getLastSeen() {
 }
 
 /**
- * Push a message into the buffer (called by persistent handler on client)
+ * Increment the idle counter (called on nudge/timeout with no messages)
+ * Returns the new count.
  */
-export function bufferMessage(msg) {
-  messageBuffer.push(msg);
-  if (messageBuffer.length > MAX_BUFFER_SIZE) {
-    messageBuffer = messageBuffer.slice(-MAX_BUFFER_SIZE);
-  }
+export function incrementIdleCount() {
+  consecutiveIdleCount++;
+  return consecutiveIdleCount;
 }
 
 /**
- * Drain all buffered messages and clear the buffer
+ * Reset the idle counter (called when a real message arrives)
  */
-export function drainMessageBuffer() {
-  const messages = messageBuffer;
-  messageBuffer = [];
-  return messages;
+export function resetIdleCount() {
+  consecutiveIdleCount = 0;
 }
 
 /**
- * Clear the message buffer (e.g., on reconnect)
+ * Get the current idle count
  */
-export function clearMessageBuffer() {
-  messageBuffer = [];
+export function getIdleCount() {
+  return consecutiveIdleCount;
 }

package/tools/connect.js

@@ -10,9 +10,10 @@ import path from 'path';
 import {
   client, keepaliveInterval,
   setClient, setServerUrl, setKeepaliveInterval,
-  resetLastSeen, clearMessageBuffer, bufferMessage,
+  resetLastSeen,
   DEFAULT_SERVER_URL, KEEPALIVE_INTERVAL_MS
 } from '../state.js';
+import { appendToInbox } from '../inbox-writer.js';
 
 /**
  * Base directory for identities
@@ -132,17 +133,16 @@ export function registerConnectTool(server) {
         setClient(newClient);
         setServerUrl(actualServerUrl);
 
-        // Reset last seen timestamp and message buffer on new connection
+        // Reset last seen timestamp on new connection
         resetLastSeen();
-        clearMessageBuffer();
 
-        // Persistent message handler - buffers ALL messages between listen() calls
-        // This is the fix for the listen() message drop bug: messages that arrive
-        // while the agent is busy with other tools are captured here instead of lost.
+        // Persistent message handler - writes ALL messages to inbox.jsonl so
+        // listen always has a single source of truth (same file the daemon uses).
         newClient.on('message', (msg) => {
-          // Skip own messages, server noise, and replays
-          if (msg.from === newClient.agentId || msg.from === '@server' || msg.replay) return;
-          bufferMessage({
+          // Skip own messages and server noise
+          if (msg.from === newClient.agentId || msg.from === '@server') return;
+          appendToInbox({
+            type: 'MSG',
             from: msg.from,
             to: msg.to,
             content: msg.content,

package/tools/listen.js

@@ -1,18 +1,74 @@
 /**
  * AgentChat Listen Tool
- * Handles listening for messages with inbox checking for missed messages
+ * Listens for messages by polling inbox.jsonl — the single source of truth
+ * for both daemon and direct-connection modes.
  */
 
 import { z } from 'zod';
 import fs from 'fs';
+import path from 'path';
 import { getDaemonPaths } from '@tjamescouch/agentchat/lib/daemon.js';
 import { addJitter } from '@tjamescouch/agentchat/lib/jitter.js';
 import { ClientMessageType } from '@tjamescouch/agentchat/lib/protocol.js';
-import { client, getLastSeen, updateLastSeen, drainMessageBuffer } from '../state.js';
+import { client, getLastSeen, updateLastSeen, getIdleCount, incrementIdleCount, resetIdleCount } from '../state.js';
 
 // Timeouts - agent cannot override these
 const ENFORCED_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour when alone
-const NUDGE_TIMEOUT_MS = 30 * 1000; // 30 seconds when others are present
+const NUDGE_TIMEOUT_MS = 5 * 1000; // 5 seconds when others are present
+const MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minute cap on backoff
+const POLL_INTERVAL_MS = 500; // fallback poll interval
+
+/**
+ * Read inbox.jsonl and return messages newer than lastSeen for the given channels.
+ */
+function readInbox(paths, lastSeen, channels, agentId) {
+  if (!fs.existsSync(paths.inbox)) return [];
+
+  let content;
+  try {
+    content = fs.readFileSync(paths.inbox, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  const lines = content.trim().split('\n').filter(Boolean);
+  const messages = [];
+
+  for (const line of lines) {
+    try {
+      const msg = JSON.parse(line);
+
+      if (msg.type !== 'MSG' || !msg.ts) continue;
+      if (msg.ts <= lastSeen) continue;
+      if (msg.from === agentId || msg.from === '@server') continue;
+
+      const isRelevantChannel = channels.includes(msg.to);
+      const isDMToUs = msg.to === agentId;
+      if (!isRelevantChannel && !isDMToUs) continue;
+
+      messages.push({
+        from: msg.from,
+        to: msg.to,
+        content: msg.content,
+        ts: msg.ts,
+      });
+    } catch {
+      // Skip invalid JSON lines
+    }
+  }
+
+  // Deduplicate by ts:from
+  const seen = new Set();
+  const deduped = messages.filter((m) => {
+    const key = `${m.ts}:${m.from}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  deduped.sort((a, b) => a.ts - b.ts);
+  return deduped;
+}
 
 /**
  * Register the listen tool with the MCP server
@@ -34,33 +90,14 @@ export function registerListenTool(server) {
         }
 
         const startTime = Date.now();
+        const paths = getDaemonPaths('default');
 
-        // Collect replay messages during channel joins
-        // The server sends buffered messages with { replay: true } on join,
-        // so we must capture them before they're emitted and lost
-        const replayMessages = [];
-        const replayHandler = (msg) => {
-          if (msg.replay && msg.from !== client.agentId && msg.from !== '@server') {
-            replayMessages.push({
-              from: msg.from,
-              to: msg.to,
-              content: msg.content,
-              ts: msg.ts,
-            });
-          }
-        };
-        client.on('message', replayHandler);
-
-        // Join channels (replay messages arrive here)
+        // Join/rejoin channels for presence (replays now go straight to inbox
+        // via the connect handler's message listener)
         for (const channel of channels) {
-          if (!client.channels.has(channel)) {
-            await client.join(channel);
-          }
+          await client.join(channel);
         }
 
-        // Done collecting replays
-        client.removeListener('message', replayHandler);
-
         // Check channel occupancy to determine timeout behavior
         let othersPresent = false;
         let channelOccupancy = {};
@@ -79,7 +116,6 @@ export function registerListenTool(server) {
             }
           }
         }
-        const lastSeen = getLastSeen();
 
         // Set presence to 'listening' so other agents see we're active
         const setPresence = (status) => {
@@ -87,156 +123,115 @@ export function registerListenTool(server) {
         };
         setPresence('listening');
 
-        // Drain the persistent message buffer (messages captured between listen calls)
-        const buffered = drainMessageBuffer().filter(m => {
-          // Filter to relevant channels/DMs, skip already-seen messages
-          const isRelevant = channels.includes(m.to) || m.to === client.agentId;
-          return isRelevant && (!m.ts || m.ts > lastSeen);
-        });
-
-        // Start with buffered messages + replay messages captured during join
-        const paths = getDaemonPaths('default');
-        let missedMessages = [...buffered, ...replayMessages];
-
-        if (fs.existsSync(paths.inbox)) {
-          try {
-            const content = fs.readFileSync(paths.inbox, 'utf-8');
-            const lines = content.trim().split('\n').filter(Boolean);
-
-            for (const line of lines) {
-              try {
-                const msg = JSON.parse(line);
-
-                // Skip if not a message type or missing timestamp
-                if (msg.type !== 'MSG' || !msg.ts) continue;
-
-                // Skip messages we've already seen
-                if (msg.ts <= lastSeen) continue;
-
-                // Skip own messages and server messages
-                if (msg.from === client.agentId || msg.from === '@server') continue;
-
-                // Only include messages for our channels (including DMs)
-                const isRelevantChannel = channels.includes(msg.to);
-                const isDMToUs = msg.to === client.agentId;
-                if (!isRelevantChannel && !isDMToUs) continue;
-
-                missedMessages.push({
-                  from: msg.from,
-                  to: msg.to,
-                  content: msg.content,
-                  ts: msg.ts,
-                });
-              } catch {
-                // Skip invalid JSON lines
-              }
-            }
-
-            // Sort by timestamp ascending (oldest first)
-            missedMessages.sort((a, b) => a.ts - b.ts);
-          } catch {
-            // Inbox read error, continue to blocking listen
-          }
-        }
+        // --- First check: return immediately if inbox has unseen messages ---
+        const lastSeen = getLastSeen();
+        const immediate = readInbox(paths, lastSeen, channels, client.agentId);
 
-        // If we have missed messages (from replay or inbox), return them immediately
-        if (missedMessages.length > 0) {
-          // Deduplicate by timestamp + from (replay and inbox may overlap)
-          const seen = new Set();
-          missedMessages = missedMessages.filter((m) => {
-            const key = `${m.ts}:${m.from}`;
-            if (seen.has(key)) return false;
-            seen.add(key);
-            return true;
-          });
-
-          // Sort by timestamp ascending (oldest first)
-          missedMessages.sort((a, b) => a.ts - b.ts);
-
-          // Update last seen to the newest message timestamp
-          const newestTs = missedMessages[missedMessages.length - 1].ts;
+        if (immediate.length > 0) {
+          const newestTs = immediate[immediate.length - 1].ts;
           updateLastSeen(newestTs);
-
+          resetIdleCount();
           setPresence('online');
           return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({
-                  messages: missedMessages,
-                  from_inbox: replayMessages.length === 0,
-                  from_replay: replayMessages.length > 0,
-                  elapsed_ms: Date.now() - startTime,
-                }),
-              },
-            ],
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                messages: immediate,
+                from_inbox: true,
+                elapsed_ms: Date.now() - startTime,
+              }),
+            }],
           };
         }
 
-        // No missed messages, wait for new ones
+        // --- No unseen messages: poll newdata semaphore until timeout ---
         return new Promise((resolve) => {
+          let watcher = null;
+          let pollId = null;
           let timeoutId = null;
 
-          const messageHandler = (msg) => {
-            // Filter out own messages, replays, and server messages
-            if (msg.from === client.agentId || msg.replay || msg.from === '@server') {
-              return;
-            }
-
-            // Update last seen timestamp
-            if (msg.ts) {
-              updateLastSeen(msg.ts);
-            }
+          const cleanup = () => {
+            if (watcher) { watcher.close(); watcher = null; }
+            if (pollId) { clearInterval(pollId); pollId = null; }
+            if (timeoutId) { clearTimeout(timeoutId); timeoutId = null; }
+            setPresence('online');
+          };
 
-            // Got a real message - return immediately
-            cleanup();
-            resolve({
-              content: [
-                {
+          const tryRead = () => {
+            const msgs = readInbox(paths, getLastSeen(), channels, client.agentId);
+            if (msgs.length > 0) {
+              const newestTs = msgs[msgs.length - 1].ts;
+              updateLastSeen(newestTs);
+              resetIdleCount();
+              cleanup();
+              resolve({
+                content: [{
                   type: 'text',
                   text: JSON.stringify({
-                    messages: [{
-                      from: msg.from,
-                      to: msg.to,
-                      content: msg.content,
-                      ts: msg.ts,
-                    }],
-                    from_inbox: false,
+                    messages: msgs,
+                    from_inbox: true,
                     elapsed_ms: Date.now() - startTime,
                   }),
-                },
-              ],
-            });
+                }],
+              });
+              return true;
+            }
+            return false;
           };
 
-          const cleanup = () => {
-            client.removeListener('message', messageHandler);
-            if (timeoutId) clearTimeout(timeoutId);
-            setPresence('online');
-          };
+          // Watch the newdata semaphore file for changes
+          const newdataDir = path.dirname(paths.newdata);
+          const newdataFile = path.basename(paths.newdata);
 
-          client.on('message', messageHandler);
+          // Ensure directory exists so fs.watch doesn't throw
+          if (!fs.existsSync(newdataDir)) {
+            fs.mkdirSync(newdataDir, { recursive: true });
+          }
 
-          // Use shorter timeout when others are present to break deadlock
-          const baseTimeout = othersPresent ? NUDGE_TIMEOUT_MS : ENFORCED_TIMEOUT_MS;
+          try {
+            watcher = fs.watch(newdataDir, (eventType, filename) => {
+              if (filename === newdataFile) {
+                tryRead();
+              }
+            });
+            watcher.on('error', () => {
+              // Watcher died — fallback poll will still work
+              if (watcher) { watcher.close(); watcher = null; }
+            });
+          } catch {
+            // fs.watch not available on this platform — rely on poll
+          }
+
+          // Fallback poll in case fs.watch misses events
+          pollId = setInterval(() => {
+            tryRead();
+          }, POLL_INTERVAL_MS);
+
+          // Exponential backoff timeout
+          const idleCount = getIdleCount();
+          const backoffMultiplier = Math.pow(2, idleCount);
+          const baseTimeout = othersPresent
+            ? Math.min(NUDGE_TIMEOUT_MS * backoffMultiplier, MAX_BACKOFF_MS)
+            : ENFORCED_TIMEOUT_MS;
           const actualTimeout = addJitter(baseTimeout, 0.2);
 
           timeoutId = setTimeout(() => {
+            incrementIdleCount();
             cleanup();
             resolve({
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify({
-                    messages: [],
-                    timeout: !othersPresent,
-                    nudge: othersPresent,
-                    others_waiting: othersPresent,
-                    channel_occupancy: channelOccupancy,
-                    elapsed_ms: Date.now() - startTime,
-                  }),
-                },
-              ],
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  messages: [],
+                  timeout: !othersPresent,
+                  nudge: othersPresent,
+                  others_waiting: othersPresent,
+                  channel_occupancy: channelOccupancy,
+                  idle_count: idleCount + 1,
+                  next_timeout_ms: Math.min(NUDGE_TIMEOUT_MS * Math.pow(2, idleCount + 1), MAX_BACKOFF_MS),
+                  elapsed_ms: Date.now() - startTime,
+                }),
+              }],
             });
           }, actualTimeout);
         });