@parhelia/core 0.1.12737 → 0.1.12744

package/dist/editor/ai/AgentTerminal.js

@@ -33,6 +33,7 @@ import { Splitter } from "../ui/Splitter";
 import { ScrollingContentTree } from "../ScrollingContentTree";
 import { MarkdownDisplay, } from "../../components/MarkdownDisplay";
 const AGENT_HISTORY_LIMIT = 1000;
+const RECENT_RUN_EVENTS_LIMIT = 50;
 function mergeAgentOperationHistory(existing, incoming, limit = AGENT_HISTORY_LIMIT) {
     const merged = new Map(existing.map((operation) => [operation.id, operation]));
     for (const operation of incoming) {
@@ -1004,16 +1005,12 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         return current.some((m) => !m.isCompleted && m.messageType === "streaming");
     }, []);
     const currentAgentId = agent?.id || agentStub.id;
-    const recentAgentRunEvents = useMemo(() => {
+    const currentRunDiagnostics = useMemo(() => {
         const normalizedAgentId = normalizeDialogAgentId(currentAgentId);
-        if (!normalizedAgentId) {
-            return [];
+        if (!normalizedAgentId || !editContext) {
+            return { events: [], totalCount: 0, receivedSeqs: [], missingSeqs: [] };
         }
-        if (!editContext) {
-            return [];
-        }
-        return (editContext.webSocketMessages || [])
-            .filter((message) => {
+        const agentRunMessages = (editContext.webSocketMessages || []).filter((message) => {
             if (!message?.type?.startsWith("agent:run:")) {
                 return false;
             }
@@ -1021,15 +1018,51 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                 return false;
             }
             return getAgentRunMessageAgentId(message.payload) === normalizedAgentId;
-        })
-            .slice(-8)
+        });
+        let runStartIndex = 0;
+        for (let i = agentRunMessages.length - 1; i >= 0; i--) {
+            if (agentRunMessages[i]?.type === "agent:run:start") {
+                runStartIndex = i;
+                break;
+            }
+        }
+        const currentRunMessages = agentRunMessages.slice(runStartIndex);
+        const seqsSet = new Set();
+        for (const message of currentRunMessages) {
+            const seq = message.seq ?? getAgentRunMessageSeq(message.payload);
+            if (typeof seq === "number" && seq > 0) {
+                seqsSet.add(seq);
+            }
+        }
+        const receivedSeqs = [...seqsSet].sort((a, b) => a - b);
+        const missingSeqs = [];
+        const max = receivedSeqs[receivedSeqs.length - 1];
+        if (max !== undefined) {
+            for (let i = 1; i <= max; i++) {
+                if (!seqsSet.has(i))
+                    missingSeqs.push(i);
+            }
+        }
+        const events = currentRunMessages
+            .slice(-RECENT_RUN_EVENTS_LIMIT)
             .map((message) => ({
             timestamp: message.timestamp,
+            direction: message.direction ?? "incoming",
             type: message.type,
-            seq: getAgentRunMessageSeq(message.payload),
-            detail: getAgentRunMessageDetail(message.type, message.payload),
+            seq: message.seq ?? getAgentRunMessageSeq(message.payload),
+            detail: message.detail ??
+                getAgentRunMessageDetail(message.type, message.payload),
+            rawMessage: message.rawMessage,
+            payloadBytes: message.payloadBytes ?? null,
         }));
+        return {
+            events,
+            totalCount: currentRunMessages.length,
+            receivedSeqs,
+            missingSeqs,
+        };
     }, [currentAgentId, editContext?.webSocketMessages]);
+    const recentAgentRunEvents = currentRunDiagnostics.events;
     const appendToolUiEvent = useCallback((type, detail, seq) => {
         const timestamp = new Date().toISOString();
         setRecentToolUiEvents((prev) => {
@@ -1834,6 +1867,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const lastSeqRef = useRef(0);
     const subscribedAgentIdRef = useRef(null);
     const reconcileServerStateInFlightRef = useRef(false);
+    const streamRecoveryInFlightRef = useRef(false);
+    const lastStreamRecoveryAtRef = useRef(0);
     const toolCallFirstSeenAtRef = useRef({});
     const pendingToolCompletionTimersRef = useRef({});
     // Cache mode/model/profile changes made while the agent is still "new" (not yet persisted)
@@ -2193,7 +2228,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const settleCompletedRun = useCallback((finalStatus = "completed") => {
         clearStopGuard();
         setError(null);
-        lastSeqRef.current = 0;
+        // Keep lastSeqRef populated so the diagnostic popover can show the
+        // last observed seq after the run finishes. The next agent:run:start
+        // resets it for the new run.
         setLastRunStatusReason(null);
         clearHeartbeatMessages();
         setMessages((prev) => {
@@ -3921,8 +3958,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                 "AI could not complete this request.";
             clearHeartbeatMessages();
             setLastRunStatusReason(null);
-            // Reset deduplication for the next run after an error
-            lastSeqRef.current = 0;
+            // Keep lastSeqRef populated so the diagnostic popover can show the
+            // last observed seq after the error. The next agent:run:start resets
+            // it for the new run.
             setError(errorMsg);
             // Update agent status to error
             setAgent((prev) => prev ? { ...prev, status: "error", statusMessage: errorMsg } : prev);
@@ -3961,10 +3999,12 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             if (subscribedAgentIdRef.current) {
                 const socket = globalThis.editorSocket;
                 if (socket && socket.readyState === WebSocket.OPEN) {
-                    socket.send(JSON.stringify({
+                    const payload = {
                         type: "agent:unsubscribe",
                         agentId: subscribedAgentIdRef.current,
-                    }));
+                    };
+                    console.debug("[AgentWebSocket] sent", payload);
+                    socket.send(JSON.stringify(payload));
                 }
                 subscribedAgentIdRef.current = null;
             }
@@ -3973,10 +4013,12 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         // Send subscription message to server
         const socket = globalThis.editorSocket;
         if (socket && socket.readyState === WebSocket.OPEN) {
-            socket.send(JSON.stringify({
+            const payload = {
                 type: "agent:subscribe",
                 agentId: agentStub.id,
-            }));
+            };
+            console.debug("[AgentWebSocket] sent", payload);
+            socket.send(JSON.stringify(payload));
         }
         // Use the addSocketMessageListener helper from editContext
         // Wrap the handler in a stable function that uses the ref
@@ -4021,10 +4063,12 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             if (socket &&
                 socket.readyState === WebSocket.OPEN &&
                 subscribedAgentIdRef.current) {
-                socket.send(JSON.stringify({
+                const payload = {
                     type: "agent:unsubscribe",
                     agentId: subscribedAgentIdRef.current,
-                }));
+                };
+                console.debug("[AgentWebSocket] sent", payload);
+                socket.send(JSON.stringify(payload));
             }
             unsubscribe();
             subscribedAgentIdRef.current = null;
@@ -5443,6 +5487,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const assistantGroupCount = useMemo(() => groupConsecutiveMessages(messages).filter((group) => group.type === "assistant-group").length, [messages]);
     const runDiagnosticsSnapshot = useMemo(() => {
         const lastEvent = recentAgentRunEvents[recentAgentRunEvents.length - 1];
+        const { receivedSeqs, missingSeqs, totalCount } = currentRunDiagnostics;
+        const observedMaxSeq = receivedSeqs[receivedSeqs.length - 1] ?? 0;
         return {
             agentId: currentAgentId,
             isSubmitting,
@@ -5455,10 +5501,13 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             hasActiveStreaming: hasActiveStreaming(),
             isSubscribed: normalizeDialogAgentId(subscribedAgentIdRef.current) ===
                 normalizeDialogAgentId(currentAgentId),
-            lastSeq: lastSeqRef.current,
+            lastSeq: Math.max(lastSeqRef.current, observedMaxSeq),
             lastEventType: lastEvent?.type ?? null,
             lastEventAt: lastEvent?.timestamp ?? null,
             recentEvents: recentAgentRunEvents,
+            currentRunReceivedSeqs: receivedSeqs,
+            currentRunMissingSeqs: missingSeqs,
+            currentRunTotalEventCount: totalCount,
             assistantMessageCount,
             assistantGroupCount,
             assistantGroupsWithRenderableToolCalls,
@@ -5472,6 +5521,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         assistantGroupsWithRenderableToolCalls,
         assistantMessageCount,
         currentAgentId,
+        currentRunDiagnostics,
         hasActiveStreaming,
         incompleteToolCallCount,
         isAgentThinking,
@@ -5502,10 +5552,58 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     settleCompletedRun(normalizeServerExecutionStatus(serverStatus) === "cancelled"
                         ? "cancelled"
                         : "completed");
+                    return;
+                }
+                const serverLastSeq = diagnostics.currentSession?.lastDelivery?.lastSeq ??
+                    diagnostics.transport?.lastSeq ??
+                    null;
+                const serverLastSuccessAt = diagnostics.currentSession?.lastDelivery?.lastSuccessAt ??
+                    diagnostics.transport?.lastBroadcastAt ??
+                    diagnostics.transport?.lastProducedAt ??
+                    null;
+                const serverLastSuccessTime = serverLastSuccessAt
+                    ? Date.parse(serverLastSuccessAt)
+                    : Number.NaN;
+                const now = Date.now();
+                const serverDeliveryOldEnough = Number.isFinite(serverLastSuccessTime) &&
+                    now - serverLastSuccessTime > 8_000;
+                const recoveryCooldownElapsed = now - lastStreamRecoveryAtRef.current > 30_000;
+                const localLastSeq = lastSeqRef.current;
+                if (diagnostics.currentSession?.isConnected &&
+                    diagnostics.currentSession?.isSubscribed &&
+                    typeof serverLastSeq === "number" &&
+                    serverLastSeq > localLastSeq &&
+                    serverDeliveryOldEnough &&
+                    recoveryCooldownElapsed &&
+                    !streamRecoveryInFlightRef.current) {
+                    streamRecoveryInFlightRef.current = true;
+                    lastStreamRecoveryAtRef.current = now;
+                    appendToolUiEvent("ui:stream-recovery", `server seq ${serverLastSeq} is ahead of local seq ${localLastSeq}; reconnecting socket`, serverLastSeq);
+                    try {
+                        await loadAgent();
+                    }
+                    catch (loadError) {
+                        console.warn("[AgentTerminal] Failed to reload agent during stream recovery", loadError);
+                    }
+                    try {
+                        const socket = globalThis.editorSocket;
+                        if (socket && socket.readyState === WebSocket.OPEN) {
+                            socket.close(4000, "agent-stream-lag");
+                        }
+                    }
+                    catch (socketError) {
+                        console.warn("[AgentTerminal] Failed to reconnect stale agent stream socket", socketError);
+                    }
+                    finally {
+                        window.setTimeout(() => {
+                            streamRecoveryInFlightRef.current = false;
+                        }, 5_000);
+                    }
                 }
             }
             catch (error) {
                 console.warn("[AgentTerminal] Failed to reconcile agent run status", error);
+                streamRecoveryInFlightRef.current = false;
             }
         };
         // Avoid racing a freshly submitted run before the backend has registered it.
@@ -5522,6 +5620,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         editContext?.socketConnectionVersion,
         isActive,
         isExecuting,
+        appendToolUiEvent,
+        loadAgent,
         settleCompletedRun,
     ]);
     const showInitialThinkingSplash = messages.length === 0 &&