@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.0

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

@@ -4,6 +4,56 @@ import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { SessionTitleWatcher } from "./session-title-watcher.js";
+export async function createSessionAndPrimeTitleWatcher(input) {
+    if (input.creatingRef?.current) {
+        throw new Error("CREATE_SESSION_IN_FLIGHT");
+    }
+    if (input.creatingRef)
+        input.creatingRef.current = true;
+    // Synchronous busy feedback: callers set creatingSession in the same render
+    // turn via setCreatingSession before the network await below.
+    input.setCreatingSession?.(true);
+    try {
+        const res = await (input.fetchFn ?? fetch)(`${input.origin}/api/operator/v1/chat/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify(input.options ?? {}),
+        });
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        if (!body.session)
+            throw new Error("创建会话响应缺少 durable session");
+        const durable = body.session;
+        const created = {
+            sessionId: durable.sessionId,
+            ...runtimeSelectionFromRecord(durable),
+        };
+        const nextList = [
+            durable,
+            ...input.sessionListRef.current.filter((item) => item.sessionId !== durable.sessionId),
+        ].slice(0, CHAT_SESSION_LIST_LIMIT);
+        // Commit ref → state → eligibility → deferred refresh. The ref assignment
+        // makes the durable record observable before React's state commit.
+        input.sessionListRef.current = nextList;
+        input.setSessionList(nextList);
+        input.titleWatcher?.markEligible(durable.sessionId);
+        void input.refreshSessionList();
+        return created;
+    }
+    finally {
+        if (input.creatingRef)
+            input.creatingRef.current = false;
+        input.setCreatingSession?.(false);
+    }
+}
 /** Session lifecycle: list / activate / create / delete / rename-archive /
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
@@ -12,17 +62,34 @@ export function useChatSessions(params) {
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const [sessionList, setSessionList] = useState([]);
+    const sessionListRef = useRef([]);
+    sessionListRef.current = sessionList;
+    const titleWatcherRef = useRef(null);
+    // Shared busy gate for sidebar + Landing create entries (one render feedback).
+    const [creatingSession, setCreatingSession] = useState(false);
+    const creatingSessionRef = useRef(false);
     // Only the latest activate/create/restore intent may commit active-session
     // 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.
+        refs.sessionGenerationRef.current += 1;
+        refs.abortRef.current?.abort();
+        refs.reconnectAbortRef.current?.abort();
+        for (const controller of refs.sessionAbortControllersRef.current.values())
+            controller.abort();
+        refs.sessionAbortControllersRef.current.clear();
+        refs.reconnectAbortRef.current = null;
+        refs.eventsStreamStateRef.current = null;
         refs.streamingRef.current = false;
         refs.abortRef.current = null;
         refs.assistantIdRef.current = null;
         refs.lastEventIdRef.current = null;
         refs.seenEventIdsRef.current = new Set();
         refs.turnAssistantIdsRef.current = new Map();
+        refs.settledTurnIdsRef.current = new Set();
         refs.activeTurnIdRef.current = null;
         resetForNewSession();
         setInput("");
@@ -91,6 +158,7 @@ export function useChatSessions(params) {
                 setError("删除会话失败");
                 return;
             }
+            titleWatcherRef.current?.cancel(sessionId);
             if (refs.sessionRef.current?.sessionId === sessionId) {
                 sessionSelectionVersionRef.current += 1;
                 refs.sessionRef.current = null;
@@ -124,11 +192,13 @@ export function useChatSessions(params) {
                 sessionId: body.session.sessionId,
                 ...runtimeSelectionFromRecord(body.session),
             };
+            resetActiveProjection();
             refs.sessionRef.current = next;
             refs.streamingRef.current = Boolean(body.session.activeTurnId);
             refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
+            refs.settledTurnIdsRef.current = new Set();
             refs.lastEventIdRef.current = null;
             setSession(next);
             refs.assistantIdRef.current = null;
@@ -159,12 +229,39 @@ export function useChatSessions(params) {
         setPreviews,
         setInput,
         applyActivatedSession,
+        resetActiveProjection,
         setActivePreviewPath,
         setError,
     ]);
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
+    if (!titleWatcherRef.current) {
+        titleWatcherRef.current = new SessionTitleWatcher({
+            origin,
+            hasSession: (sessionId) => sessionListRef.current.some((item) => item.sessionId === sessionId),
+            onTitle: (sessionId, event) => {
+                setSessionList((current) => current.map((item) => {
+                    if (item.sessionId !== sessionId)
+                        return item;
+                    // A manually assigned title is authoritative over late automatic output.
+                    if (event.automatic && item.title)
+                        return item;
+                    return event.automatic
+                        ? { ...item, title: event.title }
+                        : { ...item, displayTitle: event.title };
+                }));
+            },
+            refresh: refreshSessionList,
+        });
+    }
+    const watchSessionTitle = useCallback((sessionId) => titleWatcherRef.current?.startIfEligible(sessionId), []);
+    useEffect(() => {
+        titleWatcherRef.current?.reconcile(sessionList
+            .filter((item) => item.state !== "archived" && !item.title)
+            .map((item) => item.sessionId));
+    }, [sessionList]);
+    useEffect(() => () => titleWatcherRef.current?.dispose(), []);
     // Browser refresh recovery: retain only the durable session id locally, then
     // re-read messages and operation refs/facts from the server-owned stores.
     useEffect(() => {
@@ -189,6 +286,7 @@ export function useChatSessions(params) {
                     sessionId: body.session.sessionId,
                     ...runtimeSelectionFromRecord(body.session),
                 };
+                refs.sessionGenerationRef.current += 1;
                 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
@@ -197,6 +295,7 @@ export function useChatSessions(params) {
                 refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
                 refs.seenEventIdsRef.current = new Set();
                 refs.turnAssistantIdsRef.current = new Map();
+                refs.settledTurnIdsRef.current = new Set();
                 refs.lastEventIdRef.current = null;
                 setSession(restored);
                 setInput(body.session.composerDraft ?? "");
@@ -217,29 +316,26 @@ export function useChatSessions(params) {
             cancelled = true;
         };
     }, [origin, refs, setSession, setInput, setMessages]);
+    // 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]);
     const createSession = useCallback(async (options) => {
+        // Suppress concurrent create from any entry (sidebar / Landing / chip).
+        if (creatingSessionRef.current)
+            return null;
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-                credentials: "include",
-                body: JSON.stringify(options ?? {}),
-            });
-            if (!res.ok) {
-                const body = (await res.json().catch(() => ({})));
-                throw new Error(body.error?.message ?? `HTTP ${res.status}`);
-            }
-            const body = (await res.json());
-            const created = {
-                sessionId: body.sessionId,
-                ...(body.model ? { model: body.model } : {}),
-            };
-            void refreshSessionList();
+            const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
             resetActiveProjection();
@@ -254,16 +350,18 @@ export function useChatSessions(params) {
         catch (e) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            setError(e instanceof Error ? e.message : String(e));
+            const message = e instanceof Error ? e.message : String(e);
+            if (message !== "CREATE_SESSION_IN_FLIGHT") {
+                setError(message);
+            }
             return null;
         }
     }, [
-        origin,
         refs,
         setSession,
         setError,
         resetActiveProjection,
-        refreshSessionList,
+        createSessionAndPrimeTitleWatcherForHook,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     const compactSession = useCallback(async () => {
@@ -302,6 +400,9 @@ export function useChatSessions(params) {
             return;
         }
         await refreshSessionList();
+        if (patch.state === "archived") {
+            titleWatcherRef.current?.cancel(sessionId);
+        }
         if (patch.state === "archived" &&
             refs.sessionRef.current?.sessionId === sessionId) {
             sessionSelectionVersionRef.current += 1;
@@ -313,11 +414,13 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        creatingSession,
         activateSession,
         refreshSessionList,
         deleteSession,
         createSession,
         updateSession,
+        watchSessionTitle,
         compactSession,
     };
 }