agentgui 1.0.597 → 1.0.598

package/lib/checkpoint-manager.js

@@ -8,6 +8,7 @@ class CheckpointManager {
   constructor(queries) {
     this.queries = queries;
     this._injectedSessions = new Set(); // Track which sessions already had checkpoints injected
+    this._pendingCheckpoints = new Map(); // Store checkpoints to inject on subscribe: { conversationId -> checkpoint }
   }
 
   /**
@@ -146,6 +147,36 @@ class CheckpointManager {
   reset() {
     this._injectedSessions.clear();
   }
+
+  /**
+   * Store a checkpoint to be injected when client subscribes
+   * (Used during server startup when no clients are connected yet)
+   */
+  storeCheckpointForDelay(conversationId, checkpoint) {
+    if (checkpoint && checkpoint.events && checkpoint.events.length > 0) {
+      this._pendingCheckpoints.set(conversationId, checkpoint);
+      console.log(`[checkpoint] Stored checkpoint for ${conversationId} to inject on subscribe (${checkpoint.events.length} events, ${checkpoint.chunks.length} chunks)`);
+    }
+  }
+
+  /**
+   * Get and remove a pending checkpoint (called when client subscribes)
+   */
+  getPendingCheckpoint(conversationId) {
+    const checkpoint = this._pendingCheckpoints.get(conversationId);
+    if (checkpoint) {
+      this._pendingCheckpoints.delete(conversationId);
+      console.log(`[checkpoint] Retrieved pending checkpoint for ${conversationId}`);
+    }
+    return checkpoint;
+  }
+
+  /**
+   * Check if there's a pending checkpoint for a conversation
+   */
+  hasPendingCheckpoint(conversationId) {
+    return this._pendingCheckpoints.has(conversationId);
+  }
 }
 
 export default CheckpointManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.597",
+  "version": "1.0.598",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -4242,6 +4242,38 @@ wsRouter.onLegacy((data, ws) => {
       conversationId: data.conversationId,
       timestamp: Date.now()
     }));
+
+    // Inject pending checkpoint events if this is a conversation subscription
+    if (data.conversationId && checkpointManager.hasPendingCheckpoint(data.conversationId)) {
+      const checkpoint = checkpointManager.getPendingCheckpoint(data.conversationId);
+      if (checkpoint) {
+        console.log(`[checkpoint] Injecting ${checkpoint.events.length} events to client for ${data.conversationId}`);
+
+        // Get the session to use for the injection
+        const latestSession = queries.getLatestSession(data.conversationId);
+        if (latestSession) {
+          // Send streaming_resumed event first
+          ws.send(JSON.stringify({
+            type: 'streaming_resumed',
+            sessionId: latestSession.id,
+            conversationId: data.conversationId,
+            resumeFrom: checkpoint.sessionId,
+            eventCount: checkpoint.events.length,
+            chunkCount: checkpoint.chunks.length,
+            timestamp: Date.now()
+          }));
+
+          // Inject each checkpoint event
+          checkpointManager.injectCheckpointEvents(latestSession.id, checkpoint, (evt) => {
+            ws.send(JSON.stringify({
+              ...evt,
+              sessionId: latestSession.id,
+              conversationId: data.conversationId
+            }));
+          });
+        }
+      }
+    }
   } else if (data.type === 'unsubscribe') {
     if (data.sessionId) {
       ws.subscriptions.delete(data.sessionId);
@@ -4585,27 +4617,11 @@ async function resumeInterruptedStreams() {
           timestamp: Date.now()
         });
 
-        // Inject checkpoint events before streaming starts
+        // Store checkpoint to inject when client subscribes (not now, since no clients connected yet)
         if (checkpoint) {
-          broadcastSync({
-            type: 'streaming_resumed',
-            sessionId: session.id,
-            conversationId: conv.id,
-            resumeFrom: previousSessionId,
-            eventCount: checkpoint.events.length,
-            chunkCount: checkpoint.chunks.length,
-            timestamp: Date.now()
-          });
-
-          checkpointManager.injectCheckpointEvents(session.id, checkpoint, (evt) => {
-            broadcastSync({
-              ...evt,
-              sessionId: session.id,
-              conversationId: conv.id
-            });
-          });
-
+          checkpointManager.storeCheckpointForDelay(conv.id, checkpoint);
           checkpointManager.markSessionResumed(previousSessionId);
+          console.log(`[RESUME] Checkpoint stored for ${conv.id}, will inject on next client subscribe`);
         }
 
         const messageId = lastMsg?.id || null;