@parhelia/core 0.1.11151 → 0.1.11180

package/dist/editor/ai/AgentTerminal.js

@@ -559,6 +559,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     useEffect(() => {
         isWaitingRef.current = isWaitingForResponse;
     }, [isWaitingForResponse]);
+    // Guard ref to prevent WebSocket handlers from re-enabling execution states
+    // while a stop operation is in progress. This prevents race conditions where
+    // messages arriving during the stop process could flip the UI back to "executing".
+    const isStoppingRef = useRef(false);
     // Server-driven state: true when agent is actively processing (set by WebSocket messages)
     const [isAgentThinking, setIsAgentThinking] = useState(false);
     const hasActiveStreaming = useCallback(() => {
@@ -679,7 +683,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     const shouldCreateNewMessage = useRef(false);
     // Keep a ref to the current messages for immediate access
     const messagesRef = useRef([]);
-    const abortControllerRef = useRef(null);
     const messagesEndRef = useRef(null);
     const textareaRef = useRef(null);
     const placeholderInputRef = useRef(null);
@@ -1705,6 +1708,12 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
             return;
         // Handle agent:run:start
         if (messageType === "agent:run:start") {
+            // If a stop operation is in progress, ignore this message to prevent
+            // race conditions where the UI flips back to "executing" during stop
+            if (isStoppingRef.current) {
+                console.log("[AgentTerminal] Ignoring agent:run:start during stop operation");
+                return;
+            }
             // Reset run-scoped deduplication so new run seq values (starting at 1)
             // are not discarded due to previous run's lastSeqRef
             lastSeqRef.current = 0;
@@ -1820,6 +1829,11 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         }
         // Handle agent:run:delta (content, tools, etc.)
         if (messageType === "agent:run:delta") {
+            // If a stop operation is in progress, ignore streaming deltas to prevent
+            // new messages from being added during the stop process
+            if (isStoppingRef.current) {
+                return;
+            }
             // Allow deltas if the agent is running OR if we already have an active streaming message
             // OR if the server provided a messageId for targeted updates.
             // This avoids dropping early deltas that may arrive before the 'running' status update.
@@ -2024,6 +2038,31 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
                     });
                     return;
                 }
+                // Handle "completed" state (fallback for legacy code paths that send status instead of lifecycle event)
+                if (normalizedStatus === "completed" ||
+                    normalizedStatus === "Completed") {
+                    // Reset deduplication for the next run
+                    lastSeqRef.current = 0;
+                    // Mark the last assistant message as completed
+                    setMessages((prev) => {
+                        const updated = prev.map((msg) => msg.role === "assistant" && !msg.isCompleted
+                            ? {
+                                ...msg,
+                                isCompleted: true,
+                                messageType: "completed",
+                            }
+                            : msg);
+                        messagesRef.current = updated;
+                        return updated;
+                    });
+                    setIsWaitingForResponse(false);
+                    isWaitingRef.current = false;
+                    setIsConnecting(false);
+                    shouldCreateNewMessage.current = false;
+                    // Server says agent finished thinking
+                    setIsAgentThinking(false);
+                    return;
+                }
             }
             catch (err) {
                 console.error("[AgentTerminal] Error handling status update:", err);
@@ -2232,14 +2271,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
         }
         setSelectedModelId(nextModelId || undefined);
     }, [activeProfile?.id, agent?.model]);
-    // Cleanup stream connection when component unmounts or agent changes
-    useEffect(() => {
-        return () => {
-            if (abortControllerRef.current) {
-                abortControllerRef.current.abort();
-            }
-        };
-    }, [agent?.id]);
     // Initialize mode from metadata; fall back to agent.Mode from server
     useEffect(() => {
         try {
@@ -2929,39 +2960,45 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, isActive =
     // Stop current execution/stream safely
     const handleStop = useCallback(async () => {
         try {
+            // 1. Set the stopping guard to prevent WebSocket handlers from re-enabling states
+            // This must happen FIRST, before any other state changes
+            isStoppingRef.current = true;
+            // 2. Update all UI state to reflect stopped status
             setIsWaitingForResponse(false);
             isWaitingRef.current = false;
+            setIsConnecting(false);
+            setIsSubmitting(false);
             // User stopped the agent, hide thinking dots
             setIsAgentThinking(false);
-            // Request backend to stop the current execution (does NOT close the agent)
+            // 3. Mark any in-progress streaming messages as completed in UI
+            setMessages((prev) => {
+                const updated = prev.map((msg) => !msg.isCompleted && msg.messageType === "streaming"
+                    ? { ...msg, isCompleted: true, messageType: "completed" }
+                    : msg);
+                messagesRef.current = updated;
+                return updated;
+            });
+            // 4. Request backend to stop the current execution (does NOT close the agent)
+            // Wait for backend confirmation to ensure agent actually stopped
             if (agentStub?.id) {
                 try {
                     await cancelAgent(agentStub.id);
                 }
                 catch (err) {
                     console.error("Failed to cancel agent on backend:", err);
-                    // Continue with UI cleanup even if backend call fails
+                    // Continue - UI is already in stopped state, but backend may still be running
+                    // The isStoppingRef guard will be cleared below so future runs can proceed
                 }
             }
-            // Disconnect from the stream
-            if (abortControllerRef.current) {
-                abortControllerRef.current.abort();
-                abortControllerRef.current = null;
-            }
-            setIsConnecting(false);
-            setIsSubmitting(false);
-            // Mark any in-progress streaming messages as completed in UI
-            setMessages((prev) => {
-                const updated = prev.map((msg) => !msg.isCompleted && msg.messageType === "streaming"
-                    ? { ...msg, isCompleted: true, messageType: "completed" }
-                    : msg);
-                messagesRef.current = updated;
-                return updated;
-            });
         }
         catch (e) {
             console.error("Failed to stop agent execution", e);
         }
+        finally {
+            // Clear the stopping guard so future runs can proceed normally
+            // This happens after backend confirmation (or error)
+            isStoppingRef.current = false;
+        }
     }, []);
     // Determine effective cost limit from agent, profile, or metadata so the cost display
     // is visible immediately even before any messages or server-side persistence.