@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,495 @@
+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";
+import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
+import { confirmationToken } from "./format.js";
+import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.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) {
+    const { origin, refs, setSession, thread, composer, browser, setError, setNotice, onCompactionChange, setProcessOpen, setAutoScroll, } = params;
+    const { applyActivatedSession, resetForNewSession, setMessages } = thread;
+    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);
+    /** One-shot guard so a stale-token failure schedules a single page reload. */
+    const compactReloadScheduledRef = 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.sealedAssistantIdsRef.current = new Set();
+        refs.settledTurnIdsRef.current = new Set();
+        refs.activeTurnIdRef.current = null;
+        resetForNewSession();
+        setInput("");
+        setPendingImages([]);
+        setPreviews([]);
+        setActivePreviewPath(null);
+        setProcessOpen(false);
+        setAutoScroll(true);
+    }, [
+        refs,
+        resetForNewSession,
+        setInput,
+        setPendingImages,
+        setPreviews,
+        setActivePreviewPath,
+        setProcessOpen,
+        setAutoScroll,
+    ]);
+    const refreshSessionList = useCallback(async () => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
+                credentials: "include",
+            });
+            if (!res.ok)
+                return;
+            const sessions = (await res.json()).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);
+            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]);
+    const deleteSession = useCallback(async (sessionId) => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+                method: "DELETE",
+                credentials: "include",
+                headers: {
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+            });
+            if (!res.ok) {
+                setError("删除会话失败");
+                return false;
+            }
+            titleWatcherRef.current?.cancel(sessionId);
+            if (refs.sessionRef.current?.sessionId === sessionId) {
+                sessionSelectionVersionRef.current += 1;
+                refs.sessionRef.current = null;
+                resetActiveProjection();
+                setSession(null);
+                window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+            }
+            await refreshSessionList();
+            return true;
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+            return false;
+        }
+    }, [
+        origin,
+        refs,
+        setSession,
+        resetActiveProjection,
+        refreshSessionList,
+        setError,
+    ]);
+    const activateSession = useCallback(async (sessionId) => {
+        const selectionVersion = ++sessionSelectionVersionRef.current;
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, { credentials: "include" });
+            const body = (await res.json());
+            if (!res.ok || !body.session)
+                throw new Error(body.error?.message ?? "会话不可用");
+            if (selectionVersion !== sessionSelectionVersionRef.current)
+                return;
+            const next = {
+                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.sealedAssistantIdsRef.current = new Set();
+            refs.settledTurnIdsRef.current = new Set();
+            refs.lastEventIdRef.current = null;
+            setSession(next);
+            refs.assistantIdRef.current = null;
+            refs.abortRef.current =
+                refs.sessionAbortControllersRef.current.get(sessionId) ?? null;
+            setPendingImages([]);
+            setPreviews([]);
+            setInput(body.session.composerDraft ?? "");
+            const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            applyActivatedSession({
+                messages: hydrated.messages,
+                toolCalls: hydrated.toolCalls,
+                streaming: Boolean(body.session.activeTurnId),
+            });
+            window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, sessionId);
+            setActivePreviewPath(null);
+        }
+        catch (error) {
+            if (selectionVersion !== sessionSelectionVersionRef.current)
+                return;
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        setSession,
+        setPendingImages,
+        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(() => {
+        let cancelled = false;
+        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" });
+                if (!res.ok) {
+                    window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+                    return;
+                }
+                const body = (await res.json());
+                if (cancelled ||
+                    selectionVersion !== sessionSelectionVersionRef.current ||
+                    !body.session)
+                    return;
+                const restored = {
+                    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
+                // in the event ring and must replay once. applySseBlock dedups by
+                // eventId and marks replay so usage/unread/sound do not double-count.
+                refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
+                refs.seenEventIdsRef.current = new Set();
+                refs.turnAssistantIdsRef.current = new Map();
+                refs.sealedAssistantIdsRef.current = new Set();
+                refs.settledTurnIdsRef.current = new Set();
+                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 } : {}),
+                    };
+                }));
+            }
+            catch {
+                // Recovery is best-effort; a new session remains available.
+            }
+        })();
+        return () => {
+            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 created = await createSessionAndPrimeTitleWatcherForHook(options);
+            if (selectionVersion !== sessionSelectionVersionRef.current)
+                return null;
+            resetActiveProjection();
+            // 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.
+            refs.sessionRef.current = created;
+            window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, created.sessionId);
+            setSession(created);
+            return created;
+        }
+        catch (e) {
+            if (selectionVersion !== sessionSelectionVersionRef.current)
+                return null;
+            const message = e instanceof Error ? e.message : String(e);
+            if (message !== "CREATE_SESSION_IN_FLIGHT") {
+                setError(message);
+            }
+            return null;
+        }
+    }, [
+        refs,
+        setSession,
+        setError,
+        resetActiveProjection,
+        createSessionAndPrimeTitleWatcherForHook,
+    ]);
+    // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
+    /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */
+    const compactSession = useCallback(async (instructions) => {
+        const current = refs.sessionRef.current;
+        if (!current || refs.streamingRef.current)
+            return;
+        const trimmed = typeof instructions === "string" ? instructions.trim() : "";
+        onCompactionChange?.(true);
+        try {
+            const headers = {
+                "x-loop-console-confirmation": confirmationToken(),
+            };
+            if (trimmed) {
+                headers["content-type"] = "application/json";
+            }
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact`, {
+                method: "POST",
+                credentials: "include",
+                headers,
+                ...(trimmed
+                    ? { body: JSON.stringify({ instructions: trimmed }) }
+                    : {}),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok) {
+                const gateCode = body.error?.code;
+                if (isMutationGateFailureCode(gateCode)) {
+                    // Stale boot tokens: the page predates the current server boot.
+                    // Auto-reload once so the fresh boot page re-injects tokens; keep
+                    // an error line up while reloading in case reload is blocked.
+                    setError(describeMutationGateFailure(gateCode));
+                    if (isStaleTokenFailure(gateCode) && !compactReloadScheduledRef.current) {
+                        compactReloadScheduledRef.current = true;
+                        window.setTimeout(() => window.location.reload(), 1200);
+                    }
+                    return;
+                }
+                setError(body.error?.message ?? "上下文压缩失败");
+                return;
+            }
+            setError(null);
+            // 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 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 } }
+                        : {}),
+                },
+            ]);
+            setNotice({
+                id: Date.now(),
+                message: `已压缩上下文：${summaryText.slice(0, 72)}${summaryText.length > 72 ? "…" : ""}`,
+            });
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : "上下文压缩失败");
+        }
+        finally {
+            onCompactionChange?.(false);
+        }
+    }, [
+        origin,
+        refs,
+        setError,
+        setNotice,
+        setMessages,
+        onCompactionChange,
+        activateSession,
+    ]);
+    const updateSession = async (sessionId, patch) => {
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
+            method: "PATCH",
+            credentials: "include",
+            headers: {
+                "content-type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            body: JSON.stringify(patch),
+        });
+        if (!res.ok) {
+            setError("会话更新失败");
+            return;
+        }
+        await refreshSessionList();
+        if (patch.state === "archived") {
+            titleWatcherRef.current?.cancel(sessionId);
+        }
+        if (patch.state === "archived" &&
+            refs.sessionRef.current?.sessionId === sessionId) {
+            sessionSelectionVersionRef.current += 1;
+            refs.sessionRef.current = null;
+            resetActiveProjection();
+            setSession(null);
+            window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+        }
+    };
+    return {
+        sessionList,
+        creatingSession,
+        activateSession,
+        refreshSessionList,
+        deleteSession,
+        createSession,
+        updateSession,
+        watchSessionTitle,
+        compactSession,
+    };
+}