@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

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

@@ -2,10 +2,9 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
-import { DEFAULT_CONSOLE_CHAT_SESSION_MODE } from "../../chat/session-mode-view.js";
 import { confirmationToken } from "./format.js";
 import { isLostChatSessionError } from "./runtime-snapshot-store.js";
-import { upsertCompactionMessage, } from "./compaction-message.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
 /** Pure list mutations keep optimistic UI deterministic and easy to verify. */
@@ -68,8 +67,6 @@ function sameSessionSummary(a, b) {
         a.model?.modelId === b.model?.modelId &&
         a.thinkingLevel === b.thinkingLevel &&
         a.isBlank === b.isBlank &&
-        (a.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) ===
-            (b.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) &&
         a.optimisticState === b.optimisticState &&
         sameQueueSummary(a, b));
 }
@@ -86,18 +83,8 @@ export function stabilizeSessionList(previous, next) {
     });
     return changed ? stabilized : previous;
 }
-/** Project a session detail/list record into the active ChatSessionInfo. */
-export function projectActiveChatSession(session, fallbackWorkspaceId) {
-    const workspaceId = session.workspaceId?.trim() || fallbackWorkspaceId?.trim() || "";
-    return {
-        sessionId: session.sessionId,
-        ...(workspaceId ? { workspaceId } : {}),
-        sessionMode: session.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE,
-        ...runtimeSelectionFromRecord(session),
-    };
-}
 /** Select a server-confirmed blank session owned by the requested workspace. */
-export function findReusableBlankSession(list, workspaceId, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
+export function findReusableBlankSession(list, workspaceId) {
     const scope = workspaceId.trim();
     if (!scope)
         return undefined;
@@ -106,8 +93,7 @@ export function findReusableBlankSession(list, workspaceId, sessionMode = DEFAUL
         item.isBlank === true &&
         item.turnPhase === "idle" &&
         !item.activeTurnId &&
-        !item.optimisticState &&
-        (item.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE) === sessionMode);
+        !item.optimisticState);
 }
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
@@ -141,13 +127,7 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const body = (await res.json());
         if (!body.session)
             throw new Error("创建会话响应缺少 durable session");
-        const durable = {
-            ...body.session,
-            isBlank: true,
-            sessionMode: body.session.sessionMode ??
-                input.options?.sessionMode ??
-                DEFAULT_CONSOLE_CHAT_SESSION_MODE,
-        };
+        const durable = { ...body.session, isBlank: true };
         const created = {
             sessionId: durable.sessionId,
             ...(durable.workspaceId || input.options?.workspaceId
@@ -155,7 +135,6 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                     workspaceId: durable.workspaceId ?? input.options?.workspaceId,
                 }
                 : {}),
-            sessionMode: durable.sessionMode,
             ...runtimeSelectionFromRecord(durable),
         };
         const nextList = replaceOptimisticSession(input.sessionListRef.current, input.options?.optimisticSessionId, durable);
@@ -179,8 +158,8 @@ function mergeCompactionMessages(messages, compactions) {
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
     const { origin, refs, setSession, thread, composer, browser, setError, setNotice, onCompactionChange, setProcessOpen, setAutoScroll, } = params;
-    const { applyActivatedSession, resetForNewSession, setMessages } = thread;
-    const { seedSession, releaseSession } = composer;
+    const { applyActivatedSession, resetForNewSession } = thread;
+    const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const { workspaceId, blocked } = params;
     const workspaceQuery = workspaceId
@@ -198,11 +177,7 @@ export function useChatSessions(params) {
         return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
-    const [selectedSession, setSelectedSession] = useState(null);
-    const selectedSessionRef = useRef(null);
-    selectedSessionRef.current = selectedSession;
     const sessionListRef = useRef([]);
-    const sessionListRequestVersionRef = useRef(0);
     const pendingDeletedIdsRef = useRef(new Set());
     const pendingCreatedRowsRef = useRef(new Map());
     const sessionMutationVersionRef = useRef(0);
@@ -244,6 +219,8 @@ export function useChatSessions(params) {
         refs.settledTurnIdsRef.current = new Set();
         refs.activeTurnIdRef.current = null;
         resetForNewSession();
+        setInput("");
+        setPendingImages([]);
         setPreviews([]);
         setActivePreviewPath(null);
         setProcessOpen(false);
@@ -251,6 +228,8 @@ export function useChatSessions(params) {
     }, [
         refs,
         resetForNewSession,
+        setInput,
+        setPendingImages,
         setPreviews,
         setActivePreviewPath,
         setProcessOpen,
@@ -259,7 +238,6 @@ export function useChatSessions(params) {
     const refreshSessionList = useCallback(async () => {
         if (blocked)
             return; // AC-R5-002: fail-closed, zero session requests
-        const version = ++sessionListRequestVersionRef.current;
         try {
             // The sidebar is a multi-workspace index. Keep one unscoped summary
             // collection so expanding or switching a workspace never projects the
@@ -269,8 +247,6 @@ export function useChatSessions(params) {
                 credentials: "include",
             });
             const body = (await res.json().catch(() => ({})));
-            if (version !== sessionListRequestVersionRef.current)
-                return;
             if (!res.ok) {
                 setError(body.error?.message ?? `会话列表加载失败（HTTP ${res.status}）`);
                 return;
@@ -288,8 +264,6 @@ export function useChatSessions(params) {
             }
         }
         catch (error) {
-            if (version !== sessionListRequestVersionRef.current)
-                return;
             setError(`会话列表加载失败：${error instanceof Error ? error.message : String(error)}`);
         }
     }, [origin, blocked, setError]);
@@ -301,22 +275,12 @@ export function useChatSessions(params) {
         const { next: removedList, removed, index: removedIndex } = removeSessionById(currentList, sessionId);
         if (!removed || removedIndex < 0)
             return false;
-        // No pre-mutation snapshot may overwrite this deletion or its rollback.
-        sessionListRequestVersionRef.current += 1;
         pendingDeletedIdsRef.current.add(sessionId);
         deleteRequestVersionsRef.current.set(sessionId, requestId);
         const activeSession = refs.sessionRef.current?.sessionId === sessionId
             ? refs.sessionRef.current
             : null;
-        const selectedForDelete = selectedSessionRef.current?.sessionId === sessionId
-            ? selectedSessionRef.current
-            : null;
-        const deletingIdentity = selectedForDelete ??
-            activeSession ?? {
-            sessionId,
-            ...(removed.workspaceId ? { workspaceId: removed.workspaceId } : {}),
-        };
-        const activeWorkspaceId = deletingIdentity.workspaceId ?? workspaceId;
+        const activeWorkspaceId = activeSession?.workspaceId ?? workspaceId;
         const deletingRow = {
             ...removed,
             optimisticState: "deleting",
@@ -335,17 +299,16 @@ export function useChatSessions(params) {
         const restore = () => {
             if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
                 return;
-            sessionListRequestVersionRef.current += 1;
             pendingDeletedIdsRef.current.delete(sessionId);
             deleteRequestVersionsRef.current.delete(sessionId);
-            const restored = restoreSessionAt(sessionListRef.current.filter((item) => item.sessionId !== sessionId), removed, removedIndex);
+            const restored = restoreSessionAt(sessionListRef.current, removed, removedIndex);
             if (restored === sessionListRef.current)
                 return;
             sessionListRef.current = restored;
             setSessionList(restored);
         };
         let deletionSelectionVersion = null;
-        if (activeSession || selectedForDelete) {
+        if (activeSession) {
             deletionSelectionVersion = ++sessionSelectionVersionRef.current;
             refs.sessionRef.current = null;
             resetActiveProjection();
@@ -353,16 +316,17 @@ export function useChatSessions(params) {
             forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
         }
         const restoreActiveSession = async () => {
-            if ((activeSession || selectedForDelete) &&
+            if (activeSession &&
                 deletionSelectionVersion === sessionSelectionVersionRef.current &&
                 !refs.sessionRef.current) {
-                await activateSessionRef.current?.(deletingIdentity.sessionId, deletingIdentity.workspaceId);
+                await activateSessionRef.current?.(activeSession.sessionId, activeSession.workspaceId);
             }
         };
         try {
             // AC-002: delete follows the session's durable owner, not the
             // global active workspace.
-            const ownerQuery = sessionOwnerQuery(removed.workspaceId ?? null);
+            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",
@@ -377,13 +341,6 @@ export function useChatSessions(params) {
                 return false;
             }
             titleWatcherRef.current?.cancel(sessionId);
-            const next = sessionListRef.current.filter((item) => item.sessionId !== sessionId);
-            sessionListRef.current = next;
-            setSessionList(next);
-            if (deletionSelectionVersion === sessionSelectionVersionRef.current &&
-                selectedSessionRef.current?.sessionId === sessionId)
-                setSelectedSession(null);
-            releaseSession(deletingIdentity);
             void refreshSessionList().finally(() => {
                 pendingDeletedIdsRef.current.delete(sessionId);
                 deleteRequestVersionsRef.current.delete(sessionId);
@@ -401,7 +358,6 @@ export function useChatSessions(params) {
         refs,
         setSession,
         resetActiveProjection,
-        releaseSession,
         refreshSessionList,
         setError,
         sessionOwnerQuery,
@@ -411,45 +367,25 @@ export function useChatSessions(params) {
         const active = refs.sessionRef.current;
         const listed = sessionListRef.current.find((item) => item.sessionId === sessionId);
         const scope = ownerWorkspaceId ?? listed?.workspaceId ?? active?.workspaceId ?? workspaceId;
-        const identity = {
-            sessionId,
-            ...(scope ? { workspaceId: scope } : {}),
-        };
         forgetActiveChatSession(window.localStorage, scope, sessionId);
-        releaseSession(identity);
         pendingDeletedIdsRef.current.add(sessionId);
         const { next } = removeSessionById(sessionListRef.current, sessionId);
         sessionListRef.current = next;
         setSessionList(next);
-        if (active?.sessionId === sessionId ||
-            selectedSessionRef.current?.sessionId === sessionId) {
+        if (active?.sessionId === sessionId) {
             sessionSelectionVersionRef.current += 1;
             refs.sessionRef.current = null;
-            setSelectedSession(null);
             resetActiveProjection();
             setSession(null);
         }
         void refreshSessionList();
-    }, [refs, releaseSession, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
+    }, [refs, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
     const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
-        const listedOwner = sessionListRef.current.find((item) => item.sessionId === sessionId)?.workspaceId;
-        const requestedOwner = ownerWorkspaceId ?? listedOwner;
-        const requested = {
-            sessionId,
-            ...(requestedOwner ? { workspaceId: requestedOwner } : {}),
-        };
-        // DSH-style staging: selection identity changes synchronously; detail
-        // hydration follows. The previous session loses send authority now.
-        setSelectedSession(requested);
-        resetActiveProjection({ keepStreams: true });
-        refs.sessionRef.current = null;
-        setSession(null);
-        setError(null);
         // 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(requested.workspaceId);
+        const ownerQuery = sessionOwnerQuery(ownerWorkspaceId);
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, { credentials: "include" });
             const body = (await res.json());
@@ -466,11 +402,15 @@ export function useChatSessions(params) {
             }
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return false;
-            const next = projectActiveChatSession(body.session);
+            const next = {
+                sessionId: body.session.sessionId,
+                ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
+                ...runtimeSelectionFromRecord(body.session),
+            };
             // 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.
-            setSelectedSession(next);
+            resetActiveProjection({ keepStreams: true });
             refs.sessionRef.current = next;
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
             const visuallyStopped = body.session.turnPhase === "stopping";
@@ -490,8 +430,9 @@ export function useChatSessions(params) {
             refs.assistantIdRef.current = null;
             refs.abortRef.current =
                 refs.sessionAbortControllersRef.current.get(sessionId) ?? null;
+            setPendingImages([]);
             setPreviews([]);
-            seedSession(next, body.session.composerDraft ?? "");
+            setInput(body.session.composerDraft ?? "");
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
             hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
             applyActivatedSession({
@@ -524,8 +465,9 @@ export function useChatSessions(params) {
         origin,
         refs,
         setSession,
+        setPendingImages,
         setPreviews,
-        seedSession,
+        setInput,
         applyActivatedSession,
         resetActiveProjection,
         setActivePreviewPath,
@@ -559,7 +501,9 @@ export function useChatSessions(params) {
     }
     const watchSessionTitle = useCallback((sessionId) => titleWatcherRef.current?.startIfEligible(sessionId), []);
     useEffect(() => {
-        titleWatcherRef.current?.reconcile(sessionList.flatMap((item) => item.state !== "archived" && !item.title ? [item.sessionId] : []));
+        titleWatcherRef.current?.reconcile(sessionList
+            .filter((item) => item.state !== "archived" && !item.title)
+            .map((item) => item.sessionId));
     }, [sessionList]);
     useEffect(() => () => titleWatcherRef.current?.dispose(), []);
     // Browser refresh/workspace-switch recovery: selection is client state keyed
@@ -576,22 +520,15 @@ export function useChatSessions(params) {
         setSession(null);
         const savedSessionId = readActiveChatSessionId(window.localStorage, workspaceId);
         if (!savedSessionId) {
-            setSelectedSession(null);
             // Keep the per-workspace map intact, but clear the legacy global pointer
             // so Operate/Models cannot link a session from another workspace.
             forgetActiveChatSession(window.localStorage, workspaceId);
             return;
         }
-        setSelectedSession({
-            sessionId: savedSessionId,
-            ...(workspaceId ? { workspaceId } : {}),
-        });
         void (async () => {
             try {
                 const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(savedSessionId)}${workspaceQuery}`, { credentials: "include" });
                 if (!res.ok) {
-                    if (selectionVersion === sessionSelectionVersionRef.current)
-                        setSelectedSession(null);
                     forgetActiveChatSession(window.localStorage, workspaceId, savedSessionId);
                     return;
                 }
@@ -601,9 +538,16 @@ export function useChatSessions(params) {
                     selectionVersion !== sessionSelectionVersionRef.current ||
                     !body.session)
                     return;
-                const restored = projectActiveChatSession(body.session, workspaceId);
+                const restored = {
+                    sessionId: body.session.sessionId,
+                    ...(body.session.workspaceId
+                        ? { workspaceId: body.session.workspaceId }
+                        : workspaceId
+                            ? { workspaceId }
+                            : {}),
+                    ...runtimeSelectionFromRecord(body.session),
+                };
                 refs.sessionGenerationRef.current += 1;
-                setSelectedSession(restored);
                 refs.sessionRef.current = restored;
                 // Do not seed Last-Event-ID here: session messages are restored
                 // from the durable store, but tool/gate/operation projections live
@@ -624,8 +568,8 @@ export function useChatSessions(params) {
                 refs.settledTurnIdsRef.current = new Set();
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
-                seedSession(restored, body.session.composerDraft ?? "");
                 rememberActiveChatSession(window.localStorage, restored.workspaceId ?? workspaceId, restored.sessionId);
+                setInput(body.session.composerDraft ?? "");
                 const hydrated = hydrateSessionThread(body.session.messages ?? []);
                 hydrated.messages = mergeCompactionMessages(hydrated.messages, body.compactions);
                 applyActivatedSession({
@@ -657,7 +601,7 @@ export function useChatSessions(params) {
         workspaceQuery,
         refs,
         setSession,
-        seedSession,
+        setInput,
         applyActivatedSession,
         blocked,
         resetActiveProjection,
@@ -669,13 +613,12 @@ export function useChatSessions(params) {
     // 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(async (options) => {
+    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => {
         const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
         if (!scope) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
             return Promise.reject(new Error("WORKSPACE_REQUIRED"));
         }
-        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const optimisticSessionId = `optimistic-chat-${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const now = new Date().toISOString();
         const optimisticRow = {
@@ -684,34 +627,31 @@ export function useChatSessions(params) {
             state: "active",
             updatedAt: now,
             turnPhase: "idle",
-            sessionMode,
             optimisticState: "creating",
         };
         pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
         const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
         sessionListRef.current = optimisticList;
         setSessionList(optimisticList);
-        try {
-            const created = await createSessionAndPrimeTitleWatcher({
-                origin,
-                sessionListRef,
-                setSessionList,
-                titleWatcher: titleWatcherRef.current,
-                refreshSessionList,
-                options: { ...options, workspaceId: scope, optimisticSessionId },
-                setCreatingSession,
-                creatingRef: creatingSessionRef,
-            });
+        return createSessionAndPrimeTitleWatcher({
+            origin,
+            sessionListRef,
+            setSessionList,
+            titleWatcher: titleWatcherRef.current,
+            refreshSessionList,
+            options: { ...options, workspaceId: scope, optimisticSessionId },
+            setCreatingSession,
+            creatingRef: creatingSessionRef,
+        }).then((created) => {
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
             return created;
-        }
-        catch (error) {
+        }).catch((error) => {
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
             const cleaned = sessionListRef.current.filter((item) => item.sessionId !== optimisticSessionId);
             sessionListRef.current = cleaned;
             setSessionList(cleaned);
             throw error;
-        }
+        });
     }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
@@ -729,10 +669,9 @@ export function useChatSessions(params) {
         }
         // A caller-provided snapshot is an explicit new-session boundary; reusing
         // an existing shell would silently drop that context suffix.
-        const sessionMode = options?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
         const reusable = options?.snapshot
             ? undefined
-            : findReusableBlankSession(sessionListRef.current, scope, sessionMode);
+            : findReusableBlankSession(sessionListRef.current, scope);
         if (reusable) {
             if (previousSession?.sessionId === reusable.sessionId)
                 return previousSession;
@@ -742,7 +681,6 @@ export function useChatSessions(params) {
             return {
                 sessionId: reusable.sessionId,
                 ...(reusable.workspaceId ? { workspaceId: reusable.workspaceId } : {}),
-                sessionMode: reusable.sessionMode ?? sessionMode,
                 ...runtimeSelectionFromRecord(reusable),
             };
         }
@@ -757,7 +695,6 @@ export function useChatSessions(params) {
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
             refs.sessionRef.current = created;
-            setSelectedSession(created);
             rememberActiveChatSession(window.localStorage, created.workspaceId ?? options?.workspaceId ?? workspaceId, created.sessionId);
             setSession(created);
             return created;
@@ -826,18 +763,11 @@ export function useChatSessions(params) {
                 return;
             }
             setError(null);
-            // Keep the current projection and converge the lifecycle row in place.
-            // Re-activating here would clear the timeline and replay the full event ring.
+            // pi-web parity: reload the compacted session, then leave a distinct
+            // compaction summary card in the timeline plus a transient toast.
             const summary = body.snapshot?.summary?.trim();
             const summaryText = summary || "历史上下文已精简，关键决策与当前任务已保留。";
-            const compaction = body.compaction;
-            if (compaction &&
-                refs.sessionRef.current?.sessionId === current.sessionId) {
-                if (compaction.eventId) {
-                    refs.seenEventIdsRef.current.add(compaction.eventId);
-                }
-                setMessages((messages) => upsertCompactionMessage(messages, compaction));
-            }
+            await activateSession(current.sessionId);
             setNotice({
                 id: Date.now(),
                 message: `已压缩上下文：${summaryText.slice(0, 72)}${summaryText.length > 72 ? "…" : ""}`,
@@ -855,7 +785,7 @@ export function useChatSessions(params) {
         setError,
         setNotice,
         onCompactionChange,
-        setMessages,
+        activateSession,
         sessionOwnerQuery,
     ]);
     const updateSession = async (sessionId, patch) => {
@@ -884,7 +814,6 @@ export function useChatSessions(params) {
             const activeSessionId = refs.sessionRef.current.sessionId;
             sessionSelectionVersionRef.current += 1;
             refs.sessionRef.current = null;
-            setSelectedSession(null);
             resetActiveProjection();
             setSession(null);
             forgetActiveChatSession(window.localStorage, activeWorkspaceId, activeSessionId);
@@ -892,9 +821,6 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
-        selectedSession,
-        sessionSwitching: Boolean(selectedSession &&
-            refs.sessionRef.current?.sessionId !== selectedSession.sessionId),
         creatingSession,
         activateSession,
         refreshSessionList,