agentgui 1.0.674 → 1.0.675

package/lib/ws-handlers-conv.js

@@ -9,6 +9,16 @@ export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
     broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts, cleanupExecution } = deps;
 
+  // Per-conversation queue seq counter for event ordering
+  const queueSeqByConv = new Map();
+
+  function getNextQueueSeq(conversationId) {
+    const current = queueSeqByConv.get(conversationId) || 0;
+    const next = current + 1;
+    queueSeqByConv.set(conversationId, next);
+    return next;
+  }
+
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
     for (const c of conversations) { if (c.isStreaming && !activeExecutions.has(c.id)) c.isStreaming = 0; }
@@ -247,6 +257,14 @@ export function register(router, deps) {
 
     // Message is queued - don't broadcast as message_created, let queue_status handle the UI update
     const qp = enqueue(p.id, prompt, agentId, model, userMessage.id, subAgent);
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_status',
+      conversationId: p.id,
+      queueLength: messageQueues.get(p.id)?.length || 1,
+      seq,
+      timestamp: Date.now()
+    });
     return { message: userMessage, queued: true, queuePosition: qp };
   });
 
@@ -262,7 +280,14 @@ export function register(router, deps) {
     if (idx === -1) notFound('Queued message not found');
     queue.splice(idx, 1);
     if (queue.length === 0) messageQueues.delete(p.id);
-    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: queue?.length || 0, timestamp: Date.now() });
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_status',
+      conversationId: p.id,
+      queueLength: queue?.length || 0,
+      seq,
+      timestamp: Date.now()
+    });
     return { deleted: true };
   });
 
@@ -273,7 +298,16 @@ export function register(router, deps) {
     if (!item) notFound('Queued message not found');
     if (p.content !== undefined) item.content = p.content;
     if (p.agentId !== undefined) item.agentId = p.agentId;
-    broadcastSync({ type: 'queue_updated', conversationId: p.id, messageId: p.messageId, content: item.content, agentId: item.agentId, timestamp: Date.now() });
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_updated',
+      conversationId: p.id,
+      messageId: p.messageId,
+      content: item.content,
+      agentId: item.agentId,
+      seq,
+      timestamp: Date.now()
+    });
     return { updated: true, item };
   });
 }

package/package.json

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

package/server.js

@@ -3356,6 +3356,9 @@ function createChunkBatcher() {
   return { add, drain };
 }
 
+// Global broadcast sequence counter for event ordering
+let broadcastSeq = 0;
+
 function parseRateLimitResetTime(text) {
   const match = text.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
   if (!match) return 300;

package/static/js/streaming-renderer.js

@@ -136,23 +136,35 @@ class StreamingRenderer {
 
   /**
    * Check if event is a duplicate
+   * For streaming_progress events, use seq+sessionId for precise dedup
+   * For other events, use type+id or type+sessionId
    */
   isDuplicate(event) {
     const key = this.getEventKey(event);
     if (!key) return false;
 
-    const lastTime = this.dedupMap.get(key);
-    const now = Date.now();
+    const lastSeq = this.dedupMap.get(key);
 
-    if (lastTime && (now - lastTime) < 100) {
-      return true;
+    // For streaming_progress with seq, compare seq numbers directly
+    if (event.type === 'streaming_progress' && event.seq !== undefined && lastSeq !== undefined) {
+      if (event.seq <= lastSeq) {
+        return true; // Same or older seq = duplicate
+      }
+      this.dedupMap.set(key, event.seq);
+      return false;
+    }
+
+    // For other events, use time-based dedup
+    const now = Date.now();
+    if (lastSeq && typeof lastSeq === 'number' && lastSeq > now - 500) {
+      return true; // Recent duplicate
     }
 
     this.dedupMap.set(key, now);
     if (this.dedupMap.size > 5000) {
-      const cutoff = now - 1000;
-      for (const [k, t] of this.dedupMap) {
-        if (t < cutoff) this.dedupMap.delete(k);
+      const cutoff = now - 5000;
+      for (const [k, v] of this.dedupMap) {
+        if (typeof v === 'number' && v < cutoff) this.dedupMap.delete(k);
       }
     }
     return false;
@@ -160,10 +172,15 @@ class StreamingRenderer {
 
   /**
    * Generate deduplication key for event
+   * Use sessionId:seq for streaming_progress, fallback to type:id
    */
   getEventKey(event) {
     if (!event.type) return null;
-    return `${event.type}:${event.id || event.sessionId || ''}`;
+    // For streaming events, use sessionId as primary key
+    if (event.sessionId) {
+      return `${event.sessionId}:${event.type}`;
+    }
+    return `${event.type}:${event.id || ''}`;
   }
 
   /**

package/static/js/websocket-manager.js

@@ -480,8 +480,14 @@ class WebSocketManager {
   }
 
   resubscribeAll() {
+    // After reconnect, query server state for all conversations with active subscriptions
+    // This ensures client streaming state matches server state
+    const conversationIds = new Set();
     for (const key of this.activeSubscriptions) {
       const [type, id] = key.split(':');
+      if (type === 'conversation') {
+        conversationIds.add(id);
+      }
       const msg = { type: 'subscribe', timestamp: Date.now() };
       if (type === 'session') msg.sessionId = id;
       else msg.conversationId = id;
@@ -490,6 +496,21 @@ class WebSocketManager {
         this.stats.totalMessagesSent++;
       } catch (_) {}
     }
+
+    // After resubscribing, query streaming state for each conversation
+    // This prevents stale UI state after network hiccup
+    if (conversationIds.size > 0) {
+      conversationIds.forEach(convId => {
+        this.sendMessage({
+          type: 'conv.get',
+          id: convId,
+          timestamp: Date.now()
+        }).catch(() => {
+          // Silently ignore query failures - server will send streaming_start
+          // on subscription confirmation if execution is active
+        });
+      });
+    }
   }
 
   unsubscribeFromSession(sessionId) {