@tea-agent/loop-agent 0.32.0 → 0.33.0

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

@@ -0,0 +1,320 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+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";
+/** 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, setProcessOpen, setAutoScroll, } = params;
+    const { applyActivatedSession, resetForNewSession, setMessages } = thread;
+    const { setInput, setPendingImages } = composer;
+    const { setPreviews, setActivePreviewPath } = browser;
+    const [sessionList, setSessionList] = useState([]);
+    // 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(() => {
+        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();
+        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) => {
+        if (!window.confirm("确定删除该会话？删除后不可恢复。"))
+            return;
+        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;
+            }
+            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();
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        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),
+            };
+            refs.sessionRef.current = next;
+            refs.streamingRef.current = Boolean(body.session.activeTurnId);
+            refs.seenEventIdsRef.current = new Set();
+            refs.turnAssistantIdsRef.current = new Map();
+            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,
+        setActivePreviewPath,
+        setError,
+    ]);
+    useEffect(() => {
+        void refreshSessionList();
+    }, [refreshSessionList]);
+    // 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.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.seenEventIdsRef.current = new Set();
+                refs.turnAssistantIdsRef.current = new Map();
+                refs.lastEventIdRef.current = null;
+                setSession(restored);
+                setInput(body.session.composerDraft ?? "");
+                setMessages((body.session.messages ?? [])
+                    .filter((message) => message.role === "user" || message.role === "assistant")
+                    .map((message) => ({
+                    id: message.id,
+                    role: message.role,
+                    text: message.text,
+                    createdAt: Date.parse(message.at) || Date.now(),
+                })));
+            }
+            catch {
+                // Recovery is best-effort; a new session remains available.
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [origin, refs, setSession, setInput, setMessages]);
+    const createSession = useCallback(async (options) => {
+        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();
+            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;
+            setError(e instanceof Error ? e.message : String(e));
+            return null;
+        }
+    }, [
+        origin,
+        refs,
+        setSession,
+        setError,
+        resetActiveProjection,
+        refreshSessionList,
+    ]);
+    // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
+    const compactSession = useCallback(async () => {
+        const current = refs.sessionRef.current;
+        if (!current || refs.streamingRef.current)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact`, {
+                method: "POST",
+                credentials: "include",
+                headers: { "x-loop-console-confirmation": confirmationToken() },
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok) {
+                setError(body.error?.message ?? "上下文压缩失败");
+                return;
+            }
+            setError(null);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : "上下文压缩失败");
+        }
+    }, [origin, refs, setError]);
+    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" &&
+            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,
+        activateSession,
+        refreshSessionList,
+        deleteSession,
+        createSession,
+        updateSession,
+        compactSession,
+    };
+}

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

@@ -0,0 +1,209 @@
+import { useCallback, useEffect } from "react";
+import { formatOperatorUserError } from "../../operator-user-error.js";
+import { confirmationToken, requestId, sleep } from "./format.js";
+/** Inline prompt SSE + background reconnect GET /events stream (M1-T04/T05). */
+export function useChatStream(params) {
+    const { origin, refs, session, thread, composer, setError, setAutoScroll } = params;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
+    const { setInput, setPendingImages } = composer;
+    const sendPrompt = useCallback(async (text, images) => {
+        // Read from refs (the source of truth) so callers that captured a
+        // stale closure — notably suggestion chips chaining
+        // createSession().then(sendPrompt) — still see the freshly created
+        // session rather than the null from an earlier render.
+        const session = refs.sessionRef.current;
+        if (!session ||
+            (!text.trim() && images.length === 0) ||
+            refs.streamingRef.current)
+            return;
+        const userMsg = {
+            id: requestId("u"),
+            role: "user",
+            text: text.trim(),
+            createdAt: Date.now(),
+        };
+        setMessages((m) => [...m, userMsg]);
+        setInput("");
+        // Stop the background replay stream before opening the inline SSE
+        // stream. Otherwise both connections can consume the same persisted
+        // event under different assistant ids and render duplicate bubbles.
+        refs.reconnectAbortRef.current?.abort();
+        refs.reconnectAbortRef.current = null;
+        refs.streamingRef.current = true;
+        setStreaming(true);
+        setAutoScroll(true);
+        setError(null);
+        const assistantId = requestId("a");
+        refs.assistantIdRef.current = assistantId;
+        setStreamingAssistantId(assistantId);
+        setMessages((m) => [
+            ...m,
+            { id: assistantId, role: "assistant", text: "", createdAt: Date.now() },
+        ]);
+        const ac = new AbortController();
+        refs.abortRef.current = ac;
+        refs.sessionAbortControllersRef.current.set(session.sessionId, ac);
+        refs.inlineStreamSessionIdsRef.current.add(session.sessionId);
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${session.sessionId}/prompt`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                    Accept: "text/event-stream",
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    text: text.trim() || "请查看附件图片。",
+                    images: images.map(({ type, mimeType, data }) => ({
+                        type,
+                        mimeType,
+                        data,
+                    })),
+                }),
+                signal: ac.signal,
+            });
+            if (!res.ok || !res.body) {
+                const body = (await res.json().catch(() => ({})));
+                throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split("\n\n");
+                buffer = events.pop() ?? "";
+                for (const block of events) {
+                    const eid = applySseBlock(block, assistantId, {
+                        targetSessionId: session.sessionId,
+                    });
+                    if (eid)
+                        refs.lastEventIdRef.current = eid;
+                }
+            }
+        }
+        catch (e) {
+            if (e?.name === "AbortError") {
+                // user stopped; keep partial assistant text
+            }
+            else if (refs.sessionRef.current?.sessionId === session.sessionId) {
+                setError(formatOperatorUserError(e instanceof Error ? e.message : String(e)));
+            }
+        }
+        finally {
+            if (refs.sessionRef.current?.sessionId === session.sessionId) {
+                refs.streamingRef.current = false;
+                setStreaming(false);
+                setStreamingAssistantId(null);
+                refs.abortRef.current = null;
+                refs.assistantIdRef.current = null;
+                setPendingImages([]);
+            }
+            refs.inlineStreamSessionIdsRef.current.delete(session.sessionId);
+            refs.sessionAbortControllersRef.current.delete(session.sessionId);
+        }
+    }, [
+        origin,
+        refs,
+        applySseBlock,
+        setMessages,
+        setStreaming,
+        setStreamingAssistantId,
+        setInput,
+        setPendingImages,
+        setAutoScroll,
+        setError,
+    ]);
+    const handleStop = useCallback(() => {
+        refs.abortRef.current?.abort();
+        refs.streamingRef.current = false;
+        setStreaming(false);
+        setStreamingAssistantId(null);
+    }, [refs, setStreaming, setStreamingAssistantId]);
+    /** Open the reconnectable GET /events stream for a session and apply events
+     *  until it closes, then reopen with the latest Last-Event-ID (M1-T04/T05).
+     *
+     *  The stream is strictly a recovery path: it is stopped before an inline
+     *  prompt SSE starts, then reopened after that prompt settles. This preserves
+     *  one owner for an in-flight assistant bubble while still replaying the
+     *  durable tail after refreshes and network blips. */
+    const openEventsStream = useCallback(async (sessionId, signal) => {
+        while (!signal.aborted) {
+            try {
+                const headers = {
+                    Accept: "text/event-stream",
+                };
+                const last = refs.lastEventIdRef.current;
+                if (last)
+                    headers["Last-Event-ID"] = last;
+                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${sessionId}/events`, { headers, credentials: "include", signal });
+                if (!res.ok || !res.body) {
+                    // 404 = session gone; stop the loop quietly.
+                    if (res.status === 404)
+                        return;
+                    // transient error: back off before retrying.
+                    await sleep(2000, signal);
+                    continue;
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                // Reconnect assistant id: events arriving here belong to whichever
+                // turn is/was active; reuse the in-flight one or allocate a stable
+                // placeholder so streaming text patches a single bubble.
+                let rcAssistantId = refs.assistantIdRef.current;
+                if (!rcAssistantId) {
+                    rcAssistantId = requestId("a");
+                    refs.assistantIdRef.current = rcAssistantId;
+                }
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const blocks = buffer.split("\n\n");
+                    buffer = blocks.pop() ?? "";
+                    for (const block of blocks) {
+                        const eid = applySseBlock(block, rcAssistantId, {
+                            replay: true,
+                            targetSessionId: sessionId,
+                        });
+                        if (eid)
+                            refs.lastEventIdRef.current = eid;
+                    }
+                }
+                // Server closed the follow window (idle). Reopen from the last id
+                // after a short pause unless we were aborted.
+                await sleep(1000, signal);
+            }
+            catch (e) {
+                if (signal.aborted)
+                    return;
+                // Network blip: back off and retry (keeps reconnect resilient).
+                await sleep(2000, signal);
+            }
+        }
+    }, [origin, refs, applySseBlock]);
+    // Reconnect effect: open/refresh the events stream whenever the active
+    // session or streaming state changes. Aborts the previous stream on cleanup
+    // so switching sessions, starting an inline prompt, or unmounting does not
+    // leak a dangling connection. It resumes after settle/stop to catch the tail.
+    useEffect(() => {
+        if (!session ||
+            (streaming && refs.inlineStreamSessionIdsRef.current.has(session.sessionId)))
+            return;
+        const ac = new AbortController();
+        refs.reconnectAbortRef.current = ac;
+        void openEventsStream(session.sessionId, ac.signal);
+        return () => {
+            ac.abort();
+            if (refs.reconnectAbortRef.current === ac)
+                refs.reconnectAbortRef.current = null;
+        };
+    }, [session, streaming, openEventsStream, refs]);
+    return { sendPrompt, handleStop, openEventsStream };
+}