@parhelia/core 0.1.12767 → 0.1.12772

package/dist/editor/ai/AgentTerminal.js

@@ -40,10 +40,12 @@ import { cn } from "../../lib/utils";
 import { sanitizeSvg } from "../../lib/sanitize";
 import { Select } from "../../components/ui/select";
 import { AgentTerminalStatusBar } from "./AgentTerminalStatusBar";
+import { checkReplayVerified, createRecoveryStateSlice, decideRecoveryAction, interpretAgentRunDiagnostics, reconcilePendingDialogTracker, } from "./agentDiagnostics";
+import { forceEditorSocketReconnect } from "../client/hooks/useEditorWebSocket";
 import { SimpleTabs } from "../ui/SimpleTabs";
 import { Splitter } from "../ui/Splitter";
 import { ScrollingContentTree } from "../ScrollingContentTree";
-import { subscribeAgent } from "../services/agentSubscriptionRegistry";
+import { requestAgentSubscriptionReplay, subscribeAgent, } from "../services/agentSubscriptionRegistry";
 import { registerMountedInstance, unregisterMountedInstance, setVisibleDialogEntry, clearVisibleDialogEntriesForInstance, updateInstanceFocus, isElectedDialogReceiver, } from "./agentDialogRegistry";
 const RECENT_RUN_EVENTS_LIMIT = 50;
 // interface AgentTerminalProps {
@@ -133,6 +135,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     const activeInlineDialogRef = useRef(activeInlineDialog);
     const isQuestionnaireDialogOpen = activeInlineDialog?.request.dialogType === "questionnaire";
     const orphanTimeoutRef = useRef(null);
+    const pendingDialogReplayCallbackIdsRef = useRef(new Set());
+    const pendingDialogReplayTimeoutsRef = useRef(new Set());
     useEffect(() => {
         activeInlineDialogRef.current = activeInlineDialog;
         const callbackId = activeInlineDialog?.request.callbackId || null;
@@ -316,6 +320,34 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             return next.slice(-40);
         });
     }, []);
+    const schedulePendingDialogReplay = useCallback((agentId, callbackId, dialogType) => {
+        const normalizedCallbackId = callbackId.trim();
+        if (!agentId || !normalizedCallbackId) {
+            return;
+        }
+        if (pendingDialogReplayCallbackIdsRef.current.has(normalizedCallbackId)) {
+            return;
+        }
+        pendingDialogReplayCallbackIdsRef.current.add(normalizedCallbackId);
+        const timeout = setTimeout(() => {
+            pendingDialogReplayTimeoutsRef.current.delete(timeout);
+            const activeCallbackId = activeInlineDialogRef.current?.request.callbackId?.trim();
+            if (activeCallbackId === normalizedCallbackId) {
+                return;
+            }
+            const replayRequested = requestAgentSubscriptionReplay(agentId);
+            appendToolUiEvent(replayRequested
+                ? "ui:pending-dialog-replay-requested"
+                : "ui:pending-dialog-replay-skipped", `${dialogType || "dialog"} callbackId=${normalizedCallbackId} agentId=${agentId}`);
+        }, 750);
+        pendingDialogReplayTimeoutsRef.current.add(timeout);
+    }, [appendToolUiEvent]);
+    useEffect(() => {
+        return () => {
+            pendingDialogReplayTimeoutsRef.current.forEach((timeout) => clearTimeout(timeout));
+            pendingDialogReplayTimeoutsRef.current.clear();
+        };
+    }, []);
     // Collect all pending tool calls for batch approval functionality
     const allPendingApprovals = useMemo(() => {
         const pending = [];
@@ -1181,8 +1213,16 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     const lastSeqRef = useRef(0);
     const subscribedAgentIdRef = useRef(null);
     const reconcileServerStateInFlightRef = useRef(false);
-    const streamRecoveryInFlightRef = useRef(false);
-    const lastStreamRecoveryAtRef = useRef(0);
+    // Recovery ladder state. The graduated replay → reconnect → stale path lives in the
+    // diagnostics polling effect below. State is keyed by agentId so switching between
+    // agents in the same terminal doesn't cross-contaminate cooldowns.
+    const recoveryStateByAgentRef = useRef(new Map());
+    const replayVerifyTimeoutRef = useRef(null);
+    // Mirror refs so the one-shot verify timer (which fires outside the polling effect's
+    // closure) can read the latest snapshot/diagnostics without re-running the effect.
+    const runDiagnosticsSnapshotRef = useRef(null);
+    const lastDiagnosticsResponseRef = useRef(null);
+    const [showStaleAgentBanner, setShowStaleAgentBanner] = useState(false);
     const toolCallFirstSeenAtRef = useRef({});
     const pendingToolCompletionTimersRef = useRef({});
     // Cache mode/model/profile changes made while the agent is still "new" (not yet persisted)
@@ -3191,14 +3231,17 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     const dialogType = typeof statusData?.dialogType === "string"
                         ? statusData.dialogType
                         : null;
-                    const isBrowserCaptureWait = dialogType === DIALOG_TYPES.CAPTURE_PAGE_DOM ||
-                        dialogType === DIALOG_TYPES.CAPTURE_PAGE_SCREENSHOT;
-                    setPendingBrowserCaptureDialogType(isBrowserCaptureWait ? dialogType : null);
-                    const captureCallbackId = isBrowserCaptureWait &&
-                        typeof statusData?.callbackId === "string" &&
+                    const callbackId = typeof statusData?.callbackId === "string" &&
                         statusData.callbackId.trim()
                         ? statusData.callbackId.trim()
                         : null;
+                    const isBrowserCaptureWait = dialogType === DIALOG_TYPES.CAPTURE_PAGE_DOM ||
+                        dialogType === DIALOG_TYPES.CAPTURE_PAGE_SCREENSHOT;
+                    if (callbackId && !isBrowserCaptureWait) {
+                        schedulePendingDialogReplay(agentId, callbackId, dialogType);
+                    }
+                    setPendingBrowserCaptureDialogType(isBrowserCaptureWait ? dialogType : null);
+                    const captureCallbackId = isBrowserCaptureWait && callbackId ? callbackId : null;
                     setPendingBrowserCaptureCallbackId(captureCallbackId);
                     setAgent((prev) => prev
                         ? {
@@ -3362,6 +3405,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         handleToolCall,
         handleToolResult,
         onAgentUpdate,
+        schedulePendingDialogReplay,
         settleCompletedRun,
     ]);
     // Keep refs for latest agent to avoid adding them to effect deps
@@ -4888,6 +4932,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         const lastEvent = recentAgentRunEvents[recentAgentRunEvents.length - 1];
         const { receivedSeqs, missingSeqs, totalCount } = currentRunDiagnostics;
         const observedMaxSeq = receivedSeqs[receivedSeqs.length - 1] ?? 0;
+        const inlineCallback = activeInlineDialogRef.current?.request.callbackId?.trim() || null;
         return {
             agentId: currentAgentId,
             isSubmitting,
@@ -4914,6 +4959,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             totalToolCallCount,
             incompleteToolCallCount,
             recentToolUiEvents,
+            activeInlineDialogCallbackId: inlineCallback,
+            pendingDialogReplayCallbackIds: Array.from(pendingDialogReplayCallbackIdsRef.current),
         };
     }, [
         assistantGroupCount,
@@ -4934,20 +4981,78 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         recentToolUiEvents,
         totalToolCallCount,
         agent?.statusMessage,
+        activeInlineDialog,
     ]);
+    // Mirror the latest snapshot/diagnostics so the one-shot replay verify timer can read
+    // them after the polling effect's closure has gone stale.
+    useEffect(() => {
+        runDiagnosticsSnapshotRef.current = runDiagnosticsSnapshot;
+    }, [runDiagnosticsSnapshot]);
+    // Reset all per-agent recovery state when the active agent changes.
+    useEffect(() => {
+        recoveryStateByAgentRef.current.clear();
+        if (replayVerifyTimeoutRef.current) {
+            clearTimeout(replayVerifyTimeoutRef.current);
+            replayVerifyTimeoutRef.current = null;
+        }
+        setShowStaleAgentBanner(false);
+    }, [currentAgentId]);
+    // When the editor socket reconnects (socketConnectionVersion bump) clear the stale
+    // banner — the registry has just re-issued subscriptions, so any "stuck" state should
+    // resolve on the next poll. If it doesn't, the banner will reappear.
+    useEffect(() => {
+        setShowStaleAgentBanner(false);
+    }, [editContext?.socketConnectionVersion]);
     useEffect(() => {
         if (!effectiveIsVisible || !isExecuting || !currentAgentId) {
             return;
         }
         let disposed = false;
+        const agentIdAtMount = currentAgentId;
+        const getRecoveryState = () => {
+            let state = recoveryStateByAgentRef.current.get(agentIdAtMount);
+            if (!state) {
+                state = createRecoveryStateSlice();
+                recoveryStateByAgentRef.current.set(agentIdAtMount, state);
+            }
+            return state;
+        };
+        const logRecoveryEvent = (kind, payload) => {
+            try {
+                appendToolUiEvent(`recovery:${kind}`, JSON.stringify({ agentId: agentIdAtMount, ...payload }));
+            }
+            catch {
+                // Telemetry must never throw out of the polling path.
+            }
+        };
+        const clearVerifyTimer = () => {
+            if (replayVerifyTimeoutRef.current) {
+                clearTimeout(replayVerifyTimeoutRef.current);
+                replayVerifyTimeoutRef.current = null;
+            }
+        };
+        const tryReconnect = (state, reason) => {
+            const now = Date.now();
+            if (state.lastReconnectAt > 0 &&
+                now - state.lastReconnectAt < 60_000) {
+                logRecoveryEvent("reconnect-cooldown", { reason });
+                return false;
+            }
+            state.lastReconnectAt = now;
+            const closed = forceEditorSocketReconnect(reason);
+            logRecoveryEvent("reconnect-started", { reason, closed });
+            return true;
+        };
         const checkServerCompletion = async () => {
             try {
-                const diagnostics = await getAgentDiagnostics(currentAgentId, editContext?.sessionId);
+                const diagnostics = await getAgentDiagnostics(agentIdAtMount, editContext?.sessionId);
                 if (disposed) {
                     return;
                 }
+                lastDiagnosticsResponseRef.current = diagnostics;
                 const serverStatus = diagnostics.execution?.status;
                 if (isFinishedServerExecutionStatus(serverStatus)) {
+                    setShowStaleAgentBanner(false);
                     settleCompletedRun(normalizeServerExecutionStatus(serverStatus) === "cancelled"
                         ? "cancelled"
                         : "completed");
@@ -4970,58 +5075,117 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     isWaitingRef.current = false;
                     setIsConnecting(false);
                     setIsAgentThinking(false);
+                    setShowStaleAgentBanner(false);
                     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 snapshot = runDiagnosticsSnapshot;
+                if (!editContext?.socketDiagnostics) {
+                    // No edit context to read socket diagnostics from — recovery decisions need it,
+                    // and without it we'd misclassify the stream. Wait for the next tick.
+                    return;
+                }
+                const summary = interpretAgentRunDiagnostics({
+                    socketDiagnostics: editContext.socketDiagnostics,
+                    localSnapshot: snapshot,
+                    serverDiagnostics: diagnostics,
+                });
+                const state = getRecoveryState();
                 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();
+                reconcilePendingDialogTracker(state, diagnostics.pendingDialogs, now);
+                // --- Verify-window resolution. Structured to avoid the "expired branch
+                // unreachable" pitfall: first check whether a verify is in flight, then branch on
+                // whether it's still inside the window or just expired.
+                if (state.lastReplayVerifyDeadlineAt > 0) {
+                    if (now < state.lastReplayVerifyDeadlineAt) {
+                        // Still inside the 4s window — leave verification to the one-shot timer.
+                        return;
                     }
-                    catch (loadError) {
-                        console.warn("[AgentTerminal] Failed to reload agent during stream recovery", loadError);
+                    const verified = checkReplayVerified(state, snapshot, diagnostics);
+                    state.lastReplayVerifyDeadlineAt = 0;
+                    state.lastReplayVerifySnapshot = null;
+                    logRecoveryEvent(verified ? "replay-succeeded" : "replay-failed", { kind: "poll", summaryCode: summary.code });
+                    if (verified) {
+                        setShowStaleAgentBanner(false);
+                        return;
                     }
-                    try {
-                        const socket = globalThis.editorSocket;
-                        if (socket && socket.readyState === WebSocket.OPEN) {
-                            socket.close(4000, "agent-stream-lag");
+                    // Fall through — decideRecoveryAction will likely return "reconnect" now.
+                }
+                const decision = decideRecoveryAction({
+                    summary,
+                    localSnapshot: snapshot,
+                    serverDiagnostics: diagnostics,
+                    recoveryState: state,
+                    now,
+                });
+                state.lastDecidedAction = decision.action;
+                logRecoveryEvent("decided", {
+                    action: decision.action,
+                    summaryCode: summary.code,
+                    reasonCode: decision.reasonCode,
+                    replayKey: decision.replayKey,
+                });
+                switch (decision.action) {
+                    case "replay": {
+                        const sent = requestAgentSubscriptionReplay(agentIdAtMount);
+                        if (!sent) {
+                            tryReconnect(state, "agent-recovery-replay-no-socket");
+                            break;
                         }
+                        const serverLastSeq = diagnostics.currentSession?.lastDelivery?.lastSeq ??
+                            diagnostics.transport?.lastSeq ??
+                            null;
+                        const replayCallbackId = decision.replayKey?.split("|").pop() ?? null;
+                        state.lastReplayKey = decision.replayKey;
+                        state.lastReplayAt = now;
+                        state.lastReplayVerifyDeadlineAt = now + 4_000;
+                        state.lastReplayVerifySnapshot = {
+                            localSeq: snapshot.lastSeq,
+                            serverLastSeq,
+                            pendingDialogCallbackId: replayCallbackId === "none" ? null : replayCallbackId,
+                        };
+                        clearVerifyTimer();
+                        replayVerifyTimeoutRef.current = setTimeout(() => {
+                            replayVerifyTimeoutRef.current = null;
+                            if (disposed)
+                                return;
+                            const latestSnapshot = runDiagnosticsSnapshotRef.current ?? snapshot;
+                            const latestDiagnostics = lastDiagnosticsResponseRef.current;
+                            const verified = checkReplayVerified(state, latestSnapshot, latestDiagnostics);
+                            state.lastReplayVerifyDeadlineAt = 0;
+                            state.lastReplayVerifySnapshot = null;
+                            logRecoveryEvent(verified ? "replay-succeeded" : "replay-failed", { kind: "one-shot" });
+                            if (verified) {
+                                setShowStaleAgentBanner(false);
+                            }
+                            // Do not auto-escalate from here; the next poll will see the failed verify
+                            // and ask decideRecoveryAction for the next step (typically reconnect).
+                        }, 4_000);
+                        logRecoveryEvent("replay-started", {
+                            replayKey: decision.replayKey,
+                            summaryCode: summary.code,
+                            serverLastSeq,
+                            localSeq: snapshot.lastSeq,
+                        });
+                        break;
                     }
-                    catch (socketError) {
-                        console.warn("[AgentTerminal] Failed to reconnect stale agent stream socket", socketError);
+                    case "reconnect": {
+                        tryReconnect(state, "agent-recovery-escalation");
+                        break;
                     }
-                    finally {
-                        window.setTimeout(() => {
-                            streamRecoveryInFlightRef.current = false;
-                        }, 5_000);
+                    case "stale": {
+                        setShowStaleAgentBanner(true);
+                        logRecoveryEvent("stale", {
+                            summaryCode: summary.code,
+                            reasonCode: decision.reasonCode,
+                        });
+                        break;
                     }
+                    case "none":
+                        break;
                 }
             }
             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.
@@ -5031,16 +5195,18 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             disposed = true;
             window.clearTimeout(timeoutId);
             window.clearInterval(intervalId);
+            clearVerifyTimer();
         };
     }, [
         currentAgentId,
         editContext?.sessionId,
         editContext?.socketConnectionVersion,
+        editContext?.socketDiagnostics,
         effectiveIsVisible,
         isExecuting,
         appendToolUiEvent,
         clearHeartbeatMessages,
-        loadAgent,
+        runDiagnosticsSnapshot,
         settleCompletedRun,
     ]);
     const showInitialThinkingSplash = messages.length === 0 &&
@@ -5200,6 +5366,33 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             "Waiting for capacity. The agent will start automatically when a slot becomes available.";
         return _jsx(AgentCapacityBanner, { message: message });
     };
+    const renderStaleAgentBanner = () => {
+        if (!showStaleAgentBanner || !currentAgentId)
+            return null;
+        const handleRefreshStream = () => {
+            const state = recoveryStateByAgentRef.current.get(currentAgentId);
+            if (state) {
+                state.lastReplayKey = null;
+                state.lastReplayAt = 0;
+            }
+            requestAgentSubscriptionReplay(currentAgentId);
+            void loadAgent();
+            setShowStaleAgentBanner(false);
+        };
+        const handleReconnect = () => {
+            const state = recoveryStateByAgentRef.current.get(currentAgentId);
+            if (state) {
+                state.lastReconnectAt = 0;
+            }
+            forceEditorSocketReconnect("user-stale-agent-action");
+            setShowStaleAgentBanner(false);
+        };
+        const handleCancel = () => {
+            void handleStop();
+            setShowStaleAgentBanner(false);
+        };
+        return (_jsxs("div", { role: "status", className: "m-3 rounded border border-amber-300 bg-amber-50 p-3 text-[12px] text-amber-900", children: [_jsx("p", { className: "font-medium", children: "Agent run looks stuck" }), _jsx("p", { className: "mt-1 text-[11px] text-amber-800", children: "The backend reports this run is still active, but recent recovery attempts did not resolve the stream. Pick an action below \u2014 automatic retries are paused until then." }), _jsxs("div", { className: "mt-2 flex flex-wrap gap-2", children: [_jsx(Button, { size: "sm", variant: "outline", onClick: handleRefreshStream, children: "Refresh stream" }), _jsx(Button, { size: "sm", variant: "outline", onClick: handleReconnect, children: "Reconnect socket" }), _jsx(Button, { size: "sm", variant: "outline", onClick: handleCancel, children: "Cancel agent" })] })] }));
+    };
     const renderBrowserClaimBanner = (variant = "inline") => {
         if (!agent?.id || !editContext?.sessionId)
             return null;
@@ -5323,7 +5516,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 ? getOperationsForMessageGroup(summaryMessages, agentOperations)
                 : [];
             return (_jsxs("div", { className: `flex h-full min-h-0 flex-col ${className || ""}`, children: [fixedBrowserClaimBanner, error &&
-                        !isAgentErrorStatusValue((agent || agentStub)?.status) && (_jsx("div", { className: "m-4 rounded-lg border-l-4 border-red-500 bg-red-50 p-3 select-text", children: _jsxs("div", { className: "flex items-start", children: [_jsx(AlertCircle, { className: "mt-0.5 h-5 w-5 text-red-400", strokeWidth: 1 }), _jsxs("div", { className: "ml-3", children: [_jsx("p", { className: "text-[11px] font-medium text-red-800", children: "Error" }), _jsx("p", { className: "mt-1 text-[11px] text-red-700", children: error })] })] }) })), renderCapacityBanner(), renderErrorBanner(), _jsxs("div", { ref: messagesContainerRef, className: "flex-1 overflow-y-auto", onScroll: handleScroll, children: [showInitialThinkingSplash && (_jsx(InitialThinkingSplash, { svgIcon: activeProfile?.svgIcon })), inlineBrowserClaimBanner, inlineDialog ? (inlineDialog) : latestSummaryAssistantGroup ? (_jsx("div", { className: "space-y-0 divide-y divide-gray-100 select-text", children: _jsx(AiResponseMessage, { messages: summaryMessages, finished: !latestSummaryAssistantGroup.isLastGroup || !isExecuting, editOperations: summaryOperations, defaultCollapseJson: defaultCollapseJson, profileSvgIcon: activeProfile?.svgIcon, agentId: agent?.id || agentStub.id, agentName: activeProfile?.agentName ||
+                        !isAgentErrorStatusValue((agent || agentStub)?.status) && (_jsx("div", { className: "m-4 rounded-lg border-l-4 border-red-500 bg-red-50 p-3 select-text", children: _jsxs("div", { className: "flex items-start", children: [_jsx(AlertCircle, { className: "mt-0.5 h-5 w-5 text-red-400", strokeWidth: 1 }), _jsxs("div", { className: "ml-3", children: [_jsx("p", { className: "text-[11px] font-medium text-red-800", children: "Error" }), _jsx("p", { className: "mt-1 text-[11px] text-red-700", children: error })] })] }) })), renderCapacityBanner(), renderErrorBanner(), renderStaleAgentBanner(), _jsxs("div", { ref: messagesContainerRef, className: "flex-1 overflow-y-auto", onScroll: handleScroll, children: [showInitialThinkingSplash && (_jsx(InitialThinkingSplash, { svgIcon: activeProfile?.svgIcon })), inlineBrowserClaimBanner, inlineDialog ? (inlineDialog) : latestSummaryAssistantGroup ? (_jsx("div", { className: "space-y-0 divide-y divide-gray-100 select-text", children: _jsx(AiResponseMessage, { messages: summaryMessages, finished: !latestSummaryAssistantGroup.isLastGroup || !isExecuting, editOperations: summaryOperations, defaultCollapseJson: defaultCollapseJson, profileSvgIcon: activeProfile?.svgIcon, agentId: agent?.id || agentStub.id, agentName: activeProfile?.agentName ||
                                         activeProfile?.displayTitle ||
                                         activeProfile?.name, allPendingApprovals: allPendingApprovals, onSwitchToAutonomous: handleSwitchToAutonomous, browserCaptureInlinePrompt: browserCaptureInlinePrompt, readOnly: readOnly, onQuickAction: (action) => {
                                         const text = (action.prompt ||