agentgui 1.0.597 → 1.0.599

package/database.js

@@ -949,7 +949,15 @@ export const queries = {
     return result.changes || 0;
   },
 
-  createEvent(type, data, conversationId = null, sessionId = null) {
+  createEvent(type, data, conversationId = null, sessionId = null, idempotencyKey = null) {
+    if (idempotencyKey) {
+      const cached = this.getIdempotencyKey(idempotencyKey);
+      if (cached) {
+        console.log(`[event-idempotency] Event already exists for key ${idempotencyKey}, returning cached`);
+        return JSON.parse(cached);
+      }
+    }
+
     const id = generateId('evt');
     const now = Date.now();
 
@@ -958,7 +966,7 @@ export const queries = {
     );
     stmt.run(id, type, conversationId, sessionId, JSON.stringify(data), now);
 
-    return {
+    const event = {
       id,
       type,
       conversationId,
@@ -966,6 +974,12 @@ export const queries = {
       data,
       created_at: now
     };
+
+    if (idempotencyKey) {
+      this.setIdempotencyKey(idempotencyKey, event);
+    }
+
+    return event;
   },
 
   getEvent(id) {

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.599",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -4242,6 +4242,49 @@ wsRouter.onLegacy((data, ws) => {
       conversationId: data.conversationId,
       timestamp: Date.now()
     }));
+
+    // Notify client if this conversation has an active streaming execution
+    if (data.conversationId && activeExecutions.has(data.conversationId)) {
+      const execution = activeExecutions.get(data.conversationId);
+      const conv = queries.getConversation(data.conversationId);
+      ws.send(JSON.stringify({
+        type: 'streaming_start',
+        sessionId: execution.sessionId,
+        conversationId: data.conversationId,
+        agentId: conv?.agentType || conv?.agentId || 'claude-code',
+        resumed: true,
+        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}`);
+
+        const latestSession = queries.getLatestSession(data.conversationId);
+        if (latestSession) {
+          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()
+          }));
+
+          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 +4628,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;

package/static/js/client.js

@@ -696,6 +696,9 @@ class AgentGUIClient {
         case 'streaming_start':
           this.handleStreamingStart(data).catch(e => console.error('handleStreamingStart error:', e));
           break;
+        case 'streaming_resumed':
+          this.handleStreamingResumed(data).catch(e => console.error('handleStreamingResumed error:', e));
+          break;
         case 'streaming_progress':
           this.handleStreamingProgress(data);
           break;
@@ -920,6 +923,19 @@ class AgentGUIClient {
     this.emit('streaming:start', data);
   }
 
+  async handleStreamingResumed(data) {
+    console.log('Streaming resumed:', data);
+    const conv = this.state.currentConversation || { id: data.conversationId };
+    await this.handleStreamingStart({
+      type: 'streaming_start',
+      sessionId: data.sessionId,
+      conversationId: data.conversationId,
+      agentId: conv.agentType || conv.agentId || 'claude-code',
+      resumed: true,
+      timestamp: data.timestamp
+    });
+  }
+
   handleStreamingProgress(data) {
     // NOTE: With chunk-based architecture, blocks are rendered from polling
     // This handler is kept for backward compatibility and to trigger polling updates
@@ -3284,122 +3300,122 @@ document.addEventListener('DOMContentLoaded', async () => {
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = AgentGUIClient;
 }
-  // PHASE 2: Generate unique request ID
-  _generateRequestId() {
-    return ++this._currentRequestId;
-  }
-
-  // PHASE 2: Make a load request with tracking
-  _makeLoadRequest(conversationId) {
-    const requestId = this._generateRequestId();
-    const abortController = new AbortController();
-    
-    // Cancel previous request for this conversation if exists
-    const prev = this._loadInProgress[conversationId];
-    if (prev?.abortController) {
-      prev.abortController.abort();
-    }
-    
-    this._loadInProgress[conversationId] = {
-      requestId,
-      abortController,
-      timestamp: Date.now(),
-      conversationId
-    };
-    
-    return { requestId, abortController };
-  }
-
-  // PHASE 2: Verify request is current before rendering
-  _isCurrentRequest(conversationId, requestId) {
-    const current = this._loadInProgress[conversationId];
-    return current?.requestId === requestId;
-  }
-
-  // PHASE 3: Queue WebSocket message based on priority
-  _queueWebSocketMessage(data) {
-    const highPriorityTypes = ['conversation_deleted', 'all_conversations_deleted'];
-    
-    if (highPriorityTypes.includes(data.type)) {
-      this._highPriorityQueue.push(data);
-    } else {
-      this._lowPriorityQueue.push(data);
-    }
-  }
-
-  // PHASE 3: Process queued WebSocket messages
-  _drainMessageQueues() {
-    // Process high-priority first (deletions)
-    while (this._highPriorityQueue.length > 0) {
-      const msg = this._highPriorityQueue.shift();
-      this._processWebSocketMessageDirect(msg);
-    }
-    
-    // Then process low-priority (metadata)
-    while (this._lowPriorityQueue.length > 0) {
-      const msg = this._lowPriorityQueue.shift();
-      this._processWebSocketMessageDirect(msg);
-    }
-  }
-
-  // PHASE 3: Direct WebSocket message processing (extracted from switch)
-  _processWebSocketMessageDirect(data) {
-    switch (data.type) {
-      case 'streaming_start':
-        this.handleStreamingStart(data).catch(e => console.error('handleStreamingStart error:', e));
-        break;
-      case 'streaming_progress':
-        this.handleStreamingProgress(data);
-        break;
-      case 'streaming_complete':
-        this.handleStreamingComplete(data);
-        break;
-      case 'streaming_error':
-        this.handleStreamingError(data);
-        break;
-      case 'conversation_created':
-        this.handleConversationCreated(data);
-        break;
-      case 'conversation_deleted':
-        this.handleConversationDeleted(data);
-        break;
-      case 'all_conversations_deleted':
-        this.handleAllConversationsDeleted(data);
-        break;
-      case 'message_created':
-        this.handleMessageCreated(data);
-        break;
-      case 'conversation_updated':
-        this.handleConversationUpdated(data);
-        break;
-      case 'message_updated':
-        this.handleMessageUpdated(data);
-        break;
-      default:
-        // Other types handled elsewhere
-        break;
-    }
-  }
-
-  // PHASE 4: Track streaming event sequence
-  _recordStreamingSequence(sessionId, sequence) {
-    this._lastProcessedSequence[sessionId] = sequence;
-  }
-
-  // PHASE 4: Verify streaming event is current and in-order
-  _isValidStreamingEvent(event) {
-    // Must be for current session
-    if (event.sessionId !== this.state.currentSession?.id) {
-      return false;
-    }
-    
-    // Check sequence number
-    const lastSeq = this._lastProcessedSequence[event.sessionId] || -1;
-    if (event.sequence !== undefined && event.sequence <= lastSeq) {
-      return false; // Duplicate or out-of-order
-    }
-    
-    return true;
-  }
-
-
+  // PHASE 2: Generate unique request ID
+  _generateRequestId() {
+    return ++this._currentRequestId;
+  }
+
+  // PHASE 2: Make a load request with tracking
+  _makeLoadRequest(conversationId) {
+    const requestId = this._generateRequestId();
+    const abortController = new AbortController();
+    
+    // Cancel previous request for this conversation if exists
+    const prev = this._loadInProgress[conversationId];
+    if (prev?.abortController) {
+      prev.abortController.abort();
+    }
+    
+    this._loadInProgress[conversationId] = {
+      requestId,
+      abortController,
+      timestamp: Date.now(),
+      conversationId
+    };
+    
+    return { requestId, abortController };
+  }
+
+  // PHASE 2: Verify request is current before rendering
+  _isCurrentRequest(conversationId, requestId) {
+    const current = this._loadInProgress[conversationId];
+    return current?.requestId === requestId;
+  }
+
+  // PHASE 3: Queue WebSocket message based on priority
+  _queueWebSocketMessage(data) {
+    const highPriorityTypes = ['conversation_deleted', 'all_conversations_deleted'];
+    
+    if (highPriorityTypes.includes(data.type)) {
+      this._highPriorityQueue.push(data);
+    } else {
+      this._lowPriorityQueue.push(data);
+    }
+  }
+
+  // PHASE 3: Process queued WebSocket messages
+  _drainMessageQueues() {
+    // Process high-priority first (deletions)
+    while (this._highPriorityQueue.length > 0) {
+      const msg = this._highPriorityQueue.shift();
+      this._processWebSocketMessageDirect(msg);
+    }
+    
+    // Then process low-priority (metadata)
+    while (this._lowPriorityQueue.length > 0) {
+      const msg = this._lowPriorityQueue.shift();
+      this._processWebSocketMessageDirect(msg);
+    }
+  }
+
+  // PHASE 3: Direct WebSocket message processing (extracted from switch)
+  _processWebSocketMessageDirect(data) {
+    switch (data.type) {
+      case 'streaming_start':
+        this.handleStreamingStart(data).catch(e => console.error('handleStreamingStart error:', e));
+        break;
+      case 'streaming_progress':
+        this.handleStreamingProgress(data);
+        break;
+      case 'streaming_complete':
+        this.handleStreamingComplete(data);
+        break;
+      case 'streaming_error':
+        this.handleStreamingError(data);
+        break;
+      case 'conversation_created':
+        this.handleConversationCreated(data);
+        break;
+      case 'conversation_deleted':
+        this.handleConversationDeleted(data);
+        break;
+      case 'all_conversations_deleted':
+        this.handleAllConversationsDeleted(data);
+        break;
+      case 'message_created':
+        this.handleMessageCreated(data);
+        break;
+      case 'conversation_updated':
+        this.handleConversationUpdated(data);
+        break;
+      case 'message_updated':
+        this.handleMessageUpdated(data);
+        break;
+      default:
+        // Other types handled elsewhere
+        break;
+    }
+  }
+
+  // PHASE 4: Track streaming event sequence
+  _recordStreamingSequence(sessionId, sequence) {
+    this._lastProcessedSequence[sessionId] = sequence;
+  }
+
+  // PHASE 4: Verify streaming event is current and in-order
+  _isValidStreamingEvent(event) {
+    // Must be for current session
+    if (event.sessionId !== this.state.currentSession?.id) {
+      return false;
+    }
+    
+    // Check sequence number
+    const lastSeq = this._lastProcessedSequence[event.sessionId] || -1;
+    if (event.sequence !== undefined && event.sequence <= lastSeq) {
+      return false; // Duplicate or out-of-order
+    }
+    
+    return true;
+  }
+
+