@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -2,7 +2,7 @@ import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
 import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, decideSubmissionRoute, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcileDeferredSubmissionFromState, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, } from "./turn-stream-controller.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -46,6 +46,7 @@ function sseEventName(block) {
 function sleepBriefly() {
     return new Promise((resolve) => window.setTimeout(resolve, 25));
 }
+const STOP_RECONCILE_DELAYS_MS = [100, 250, 500, 1_000, 2_000];
 function clearEmptyAssistant(setMessages, assistantId) {
     if (!assistantId)
         return;
@@ -57,7 +58,7 @@ function clearEmptyAssistant(setMessages, assistantId) {
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
     const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
-    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, setDeferredTurns, } = thread;
     const { setInput, setPendingImages, recordHistory } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -73,15 +74,26 @@ export function useChatStream(params) {
         if (refs.sessionRef.current?.sessionId !== sessionId ||
             refs.sessionGenerationRef.current !== generation)
             return;
+        const pendingClientRequestId = refs.pendingSubmissionRef.current?.clientRequestId;
+        if (pendingClientRequestId)
+            releaseSubmitOwnership(pendingClientRequestId);
         refs.streamingRef.current = false;
         refs.activeTurnIdRef.current = null;
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
+        refs.stopRequestedRef.current = false;
         setStreaming(false);
         setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setTurnPhase, setStreamingAssistantId, setMessages]);
+    }, [
+        refs,
+        releaseSubmitOwnership,
+        setStreaming,
+        setTurnPhase,
+        setStreamingAssistantId,
+        setMessages,
+    ]);
     /** Follow one session's event stream until it is explicitly aborted. The
      * server's `stream_ready` marker separates replay from live events; this
      * means replay cannot render duplicate messages while live text remains
@@ -243,12 +255,12 @@ export function useChatStream(params) {
     /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
     const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
         refs.stoppingTurnIdRef.current = turnId;
-        // Optimistic visual stop: remove the running spinner immediately, but
-        // retain ownership as `stopping` until the server proves a terminal state.
-        // This keeps the composer responsive without falsely advertising idle.
+        // DSH-style visual stop: the composer becomes idle immediately. Hidden
+        // ownership remains stopping so a new message routes to the durable queue
+        // until terminal evidence proves the old Turn is gone.
         refs.streamingRef.current = false;
         setStreaming(false);
-        setTurnPhase("stopping");
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
@@ -277,13 +289,17 @@ export function useChatStream(params) {
                 const state = await fetchSessionState(sessionId);
                 const stillCurrent = refs.sessionRef.current?.sessionId === sessionId &&
                     refs.sessionGenerationRef.current === generation;
+                // Terminal SSE may settle the Turn while /state is in flight. Do not
+                // write the pre-request ownership snapshot back after that newer fact.
+                if (!stillCurrent || refs.stoppingTurnIdRef.current !== turnId)
+                    return;
                 applyAbortDecision(bag, decision, noticeSink(), {
-                    sessionStillCurrent: stillCurrent,
+                    sessionStillCurrent: true,
                     runtimeBusy: isRuntimeBusyUnion(state ?? undefined),
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
-                setTurnPhase(turnPhaseFromOwnership(bag));
+                setTurnPhase(visualTurnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -291,11 +307,7 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
-            setTurnPhase(turnPhaseFromOwnership(bag));
-            // Sync the post-decision busy state back to React: optimistic stop
-            // flipped it idle up front; pending/keep-busy outcomes restore it.
-            if (bag.streaming)
-                setStreaming(true);
+            setTurnPhase(visualTurnPhaseFromOwnership(bag));
         }
         catch {
             // Abort network failure: keep busy (UIS-abort-network-fail).
@@ -308,11 +320,11 @@ export function useChatStream(params) {
                 networkError: true,
             }), noticeSink());
             applyOwnershipBagToRefs(refs, bag);
-            // Network failure: the optimistic idle was premature — restore busy
-            // so the turn is not silently dropped; /state reconcile converges.
-            refs.streamingRef.current = true;
-            setStreaming(true);
-            setTurnPhase("stopping");
+            // Transport failure is ambiguous: keep the visual composer available,
+            // retain hidden ownership, and let the short /state backoff converge.
+            refs.streamingRef.current = false;
+            setStreaming(false);
+            setTurnPhase("idle");
         }
     }, [
         origin,
@@ -368,7 +380,13 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
-        setTurnPhase(turnPhaseFromOwnership(bag));
+        const ownershipPhase = turnPhaseFromOwnership(bag);
+        setTurnPhase(visualTurnPhaseFromOwnership(bag));
+        if (ownershipPhase === "stopping") {
+            refs.streamingRef.current = false;
+            setStreaming(false);
+            setStreamingAssistantId(null);
+        }
     }, [
         refs,
         noticeSink,
@@ -386,17 +404,18 @@ export function useChatStream(params) {
         const activeSession = refs.sessionRef.current;
         if (!activeSession || (!input.text.trim() && input.images.length === 0))
             return { action: "handled" };
-        const existing = thread.deferredTurn;
         showNotice("正在排队…");
-        const acceptDeferred = (deferredTurn) => {
-            setDeferredTurn(deferredTurn);
+        const acceptDeferred = (deferredTurn, deferredTurns) => {
+            setDeferredTurn(deferredTurns?.[0] ?? deferredTurn);
+            setDeferredTurns(deferredTurns ?? [deferredTurn]);
             setInput("");
             setPendingImages([]);
             setError(null);
-            showNotice(existing ? "已更新排队消息" : "已排队，将在当前回合结束后自动发送");
+            showNotice("已排队，将在当前回合结束后自动发送");
         };
         const acceptDispatched = () => {
             setDeferredTurn(null);
+            setDeferredTurns([]);
             setInput("");
             setPendingImages([]);
             setError(null);
@@ -415,7 +434,6 @@ export function useChatStream(params) {
                     blockedByTurnId: input.blockedByTurnId,
                     text: input.text,
                     images: input.images,
-                    ...(existing ? { expectedRevision: existing.revision } : {}),
                 }),
             });
             const body = (await response.json().catch(() => ({})));
@@ -425,9 +443,11 @@ export function useChatStream(params) {
             for (let attempt = 0; attempt < 2; attempt += 1) {
                 const { response, body } = await putOnce();
                 if (response.ok && body.accepted && body.deferredTurn) {
-                    acceptDeferred(body.deferredTurn);
+                    acceptDeferred(body.deferredTurn, body.deferredTurns);
                     return { action: "handled" };
                 }
+                if (body.deferredTurns)
+                    setDeferredTurns(body.deferredTurns);
                 if (body.deferredTurn)
                     setDeferredTurn(body.deferredTurn);
                 if (body.error?.code !== "TURN_NOT_ACTIVE") {
@@ -442,7 +462,7 @@ export function useChatStream(params) {
                     state: canonical ?? undefined,
                 });
                 if (decision.action === "deferred") {
-                    acceptDeferred(decision.deferredTurn);
+                    acceptDeferred(decision.deferredTurn, canonical?.deferredTurns);
                     return { action: "handled" };
                 }
                 if (decision.action === "accepted") {
@@ -451,7 +471,7 @@ export function useChatStream(params) {
                 }
                 if (decision.action === "retry-deferred" && attempt === 0)
                     continue;
-                if (decision.action === "send-now" && !existing) {
+                if (decision.action === "send-now") {
                     showNotice("上一轮已停止，正在发送当前消息…");
                     return { action: "send-now" };
                 }
@@ -468,14 +488,14 @@ export function useChatStream(params) {
                 state: canonical ?? undefined,
             });
             if (decision.action === "deferred") {
-                acceptDeferred(decision.deferredTurn);
+                acceptDeferred(decision.deferredTurn, canonical?.deferredTurns);
                 return { action: "handled" };
             }
             if (decision.action === "accepted") {
                 acceptDispatched();
                 return { action: "handled" };
             }
-            if (decision.action === "send-now" && !existing) {
+            if (decision.action === "send-now") {
                 showNotice("上一轮已停止，正在发送当前消息…");
                 return { action: "send-now" };
             }
@@ -489,6 +509,7 @@ export function useChatStream(params) {
         refs,
         thread.deferredTurn,
         setDeferredTurn,
+        setDeferredTurns,
         setInput,
         setPendingImages,
         setError,
@@ -497,9 +518,11 @@ export function useChatStream(params) {
     ]);
     /** DELETE the queued turn; "restore" moves its text back into the composer,
      *  "discard" drops it entirely (2026-08-23 queue chip actions). */
-    const requestDeferredTurnDelete = useCallback(async (mode) => {
+    const requestDeferredTurnDelete = useCallback(async (mode, target) => {
         const activeSession = refs.sessionRef.current;
-        const deferred = thread.deferredTurn;
+        const deferred = target
+            ? thread.deferredTurns.find((item) => item.clientRequestId === target.clientRequestId)
+            : thread.deferredTurns[0] ?? thread.deferredTurn;
         if (!activeSession || !deferred)
             return;
         try {
@@ -520,10 +543,12 @@ export function useChatStream(params) {
                 setError(body.error?.message ?? "待发送消息撤回失败");
                 return;
             }
-            setDeferredTurn(null);
+            const remaining = thread.deferredTurns.filter((item) => item.clientRequestId !== deferred.clientRequestId);
+            setDeferredTurns(remaining);
+            setDeferredTurn(remaining[0] ?? null);
             if (mode === "restore") {
-                setInput(body.deferredTurn?.text ?? "");
-                setPendingImages(body.deferredTurn?.images ?? []);
+                setInput(deferred.text ?? body.deferredTurn?.text ?? "");
+                setPendingImages(deferred.images ?? body.deferredTurn?.images ?? []);
                 showNotice("待发送消息已移回输入框");
             }
             else {
@@ -538,14 +563,66 @@ export function useChatStream(params) {
         origin,
         refs,
         thread.deferredTurn,
+        thread.deferredTurns,
         setDeferredTurn,
+        setDeferredTurns,
         setInput,
         setPendingImages,
         setError,
         showNotice,
     ]);
     const cancelDeferredTurn = useCallback(() => requestDeferredTurnDelete("restore"), [requestDeferredTurnDelete]);
-    const discardDeferredTurn = useCallback(() => requestDeferredTurnDelete("discard"), [requestDeferredTurnDelete]);
+    const discardDeferredTurn = useCallback((target) => requestDeferredTurnDelete("discard", target), [requestDeferredTurnDelete]);
+    const editDeferredTurn = useCallback(async (target, text) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession)
+            return;
+        const item = thread.deferredTurns.find((entry) => entry.clientRequestId === target.clientRequestId);
+        if (!item)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json", "x-loop-console-confirmation": confirmationToken() },
+                credentials: "include",
+                body: JSON.stringify({ clientRequestId: target.clientRequestId, blockedByTurnId: item.blockedByTurnId, text, images: item.images ?? [], expectedRevision: target.revision }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok)
+                throw new Error(body.error?.message ?? "编辑排队消息失败");
+            if (body.deferredTurns)
+                setDeferredTurns(body.deferredTurns);
+            if (body.deferredTurn)
+                setDeferredTurn(body.deferredTurn);
+            setError(null);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : "编辑排队消息失败");
+        }
+    }, [origin, refs, thread.deferredTurns, setDeferredTurn, setDeferredTurns, setError]);
+    const steerDeferredTurn = useCallback(async (target) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn/${encodeURIComponent(target.clientRequestId)}/steer`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "x-loop-console-confirmation": confirmationToken() },
+                credentials: "include",
+                body: JSON.stringify({ expectedRevision: target.revision }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok)
+                throw new Error(body.error?.message ?? "插话发送失败");
+            const remaining = body.deferredTurns ?? thread.deferredTurns.filter((item) => item.clientRequestId !== target.clientRequestId);
+            setDeferredTurns(remaining);
+            setDeferredTurn(remaining[0] ?? null);
+            setError(null);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : "插话发送失败");
+        }
+    }, [origin, refs, thread.deferredTurns, setDeferredTurn, setDeferredTurns, setError]);
     const sendPrompt = useCallback(async (text, images) => {
         const initialSession = refs.sessionRef.current;
         if (!initialSession || (!text.trim() && images.length === 0))
@@ -747,10 +824,12 @@ export function useChatStream(params) {
         // Decide + mark intent/coalesce only; POST is issued once below.
         const stopResult = requestStopOnOwnership(bag, {
             postAbort: () => { },
-            notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
-        setTurnPhase("stopping");
+        refs.streamingRef.current = false;
+        setStreaming(false);
+        setStreamingAssistantId(null);
+        setTurnPhase("idle");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -800,7 +879,6 @@ export function useChatStream(params) {
             markStopRequested(lateBag);
             const late = requestStopOnOwnership(lateBag, {
                 postAbort: () => { },
-                notice: noticeSink(),
             });
             applyOwnershipBagToRefs(refs, lateBag);
             if (late.abortedTurnId) {
@@ -810,7 +888,13 @@ export function useChatStream(params) {
         finally {
             refs.stopInFlightRef.current = false;
         }
-    }, [refs, noticeSink, postAbortForTurn]);
+    }, [
+        refs,
+        postAbortForTurn,
+        setStreaming,
+        setStreamingAssistantId,
+        setTurnPhase,
+    ]);
     // State reconciliation is only a status fence: it never consumes/creates
     // message events, and a generation check discards late responses (M5.3).
     // Busy truth = durable activeTurn union runtime busy facts (AC-003/AC-006).
@@ -830,7 +914,8 @@ export function useChatStream(params) {
         const sessionId = session.sessionId;
         const generation = refs.sessionGenerationRef.current;
         let cancelled = false;
-        const sync = async () => {
+        let syncInFlight = null;
+        const runSync = async () => {
             try {
                 const res = await fetch(operatorChatStateUrl(origin, sessionId), {
                     credentials: "include",
@@ -859,10 +944,16 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
-                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    const ownershipPhase = turnPhaseFromOwnership(bag);
+                    setTurnPhase(visualTurnPhaseFromOwnership(bag));
+                    if (ownershipPhase === "stopping") {
+                        refs.streamingRef.current = false;
+                        setStreaming(false);
+                        setStreamingAssistantId(null);
+                    }
                     if (state && "deferredTurn" in state)
                         setDeferredTurn(state.deferredTurn ?? null);
-                    if (result === "bound") {
+                    if (result === "bound" && ownershipPhase !== "stopping") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
                         return;
@@ -940,19 +1031,41 @@ export function useChatStream(params) {
                 // offline/background case: interval, visibility and online retry.
             }
         };
+        const sync = () => {
+            if (syncInFlight)
+                return syncInFlight;
+            syncInFlight = runSync().finally(() => {
+                syncInFlight = null;
+            });
+            return syncInFlight;
+        };
         const onVisible = () => {
             if (document.visibilityState === "visible")
                 void sync();
         };
         const onOnline = () => void sync();
         const interval = window.setInterval(() => void sync(), 15_000);
+        let stopRetryTimer;
+        let stopRetryIndex = 0;
+        const scheduleStopRetry = () => {
+            if (cancelled ||
+                stopRetryIndex >= STOP_RECONCILE_DELAYS_MS.length ||
+                (!refs.stopRequestedRef.current && !refs.stoppingTurnIdRef.current))
+                return;
+            const delay = STOP_RECONCILE_DELAYS_MS[stopRetryIndex++];
+            stopRetryTimer = window.setTimeout(() => {
+                void sync().finally(scheduleStopRetry);
+            }, delay);
+        };
         document.addEventListener("visibilitychange", onVisible);
         window.addEventListener("online", onOnline);
         // Immediate tick so terminal-before-streaming-false races converge promptly.
-        void sync();
+        void sync().finally(scheduleStopRetry);
         return () => {
             cancelled = true;
             window.clearInterval(interval);
+            if (stopRetryTimer !== undefined)
+                window.clearTimeout(stopRetryTimer);
             document.removeEventListener("visibilitychange", onVisible);
             window.removeEventListener("online", onOnline);
         };
@@ -988,6 +1101,8 @@ export function useChatStream(params) {
         handleStop,
         cancelDeferredTurn,
         discardDeferredTurn,
+        editDeferredTurn,
+        steerDeferredTurn,
         openEventsStream,
     };
 }