agenthub-multiagent-mcp 1.1.4 → 1.3.0

package/src/heartbeat.ts

@@ -1,8 +1,13 @@
 /**
  * Background heartbeat manager with enhanced logging for pending tasks/messages
+ * and automatic reconnection on failures.
  */
 
 import { ApiClient } from "./client.js";
+import { AgentState } from "./state.js";
+
+// Reconnection callback type
+export type ReconnectCallback = () => Promise<AgentState | null>;
 
 export class HeartbeatManager {
   private client: ApiClient;
@@ -13,16 +18,34 @@ export class HeartbeatManager {
   private lastUnreadMessages = 0;
   private heartbeatCount = 0;
 
+  // Retry state
+  private consecutiveFailures = 0;
+  private backoffMs = 1000; // Start at 1 second
+  private readonly maxBackoffMs = 30000; // Cap at 30 seconds
+  private readonly failuresBeforeReconnect = 3;
+  private reconnectCallback?: ReconnectCallback;
+  private isReconnecting = false;
+
   constructor(client: ApiClient) {
     this.client = client;
   }
 
+  /**
+   * Set callback for reconnection attempts
+   */
+  setReconnectCallback(callback: ReconnectCallback): void {
+    this.reconnectCallback = callback;
+  }
+
   start(agentId: string): void {
     this.stop(); // Clear any existing interval
     this.agentId = agentId;
     this.heartbeatCount = 0;
     this.lastPendingTasks = 0;
     this.lastUnreadMessages = 0;
+    this.consecutiveFailures = 0;
+    this.backoffMs = 1000;
+    this.isReconnecting = false;
 
     // Send heartbeat every 30 seconds
     this.intervalId = setInterval(async () => {
@@ -31,12 +54,12 @@ export class HeartbeatManager {
       try {
         await this.sendHeartbeat();
       } catch (error) {
-        console.error("Heartbeat failed:", error);
+        await this.handleHeartbeatFailure(error);
       }
     }, 30_000);
 
     // Send initial heartbeat
-    this.sendHeartbeat();
+    this.sendHeartbeat().catch((error) => this.handleHeartbeatFailure(error));
   }
 
   stop(): void {
@@ -57,42 +80,102 @@ export class HeartbeatManager {
 
   setStatus(status: "online" | "busy"): void {
     this.status = status;
-    this.sendHeartbeat();
+    this.sendHeartbeat().catch((error) => this.handleHeartbeatFailure(error));
   }
 
   private async sendHeartbeat(): Promise<void> {
     if (!this.agentId) return;
 
-    try {
-      const response = await this.client.heartbeat(this.agentId, this.status);
-      this.heartbeatCount++;
+    const response = await this.client.heartbeat(this.agentId, this.status);
 
-      const { pending_tasks_count, unread_messages_count } = response;
+    // Success - reset failure state
+    this.consecutiveFailures = 0;
+    this.backoffMs = 1000;
+    this.heartbeatCount++;
 
-      // Log if there are new pending tasks
-      if (pending_tasks_count > 0 && pending_tasks_count !== this.lastPendingTasks) {
-        console.error(`\n🔔 [AgentHub] You have ${pending_tasks_count} pending task(s) waiting! Use get_pending_tasks to view them.\n`);
-      }
+    const { pending_tasks_count, unread_messages_count } = response;
 
-      // Log if there are new unread messages
-      if (unread_messages_count > 0 && unread_messages_count !== this.lastUnreadMessages) {
-        console.error(`\n📬 [AgentHub] You have ${unread_messages_count} unread message(s)! Use check_inbox to read them.\n`);
+    // Log if there are new pending tasks
+    if (pending_tasks_count > 0 && pending_tasks_count !== this.lastPendingTasks) {
+      console.error(`\n🔔 [AgentHub] You have ${pending_tasks_count} pending task(s) waiting! Use get_pending_tasks to view them.\n`);
+    }
+
+    // Log if there are new unread messages
+    if (unread_messages_count > 0 && unread_messages_count !== this.lastUnreadMessages) {
+      console.error(`\n📬 [AgentHub] You have ${unread_messages_count} unread message(s)! Use check_inbox to read them.\n`);
+    }
+
+    // Periodic reminder every 5 heartbeats (2.5 minutes) if there are pending items
+    if (this.heartbeatCount % 5 === 0) {
+      if (pending_tasks_count > 0 || unread_messages_count > 0) {
+        const parts = [];
+        if (pending_tasks_count > 0) parts.push(`${pending_tasks_count} pending task(s)`);
+        if (unread_messages_count > 0) parts.push(`${unread_messages_count} unread message(s)`);
+        console.error(`\n⏰ [AgentHub] Reminder: You have ${parts.join(" and ")}.\n`);
       }
+    }
+
+    this.lastPendingTasks = pending_tasks_count;
+    this.lastUnreadMessages = unread_messages_count;
+  }
+
+  private async handleHeartbeatFailure(error: unknown): Promise<void> {
+    this.consecutiveFailures++;
+    console.error(`[AgentHub] Heartbeat failed (attempt ${this.consecutiveFailures}):`, error);
 
-      // Periodic reminder every 5 heartbeats (2.5 minutes) if there are pending items
-      if (this.heartbeatCount % 5 === 0) {
-        if (pending_tasks_count > 0 || unread_messages_count > 0) {
-          const parts = [];
-          if (pending_tasks_count > 0) parts.push(`${pending_tasks_count} pending task(s)`);
-          if (unread_messages_count > 0) parts.push(`${unread_messages_count} unread message(s)`);
-          console.error(`\n⏰ [AgentHub] Reminder: You have ${parts.join(" and ")}.\n`);
-        }
+    // Check if we should attempt full reconnection
+    if (this.consecutiveFailures >= this.failuresBeforeReconnect && !this.isReconnecting) {
+      await this.attemptReconnection();
+    } else {
+      // Schedule retry with exponential backoff
+      this.scheduleRetry();
+    }
+  }
+
+  private scheduleRetry(): void {
+    console.error(`[AgentHub] Retrying heartbeat in ${this.backoffMs}ms...`);
+
+    setTimeout(async () => {
+      if (!this.agentId) return;
+
+      try {
+        await this.sendHeartbeat();
+        console.error("[AgentHub] Heartbeat recovered!");
+      } catch (error) {
+        await this.handleHeartbeatFailure(error);
       }
+    }, this.backoffMs);
+
+    // Increase backoff for next failure (exponential with cap)
+    this.backoffMs = Math.min(this.backoffMs * 2, this.maxBackoffMs);
+  }
+
+  private async attemptReconnection(): Promise<void> {
+    if (!this.reconnectCallback) {
+      console.error("[AgentHub] No reconnect callback configured, continuing retries...");
+      this.scheduleRetry();
+      return;
+    }
+
+    this.isReconnecting = true;
+    console.error("[AgentHub] Attempting full reconnection...");
 
-      this.lastPendingTasks = pending_tasks_count;
-      this.lastUnreadMessages = unread_messages_count;
+    try {
+      const state = await this.reconnectCallback();
+      if (state) {
+        this.agentId = state.agent_id;
+        this.consecutiveFailures = 0;
+        this.backoffMs = 1000;
+        this.isReconnecting = false;
+        console.error(`[AgentHub] Reconnected successfully as ${state.agent_id}`);
+      } else {
+        throw new Error("No state available for reconnection");
+      }
     } catch (error) {
-      console.error("Heartbeat failed:", error);
+      console.error("[AgentHub] Reconnection failed:", error);
+      this.isReconnecting = false;
+      this.consecutiveFailures = 0; // Reset to try again after more failures
+      this.scheduleRetry();
     }
   }
 

package/src/index.ts

@@ -10,11 +10,14 @@ import {
 import { ApiClient } from "./client.js";
 import { registerTools, handleToolCall } from "./tools/index.js";
 import { HeartbeatManager } from "./heartbeat.js";
+import { WebSocketClient } from "./websocket.js";
+import * as state from "./state.js";
 
 // Environment configuration
-const AGENTHUB_URL = process.env.AGENTHUB_URL || "http://localhost:8787";
+const AGENTHUB_URL = process.env.AGENTHUB_URL || "https://agenthub.contetial.com";
 const AGENTHUB_API_KEY = process.env.AGENTHUB_API_KEY || "";
 const AGENTHUB_AGENT_ID = process.env.AGENTHUB_AGENT_ID || "";
+const AGENTHUB_AUTO_RECONNECT = process.env.AGENTHUB_AUTO_RECONNECT !== "false"; // Enabled by default
 
 // Validate configuration
 if (!AGENTHUB_API_KEY) {
@@ -28,14 +31,61 @@ const client = new ApiClient(AGENTHUB_URL, AGENTHUB_API_KEY);
 // Initialize heartbeat manager
 const heartbeat = new HeartbeatManager(client);
 
-// Track current agent ID
+// Initialize WebSocket client for push notifications
+const wsClient = new WebSocketClient(AGENTHUB_URL, AGENTHUB_API_KEY);
+
+// Track current agent ID and working directory
 let currentAgentId = AGENTHUB_AGENT_ID;
+const workingDir = process.cwd();
+
+/**
+ * Attempt to reconnect using stored state
+ */
+async function attemptReconnect(): Promise<state.AgentState | null> {
+  const existingState = state.loadState(workingDir);
+  if (!existingState) {
+    return null;
+  }
+
+  const owner = state.getCurrentOwner();
+  if (existingState.owner !== owner) {
+    console.error("[AgentHub] State file belongs to different user, skipping auto-reconnect");
+    return null;
+  }
+
+  try {
+    const result = await client.reconnectAgent(
+      existingState.agent_id,
+      existingState.token,
+      owner,
+      undefined, // model - keep existing
+      existingState.name
+    );
+
+    if (result.reconnected) {
+      currentAgentId = result.agent_id;
+      // Update state with any changes
+      state.saveState(workingDir, {
+        ...existingState,
+        name: result.name,
+      });
+      return existingState;
+    }
+  } catch (error) {
+    console.error("[AgentHub] Reconnect attempt failed:", error);
+  }
+
+  return null;
+}
+
+// Set up reconnect callback for heartbeat manager
+heartbeat.setReconnectCallback(attemptReconnect);
 
 // Create MCP server
 const server = new Server(
   {
     name: "agenthub",
-    version: "1.1.4",
+    version: "1.2.0",
   },
   {
     capabilities: {
@@ -61,9 +111,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       setCurrentAgentId: (id: string) => {
         currentAgentId = id;
         heartbeat.start(id);
+        wsClient.connect(id);
+      },
+      stopHeartbeat: () => {
+        heartbeat.stop();
+        wsClient.close();
       },
-      stopHeartbeat: () => heartbeat.stop(),
       getWorkingDir: () => process.cwd(),
+      getPushedItems: () => wsClient.getPushedItems(),
     });
 
     return {
@@ -91,11 +146,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Graceful shutdown
 process.on("SIGINT", () => {
   heartbeat.stop();
+  wsClient.close();
   process.exit(0);
 });
 
 process.on("SIGTERM", () => {
   heartbeat.stop();
+  wsClient.close();
   process.exit(0);
 });
 
@@ -105,15 +162,31 @@ async function main() {
   await server.connect(transport);
   console.error("AgentHub MCP server running");
 
-  // Auto-register if agent ID is provided
+  // Auto-register if agent ID is provided via environment
   if (AGENTHUB_AGENT_ID) {
     try {
       await client.registerAgent(AGENTHUB_AGENT_ID);
       heartbeat.start(AGENTHUB_AGENT_ID);
+      wsClient.connect(AGENTHUB_AGENT_ID);
       console.error(`Auto-registered as agent: ${AGENTHUB_AGENT_ID}`);
     } catch (error) {
       console.error(`Failed to auto-register: ${error}`);
     }
+  } else if (AGENTHUB_AUTO_RECONNECT) {
+    // Try to auto-reconnect from stored state
+    const existingState = state.loadState(workingDir);
+    if (existingState) {
+      console.error(`[AgentHub] Found existing state for agent: ${existingState.agent_id}`);
+      const reconnected = await attemptReconnect();
+      if (reconnected) {
+        heartbeat.start(reconnected.agent_id);
+        wsClient.connect(reconnected.agent_id);
+        const displayName = reconnected.name || reconnected.agent_id;
+        console.error(`[AgentHub] Auto-reconnected as: ${displayName}`);
+      } else {
+        console.error("[AgentHub] Auto-reconnect failed, manual registration required");
+      }
+    }
   }
 }
 

package/src/state.ts

@@ -20,6 +20,7 @@ const PBKDF2_ITERATIONS = 100000;
 
 export interface AgentState {
   agent_id: string;
+  name?: string;
   owner: string;
   token: string;
   last_task?: string;