agentgui 1.0.598 → 1.0.600

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/package.json

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

package/server.js

@@ -4243,16 +4243,28 @@ wsRouter.onLegacy((data, ws) => {
       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}`);
 
-        // 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,
@@ -4263,7 +4275,6 @@ wsRouter.onLegacy((data, ws) => {
             timestamp: Date.now()
           }));
 
-          // Inject each checkpoint event
           checkpointManager.injectCheckpointEvents(latestSession.id, checkpoint, (evt) => {
             ws.send(JSON.stringify({
               ...evt,

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,3 @@ 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;
-  }
-
-