@tea-agent/loop-agent 0.38.1 → 0.38.2

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

@@ -1,8 +1,8 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
-import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, } from "./turn-stream-controller.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";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -57,7 +57,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, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
     const { setInput, setPendingImages } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -78,9 +78,10 @@ export function useChatStream(params) {
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
         setStreaming(false);
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    }, [refs, 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
@@ -242,13 +243,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 stop (pi-web parity): the abort signal kills the SDK
-        // process tree promptly, so flip the UI idle NOW instead of holding
-        // the busy spinner through the whole POST /abort round-trip. If the
-        // server later reports the turn still running (TURN_ABORT_PENDING
-        // or owner-lost reconcile), applyAbortDecision restores busy state.
+        // 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.
         refs.streamingRef.current = false;
         setStreaming(false);
+        setTurnPhase("stopping");
         setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
@@ -283,6 +283,7 @@ export function useChatStream(params) {
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
+                setTurnPhase(turnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -290,6 +291,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)
@@ -310,11 +312,13 @@ export function useChatStream(params) {
             // so the turn is not silently dropped; /state reconcile converges.
             refs.streamingRef.current = true;
             setStreaming(true);
+            setTurnPhase("stopping");
         }
     }, [
         origin,
         refs,
         setStreaming,
+        setTurnPhase,
         markIdleIfCurrent,
         fetchSessionState,
         noticeSink,
@@ -364,10 +368,12 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase(turnPhaseFromOwnership(bag));
     }, [
         refs,
         noticeSink,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
         setPendingImages,
         watchSessionTitle,
@@ -376,10 +382,190 @@ export function useChatStream(params) {
         setError,
         postAbortForTurn,
     ]);
+    const queueDeferredTurn = useCallback(async (input) => {
+        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);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice(existing ? "已更新停止后发送的消息" : "已排队，将在上一轮停止后自动发送");
+        };
+        const acceptDispatched = () => {
+            setDeferredTurn(null);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice("消息已进入发送");
+        };
+        const putOnce = async () => {
+            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: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    text: input.text,
+                    images: input.images,
+                    ...(existing ? { expectedRevision: existing.revision } : {}),
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            return { response, body };
+        };
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const { response, body } = await putOnce();
+                if (response.ok && body.accepted && body.deferredTurn) {
+                    acceptDeferred(body.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (body.deferredTurn)
+                    setDeferredTurn(body.deferredTurn);
+                if (body.error?.code !== "TURN_NOT_STOPPING") {
+                    setError(body.error?.message ??
+                        `待发送消息未被服务端接受（HTTP ${response.status}）`);
+                    return { action: "handled" };
+                }
+                const canonical = await fetchSessionState(activeSession.sessionId);
+                const decision = reconcileDeferredSubmissionFromState({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    state: canonical ?? undefined,
+                });
+                if (decision.action === "deferred") {
+                    acceptDeferred(decision.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (decision.action === "accepted") {
+                    acceptDispatched();
+                    return { action: "handled" };
+                }
+                if (decision.action === "retry-deferred" && attempt === 0)
+                    continue;
+                if (decision.action === "send-now" && !existing) {
+                    showNotice("上一轮已停止，正在发送当前消息…");
+                    return { action: "send-now" };
+                }
+                setError(body.error?.message ?? "停止状态已变化，当前消息仍保留在输入框");
+                return { action: "handled" };
+            }
+            return { action: "handled" };
+        }
+        catch (error) {
+            const canonical = await fetchSessionState(activeSession.sessionId);
+            const decision = reconcileDeferredSubmissionFromState({
+                clientRequestId: input.clientRequestId,
+                blockedByTurnId: input.blockedByTurnId,
+                state: canonical ?? undefined,
+            });
+            if (decision.action === "deferred") {
+                acceptDeferred(decision.deferredTurn);
+                return { action: "handled" };
+            }
+            if (decision.action === "accepted") {
+                acceptDispatched();
+                return { action: "handled" };
+            }
+            if (decision.action === "send-now" && !existing) {
+                showNotice("上一轮已停止，正在发送当前消息…");
+                return { action: "send-now" };
+            }
+            setError(error instanceof Error
+                ? `无法确认消息是否已排队：${error.message}`
+                : "无法确认消息是否已排队，请刷新后查看服务端状态");
+            return { action: "handled" };
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+        fetchSessionState,
+    ]);
+    const cancelDeferredTurn = useCallback(async () => {
+        const activeSession = refs.sessionRef.current;
+        const deferred = thread.deferredTurn;
+        if (!activeSession || !deferred)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "DELETE",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: deferred.clientRequestId,
+                    expectedRevision: deferred.revision,
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.cancelled) {
+                setError(body.error?.message ?? "待发送消息撤回失败");
+                return;
+            }
+            setDeferredTurn(null);
+            setInput(body.deferredTurn?.text ?? "");
+            setPendingImages(body.deferredTurn?.images ?? []);
+            setError(null);
+            showNotice("待发送消息已移回输入框");
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+    ]);
     const sendPrompt = useCallback(async (text, images) => {
+        const initialSession = refs.sessionRef.current;
+        if (!initialSession || (!text.trim() && images.length === 0))
+            return;
+        const ownership = ownershipBagFromRefs(refs);
+        const route = decideSubmissionRoute({
+            turnPhase: turnPhaseFromOwnership(ownership),
+            blockedByTurnId: ownership.stoppingTurnId ?? ownership.activeTurnId,
+        });
+        const clientRequestId = requestId("chat-submit");
+        if (route.action === "hold") {
+            if (turnPhaseFromOwnership(ownership) === "stopping")
+                showNotice("正在确认上一轮停止状态，当前消息已保留");
+            return;
+        }
+        if (route.action === "queue-deferred") {
+            const deferred = await queueDeferredTurn({
+                text,
+                images,
+                clientRequestId,
+                blockedByTurnId: route.blockedByTurnId,
+            });
+            if (deferred.action !== "send-now")
+                return;
+        }
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
+            activeSession.sessionId !== initialSession.sessionId ||
             (!text.trim() && images.length === 0) ||
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
@@ -389,7 +575,6 @@ export function useChatStream(params) {
         // AC-001: acquire synchronous submit ownership before the first await.
         refs.submitInFlightRef.current = true;
         const submitGeneration = ++refs.submitGenerationRef.current;
-        const clientRequestId = requestId("chat-submit");
         const userMessageId = requestId("u");
         const assistantId = requestId("a");
         const draftText = text.trim();
@@ -437,6 +622,7 @@ export function useChatStream(params) {
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
+        setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
@@ -532,7 +718,9 @@ export function useChatStream(params) {
         setAutoScroll,
         setError,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
+        queueDeferredTurn,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -548,6 +736,7 @@ export function useChatStream(params) {
             notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase("stopping");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -656,6 +845,9 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
+                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    if (state && "deferredTurn" in state)
+                        setDeferredTurn(state.deferredTurn ?? null);
                     if (result === "bound") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
@@ -755,6 +947,7 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
+        setTurnPhase,
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
@@ -776,5 +969,5 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, openEventsStream };
+    return { sendPrompt, handleStop, cancelDeferredTurn, openEventsStream };
 }

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

@@ -31,6 +31,8 @@ export function useChatThread(params) {
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [streaming, setStreaming] = useState(false);
+    const [turnPhase, setTurnPhase] = useState("idle");
+    const [deferredTurn, setDeferredTurn] = useState(null);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
@@ -44,6 +46,8 @@ export function useChatThread(params) {
         setHumanGateCards,
         setArtifactCards,
         setStreaming,
+        setTurnPhase,
+        setDeferredTurn,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -190,6 +194,8 @@ export function useChatThread(params) {
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
         setStreaming(false);
+        setTurnPhase("idle");
+        setDeferredTurn(null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -207,6 +213,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(next.streaming);
+        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setDeferredTurn(next.deferredTurn ?? null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -228,6 +236,8 @@ export function useChatThread(params) {
             const activeTurnId = body.session.activeTurnId ?? null;
             refs.activeTurnIdRef.current = activeTurnId;
             refs.streamingRef.current = Boolean(activeTurnId);
+            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            setDeferredTurn(body.session.deferredTurn ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -246,7 +256,15 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setToolCalls, setStreamingAssistantId]);
+    }, [
+        origin,
+        refs,
+        setMessages,
+        setToolCalls,
+        setStreamingAssistantId,
+        setTurnPhase,
+        setDeferredTurn,
+    ]);
     return {
         messages,
         setMessages,
@@ -265,6 +283,10 @@ export function useChatThread(params) {
         usage,
         streaming,
         setStreaming,
+        turnPhase,
+        setTurnPhase,
+        deferredTurn,
+        setDeferredTurn,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,