@tea-agent/loop-agent 0.40.0-next.3 → 0.40.0-next.5

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

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { parseAssistantContent } from "../../chat/assistant-content.js";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
@@ -28,6 +27,9 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         });
         if (!res.ok) {
             const body = (await res.json().catch(() => ({})));
+            if (isMutationGateFailureCode(body.error?.code)) {
+                throw new Error(describeMutationGateFailure(body.error.code));
+            }
             throw new Error(body.error?.message ?? `HTTP ${res.status}`);
         }
         const body = (await res.json());
@@ -36,6 +38,11 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const durable = body.session;
         const created = {
             sessionId: durable.sessionId,
+            ...(durable.workspaceId || input.options?.workspaceId
+                ? {
+                    workspaceId: durable.workspaceId ?? input.options?.workspaceId,
+                }
+                : {}),
             ...runtimeSelectionFromRecord(durable),
         };
         const nextList = [
@@ -56,6 +63,30 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         input.setCreatingSession?.(false);
     }
 }
+function mergeCompactionMessages(messages, compactions) {
+    const result = [...messages];
+    for (const item of compactions ?? []) {
+        const data = item.data && typeof item.data === "object" ? item.data : {};
+        const eventId = typeof item.eventId === "string" ? item.eventId : undefined;
+        const id = eventId ? `compaction-${eventId}` : `compaction-${item.at ?? Date.now()}`;
+        if (result.some((message) => message.id === id))
+            continue;
+        const summary = typeof data.summary === "string" ? data.summary : "历史上下文已精简，关键决策与当前任务已保留。";
+        result.push({
+            id,
+            role: "assistant",
+            kind: "compaction",
+            text: summary,
+            createdAt: Date.parse(item.at ?? "") || Date.now(),
+            compaction: {
+                ...(typeof data.tokensBefore === "number" ? { tokensBefore: data.tokensBefore } : {}),
+                ...(typeof data.firstKeptEntryId === "string" ? { firstKeptEntryId: data.firstKeptEntryId } : {}),
+                ...(eventId ? { eventId } : {}),
+            },
+        });
+    }
+    return result.sort((a, b) => a.createdAt - b.createdAt);
+}
 /** Session lifecycle: list / activate / create / delete / rename-archive /
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
@@ -63,6 +94,21 @@ export function useChatSessions(params) {
     const { applyActivatedSession, resetForNewSession, setMessages } = thread;
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
+    const { workspaceId, blocked } = params;
+    const workspaceQuery = workspaceId
+        ? `?workspaceId=${encodeURIComponent(workspaceId)}`
+        : "";
+    /** AC-002 (2026-08-26): session requests follow the session's DURABLE
+     *  owning workspace, not the global active workspace. The sidebar list
+     *  items carry workspaceId; once a session is activated its owner is kept
+     *  on the session record itself. Switching the Operate/Inspect active
+     *  workspace therefore never retargets an open session's requests. */
+    const sessionOwnerQuery = useCallback((ownerWorkspaceId) => {
+        const owner = ownerWorkspaceId?.trim() ||
+            refs.sessionRef.current?.workspaceId?.trim() ||
+            "";
+        return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
+    }, [refs]);
     const [sessionList, setSessionList] = useState([]);
     const sessionListRef = useRef([]);
     sessionListRef.current = sessionList;
@@ -76,11 +122,15 @@ export function useChatSessions(params) {
     // state. This prevents slow responses from an older selection overwriting a
     // newer user choice.
     const sessionSelectionVersionRef = useRef(0);
-    const resetActiveProjection = useCallback(() => {
-        // M4.5/M5.2: selection is a hard ownership boundary. Abort every request
-        // owned by the old projection, then invalidate its async callbacks.
+    const resetActiveProjection = useCallback((options) => {
+        // M4.5/M5.2: selection is a hard ownership boundary for THIS projection.
+        // Multi-workspace (AC-002): keepStreams=true (workspace switch) aborts
+        // only projection-local requests and leaves background SSE streams of
+        // other sessions/workspaces running.
+        const keepStreams = options?.keepStreams === true;
         refs.sessionGenerationRef.current += 1;
-        refs.abortRef.current?.abort();
+        if (!keepStreams)
+            refs.abortRef.current?.abort();
         refs.reconnectAbortRef.current?.abort();
         for (const controller of refs.sessionAbortControllersRef.current.values())
             controller.abort();
@@ -114,43 +164,36 @@ export function useChatSessions(params) {
         setAutoScroll,
     ]);
     const refreshSessionList = useCallback(async () => {
+        if (blocked)
+            return; // AC-R5-002: fail-closed, zero session requests
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions${workspaceQuery}`, {
                 credentials: "include",
             });
             if (!res.ok)
                 return;
-            const sessions = (await res.json()).sessions ??
-                [];
+            const sessions = (await res.json())
+                .sessions ?? [];
+            // Multi-workspace (AC-002): list only this workspace's sessions when a
+            // scope is active; unscoped (legacy) keeps the full list.
+            const scoped = workspaceId
+                ? sessions.filter((item) => !item.workspaceId || item.workspaceId === workspaceId)
+                : sessions;
             // API returns newest-first; keep only the recent window in the sidebar.
-            const keep = sessions.slice(0, CHAT_SESSION_LIST_LIMIT);
-            const excess = sessions.slice(CHAT_SESSION_LIST_LIMIT);
+            const keep = scoped.slice(0, CHAT_SESSION_LIST_LIMIT);
             setSessionList(keep);
-            if (excess.length === 0)
-                return;
-            await Promise.all(excess.map((item) => fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(item.sessionId)}`, {
-                method: "DELETE",
-                credentials: "include",
-                headers: {
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-            }).catch(() => undefined)));
-            const activeId = refs.sessionRef.current?.sessionId;
-            if (activeId && excess.some((item) => item.sessionId === activeId)) {
-                sessionSelectionVersionRef.current += 1;
-                refs.sessionRef.current = null;
-                resetActiveProjection();
-                setSession(null);
-                window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
-            }
         }
         catch {
             /* Chat remains usable without the sidebar index. */
         }
-    }, [origin, refs, resetActiveProjection, setSession]);
+    }, [origin, workspaceQuery, workspaceId, blocked]);
     const deleteSession = useCallback(async (sessionId) => {
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+            // AC-002: delete follows the session's durable owner, not the
+            // global active workspace.
+            const ownerQuery = sessionOwnerQuery(sessionListRef.current.find((item) => item.sessionId === sessionId)
+                ?.workspaceId ?? null);
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, {
                 method: "DELETE",
                 credentials: "include",
                 headers: {
@@ -183,11 +226,16 @@ export function useChatSessions(params) {
         resetActiveProjection,
         refreshSessionList,
         setError,
+        sessionOwnerQuery,
     ]);
-    const activateSession = useCallback(async (sessionId) => {
+    const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
+        // AC-002: activation targets the session's durable owning workspace —
+        // never the global active workspace (no cross-workspace leak when
+        // Operate/Inspect switch their scope while a session stays open).
+        const ownerQuery = sessionOwnerQuery(ownerWorkspaceId);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, { credentials: "include" });
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, { credentials: "include" });
             const body = (await res.json());
             if (!res.ok || !body.session)
                 throw new Error(body.error?.message ?? "会话不可用");
@@ -195,12 +243,17 @@ export function useChatSessions(params) {
                 return;
             const next = {
                 sessionId: body.session.sessionId,
+                ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
                 ...runtimeSelectionFromRecord(body.session),
             };
-            resetActiveProjection();
+            // AC-002: session switch (same or cross workspace) never aborts other
+            // sessions' background request controllers; the single /events owner is
+            // re-bound by useChatStream's session effect.
+            resetActiveProjection({ keepStreams: true });
             refs.sessionRef.current = next;
             refs.streamingRef.current = Boolean(body.session.activeTurnId);
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
+            refs.streamingRef.current = Boolean(body.session.activeTurnId);
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
@@ -214,13 +267,19 @@ export function useChatSessions(params) {
             setPreviews([]);
             setInput(body.session.composerDraft ?? "");
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
             applyActivatedSession({
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
+                sessionStats: body.sessionStats,
+                usage: body.usage,
                 streaming: Boolean(body.session.activeTurnId),
                 turnPhase: body.session.turnPhase ??
                     (body.session.activeTurnId ? "running" : "idle"),
                 deferredTurn: body.session.deferredTurn ?? null,
+                deferredTurns: body.session.deferredTurns ?? (body.session.deferredTurn ? [body.session.deferredTurn] : []),
+                pendingQuestion: body.session.pendingQuestion ?? null,
+                todos: body.session.todos ?? [],
             });
             window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, sessionId);
             setActivePreviewPath(null);
@@ -241,6 +300,7 @@ export function useChatSessions(params) {
         resetActiveProjection,
         setActivePreviewPath,
         setError,
+        sessionOwnerQuery,
     ]);
     useEffect(() => {
         void refreshSessionList();
@@ -275,19 +335,22 @@ export function useChatSessions(params) {
     // re-read messages and operation refs/facts from the server-owned stores.
     useEffect(() => {
         let cancelled = false;
+        if (blocked)
+            return; // AC-R5-002: unknown workspace — no restore GET
         const savedSessionId = window.localStorage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
         if (!savedSessionId)
             return;
         const selectionVersion = ++sessionSelectionVersionRef.current;
         void (async () => {
             try {
-                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}`, { credentials: "include" });
+                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}${workspaceQuery}`, { credentials: "include" });
                 if (!res.ok) {
                     window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
                     return;
                 }
                 const body = (await res.json());
                 if (cancelled ||
+                    blocked ||
                     selectionVersion !== sessionSelectionVersionRef.current ||
                     !body.session)
                     return;
@@ -309,18 +372,21 @@ export function useChatSessions(params) {
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
                 setInput(body.session.composerDraft ?? "");
-                setMessages((body.session.messages ?? [])
-                    .filter((message) => message.role === "user" || message.role === "assistant")
-                    .map((message) => {
-                    const content = parseAssistantContent(message.content);
-                    return {
-                        id: message.id,
-                        role: message.role,
-                        text: message.text,
-                        createdAt: Date.parse(message.at) || Date.now(),
-                        ...(content && content.length > 0 ? { content } : {}),
-                    };
-                }));
+                const hydrated = hydrateSessionThread(body.session.messages ?? []);
+                hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
+                applyActivatedSession({
+                    messages: hydrated.messages,
+                    toolCalls: hydrated.toolCalls,
+                    sessionStats: body.sessionStats,
+                    usage: body.usage,
+                    streaming: Boolean(body.session.activeTurnId),
+                    turnPhase: body.session.turnPhase ??
+                        (body.session.activeTurnId ? "running" : "idle"),
+                    deferredTurn: body.session.deferredTurn ?? null,
+                    deferredTurns: body.session.deferredTurns ?? (body.session.deferredTurn ? [body.session.deferredTurn] : []),
+                    pendingQuestion: body.session.pendingQuestion ?? null,
+                    todos: body.session.todos ?? [],
+                });
             }
             catch {
                 // Recovery is best-effort; a new session remains available.
@@ -329,30 +395,51 @@ export function useChatSessions(params) {
         return () => {
             cancelled = true;
         };
-    }, [origin, refs, setSession, setInput, setMessages]);
+    }, [
+        origin,
+        workspaceQuery,
+        refs,
+        setSession,
+        setInput,
+        applyActivatedSession,
+        blocked,
+    ]);
     // The sole production create path delegates to the exported orchestration
     // helper so its durable commit order is directly traceable and testable.
-    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => createSessionAndPrimeTitleWatcher({
-        origin,
-        sessionListRef,
-        setSessionList,
-        titleWatcher: titleWatcherRef.current,
-        refreshSessionList,
-        options,
-        setCreatingSession,
-        creatingRef: creatingSessionRef,
-    }), [origin, refreshSessionList]);
+    // AC-003 (2026-08-26): session creation REQUIRES a known workspaceId —
+    // either explicit (sidebar create-in-workspace) or the current valid
+    // selection. No scope → fail closed client-side (the server would reject
+    // with WORKSPACE_REQUIRED anyway); never a default-workspace fallback.
+    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => {
+        const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
+        if (!scope) {
+            setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
+            return Promise.reject(new Error("WORKSPACE_REQUIRED"));
+        }
+        return createSessionAndPrimeTitleWatcher({
+            origin,
+            sessionListRef,
+            setSessionList,
+            titleWatcher: titleWatcherRef.current,
+            refreshSessionList,
+            options: { ...options, workspaceId: scope },
+            setCreatingSession,
+            creatingRef: creatingSessionRef,
+        });
+    }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
         if (creatingSessionRef.current)
             return null;
+        if (blocked)
+            return null; // AC-R5-002: unknown workspace — no POST
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
         try {
             const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            resetActiveProjection();
+            resetActiveProjection({ keepStreams: true });
             // Set ref synchronously BEFORE setState so a chained
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
@@ -376,6 +463,7 @@ export function useChatSessions(params) {
         setError,
         resetActiveProjection,
         createSessionAndPrimeTitleWatcherForHook,
+        blocked,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */
@@ -392,7 +480,8 @@ export function useChatSessions(params) {
             if (trimmed) {
                 headers["content-type"] = "application/json";
             }
-            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact`, {
+            // AC-002: compaction follows the session's durable owner.
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact${sessionOwnerQuery()}`, {
                 method: "POST",
                 credentials: "include",
                 headers,
@@ -424,19 +513,23 @@ export function useChatSessions(params) {
             const tokensBefore = body.snapshot?.tokensBefore;
             const summaryText = summary || "历史上下文已精简，关键决策与当前任务已保留。";
             await activateSession(current.sessionId);
-            setMessages((messages) => [
-                ...messages,
-                {
-                    id: `compaction-${Date.now()}`,
-                    role: "assistant",
-                    kind: "compaction",
-                    text: summaryText,
-                    createdAt: Date.now(),
-                    ...(tokensBefore
-                        ? { compaction: { tokensBefore } }
-                        : {}),
-                },
-            ]);
+            setMessages((messages) => {
+                const eventId = typeof body.eventId === "string" ? body.eventId : undefined;
+                const id = eventId ? `compaction-${eventId}` : `compaction-${Date.now()}`;
+                if (messages.some((message) => message.id === id))
+                    return messages;
+                return [...messages, {
+                        id,
+                        role: "assistant",
+                        kind: "compaction",
+                        text: summaryText,
+                        createdAt: Date.now(),
+                        compaction: {
+                            ...(tokensBefore === undefined ? {} : { tokensBefore }),
+                            ...(eventId ? { eventId } : {}),
+                        },
+                    }];
+            });
             setNotice({
                 id: Date.now(),
                 message: `已压缩上下文：${summaryText.slice(0, 72)}${summaryText.length > 72 ? "…" : ""}`,
@@ -456,9 +549,12 @@ export function useChatSessions(params) {
         setMessages,
         onCompactionChange,
         activateSession,
+        sessionOwnerQuery,
     ]);
     const updateSession = async (sessionId, patch) => {
-        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+        // AC-002: rename/archive follows the session's durable owner.
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${sessionOwnerQuery(sessionListRef.current.find((item) => item.sessionId === sessionId)
+            ?.workspaceId ?? null)}`, {
             method: "PATCH",
             credentials: "include",
             headers: {

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

@@ -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, setTurnPhase, setDeferredTurn, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, setDeferredTurns, } = thread;
     const { setInput, setPendingImages, recordHistory } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -386,17 +386,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 +416,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 +425,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 +444,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 +453,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 +470,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 +491,7 @@ export function useChatStream(params) {
         refs,
         thread.deferredTurn,
         setDeferredTurn,
+        setDeferredTurns,
         setInput,
         setPendingImages,
         setError,
@@ -497,9 +500,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 +525,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 +545,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))
@@ -988,6 +1047,8 @@ export function useChatStream(params) {
         handleStop,
         cancelDeferredTurn,
         discardDeferredTurn,
+        editDeferredTurn,
+        steerDeferredTurn,
         openEventsStream,
     };
 }