@tea-agent/loop-agent 0.44.0-next.6 → 0.44.0-next.7

package/dist/worker/console/static-src/operator-chat/turn-state-projection.js

@@ -0,0 +1,166 @@
+export const TURN_STATE_RECONCILE_DELAYS_MS = [0, 75, 200, 500];
+export const TURN_STATE_QUEUE_RETRY_DELAYS_MS = [0, 75, 200, 500, 2_000];
+const MAX_TURN_STATE_QUERY_BATCH = 8;
+/** Normalize server turn facts. Queued is externally still an open/running Turn. */
+export function normalizeDurableTurnState(state) {
+    if (state === "queued" || state === "running")
+        return "running";
+    if (state === "settled" || state === "aborted" || state === "failed") {
+        return state;
+    }
+    return undefined;
+}
+/** Merge authoritative summaries without deleting older paginated Turn facts. */
+export function mergeTurnStateSummaries(current, summaries) {
+    if (!summaries?.length)
+        return current;
+    let next;
+    for (const summary of summaries) {
+        if (typeof summary.turnId !== "string" || !summary.turnId)
+            continue;
+        const state = normalizeDurableTurnState(summary.state);
+        const previous = next?.[summary.turnId] ?? current[summary.turnId];
+        const merged = mergeDurableTurnState(previous, state);
+        if (!merged || previous === merged)
+            continue;
+        next ??= { ...current };
+        next[summary.turnId] = merged;
+    }
+    return next ?? current;
+}
+export function setProjectedTurnState(current, turnId, state) {
+    if (!turnId)
+        return current;
+    const normalized = normalizeDurableTurnState(state);
+    const merged = mergeDurableTurnState(current[turnId], normalized);
+    if (!merged || current[turnId] === merged) {
+        return current;
+    }
+    return { ...current, [turnId]: merged };
+}
+function mergeDurableTurnState(current, incoming) {
+    if (!incoming)
+        return current;
+    if (!current)
+        return incoming;
+    if (current === "failed" || current === "aborted")
+        return current;
+    if (current === "settled" && incoming === "running")
+        return current;
+    return incoming;
+}
+export function turnStateReconcileTrigger(replay, eventName) {
+    if (eventName !== "agent_settled")
+        return undefined;
+    return replay ? "after-replay" : "immediate";
+}
+export async function reconcileTurnStateWithBackoff(input) {
+    const delays = input.delaysMs ?? TURN_STATE_RECONCILE_DELAYS_MS;
+    const wait = input.wait ??
+        ((delayMs) => new Promise((resolve) => globalThis.setTimeout(resolve, delayMs)));
+    for (const delayMs of delays) {
+        if (delayMs > 0)
+            await wait(delayMs);
+        if (input.isCancelled?.())
+            return "cancelled";
+        let snapshot = null;
+        try {
+            snapshot = await input.read();
+        }
+        catch {
+            // A transport failure consumes one bounded attempt; later attempts or an
+            // SSE reconnect retain ownership of the pending reconciliation.
+        }
+        if (input.isCancelled?.())
+            return "cancelled";
+        if (!snapshot?.turnStates)
+            continue;
+        input.apply(snapshot.turnStates);
+        const state = snapshot.turnStates
+            .filter((summary) => summary.turnId === input.turnId)
+            .map((summary) => normalizeDurableTurnState(summary.state))
+            .find((candidate) => candidate !== undefined);
+        if (state && state !== "running")
+            return "terminal";
+    }
+    return "pending";
+}
+/** Serialize targeted Turn-state reads, batching replay work and retaining
+ * unresolved Turns until durable terminal truth arrives or the owner ends. */
+export function createTurnStateReconcileQueue(input) {
+    const pending = new Set();
+    const wait = input.wait ??
+        ((delayMs) => new Promise((resolve) => globalThis.setTimeout(resolve, delayMs)));
+    const retryDelays = input.retryDelaysMs?.length
+        ? input.retryDelaysMs
+        : TURN_STATE_QUEUE_RETRY_DELAYS_MS;
+    let worker = null;
+    const run = async () => {
+        let retryIndex = 0;
+        while (pending.size > 0 && !input.isCancelled?.()) {
+            const delayMs = retryDelays[Math.min(retryIndex, retryDelays.length - 1)] ?? 0;
+            if (delayMs > 0) {
+                try {
+                    await wait(delayMs);
+                }
+                catch {
+                    if (input.isCancelled?.())
+                        return;
+                }
+            }
+            if (input.isCancelled?.())
+                return;
+            const batch = [...pending].slice(0, MAX_TURN_STATE_QUERY_BATCH);
+            let snapshot = null;
+            try {
+                snapshot = await input.read(batch);
+            }
+            catch {
+                // The queue owns retry cadence; a transient read failure keeps the batch pending.
+            }
+            if (input.isCancelled?.())
+                return;
+            const summaries = snapshot?.turnStates;
+            if (summaries?.length)
+                input.apply(summaries);
+            let completed = 0;
+            for (const turnId of batch) {
+                const state = summaries
+                    ?.filter((summary) => summary.turnId === turnId)
+                    .map((summary) => normalizeDurableTurnState(summary.state))
+                    .find((candidate) => candidate !== undefined);
+                if (state && state !== "running") {
+                    pending.delete(turnId);
+                    completed += 1;
+                    continue;
+                }
+                // Rotate unresolved ids so batches larger than the server query cap cannot starve.
+                pending.delete(turnId);
+                pending.add(turnId);
+            }
+            retryIndex = completed > 0 ? 0 : retryIndex + 1;
+        }
+    };
+    const start = () => {
+        if (worker)
+            return worker;
+        if (pending.size === 0 || input.isCancelled?.())
+            return Promise.resolve();
+        worker = run().finally(() => {
+            worker = null;
+            if (pending.size > 0 && !input.isCancelled?.())
+                void start();
+        });
+        return worker;
+    };
+    return {
+        enqueue: (turnId, options) => {
+            if (!turnId || input.isCancelled?.())
+                return;
+            pending.add(turnId);
+            if (!options?.defer)
+                void start();
+        },
+        start,
+    };
+}

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -19,11 +19,65 @@ export const OPERATOR_CHAT_REAL_PATHS = {
     events: "/api/operator/v1/chat/sessions/:sessionId/events",
     abort: "/api/operator/v1/chat/sessions/:sessionId/turns/:turnId/abort",
 };
+const MAX_STATE_TURN_IDS = 8;
+const MAX_STATE_TURN_ID_CHARS = 240;
+function boundedStateTurnIds(turnIds) {
+    const result = [];
+    const seen = new Set();
+    for (const raw of turnIds ?? []) {
+        const turnId = raw.trim();
+        if (!turnId ||
+            turnId.length > MAX_STATE_TURN_ID_CHARS ||
+            seen.has(turnId)) {
+            continue;
+        }
+        seen.add(turnId);
+        result.push(turnId);
+        if (result.length >= MAX_STATE_TURN_IDS)
+            break;
+    }
+    return result;
+}
 export function operatorChatTurnsUrl(origin, sessionId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns`;
 }
-export function operatorChatStateUrl(origin, sessionId) {
-    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`;
+export function operatorChatStateUrl(origin, sessionId, turnIds) {
+    const base = `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`;
+    const bounded = boundedStateTurnIds(turnIds);
+    if (bounded.length === 0)
+        return base;
+    const query = new URLSearchParams();
+    for (const turnId of bounded)
+        query.append("turnId", turnId);
+    return `${base}?${query.toString()}`;
+}
+/** Compose session ownership with a short request timeout and explicit cleanup. */
+export function createBoundedOwnerSignal(input) {
+    const controller = new AbortController();
+    const abortFromOwner = () => controller.abort(input.ownerSignal?.reason);
+    if (input.ownerSignal?.aborted)
+        abortFromOwner();
+    else
+        input.ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
+    const schedule = input.schedule ??
+        ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+    const cancel = input.cancel ??
+        ((handle) => globalThis.clearTimeout(handle));
+    const timer = controller.signal.aborted
+        ? undefined
+        : schedule(() => controller.abort(new Error("Operator Chat state request timed out")), input.timeoutMs);
+    let disposed = false;
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (timer !== undefined)
+                cancel(timer);
+            input.ownerSignal?.removeEventListener("abort", abortFromOwner);
+        },
+    };
 }
 export function operatorChatEventsUrl(origin, sessionId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`;

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

@@ -8,6 +8,47 @@ import { isLostChatSessionError } from "./runtime-snapshot-store.js";
 import { upsertCompactionMessage, } from "./compaction-message.js";
 import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSessionListItem(value) {
+    if (!isRecord(value))
+        return false;
+    const optionalString = (field) => field === undefined || typeof field === "string";
+    return (typeof value.sessionId === "string" &&
+        value.sessionId.trim().length > 0 &&
+        (value.state === "active" || value.state === "archived") &&
+        typeof value.updatedAt === "string" &&
+        optionalString(value.workspaceId) &&
+        optionalString(value.title) &&
+        optionalString(value.displayTitle) &&
+        optionalString(value.activeTurnId) &&
+        (value.isBlank === undefined || typeof value.isBlank === "boolean") &&
+        (value.sessionMode === undefined ||
+            value.sessionMode === "workflow" ||
+            value.sessionMode === "pi") &&
+        (value.turnPhase === undefined ||
+            value.turnPhase === "idle" ||
+            value.turnPhase === "running" ||
+            value.turnPhase === "stopping"));
+}
+/** A 2xx response is authoritative only after its versioned payload validates. */
+export function parseSessionListBaseline(value) {
+    if (!isRecord(value) || value.schemaVersion !== 2) {
+        throw new Error("会话列表响应版本无效");
+    }
+    if (!Array.isArray(value.sessions) || !value.sessions.every(isSessionListItem)) {
+        throw new Error("会话列表响应缺少有效的 sessions");
+    }
+    const workspaceErrors = value.workspaceErrors ?? [];
+    if (!Array.isArray(workspaceErrors) || !workspaceErrors.every(isRecord)) {
+        throw new Error("会话列表响应包含无效的 workspaceErrors");
+    }
+    return {
+        sessions: value.sessions,
+        workspaceErrors: workspaceErrors,
+    };
+}
 /** Pure list mutations keep optimistic UI deterministic and easy to verify. */
 export function insertOptimisticSession(list, row) {
     return [row, ...list.filter((item) => item.sessionId !== row.sessionId)];
@@ -199,11 +240,19 @@ export function useChatSessions(params) {
         return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
+    const [sessionListStatus, setSessionListStatus] = useState({
+        phase: "pending",
+        state: "idle",
+        error: null,
+    });
     const [selectedSession, setSelectedSession] = useState(null);
     const selectedSessionRef = useRef(null);
     selectedSessionRef.current = selectedSession;
     const sessionListRef = useRef([]);
     const sessionListRequestVersionRef = useRef(0);
+    const sessionListRefreshRef = useRef(null);
+    const sessionListRefreshQueuedRef = useRef(false);
+    const sessionListGlobalErrorRef = useRef(null);
     const pendingDeletedIdsRef = useRef(new Set());
     const pendingCreatedRowsRef = useRef(new Map());
     const sessionMutationVersionRef = useRef(0);
@@ -257,48 +306,101 @@ export function useChatSessions(params) {
         setProcessOpen,
         setAutoScroll,
     ]);
-    const refreshSessionList = useCallback(async () => {
+    const refreshSessionList = useCallback(() => {
         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
-            // previous workspace's list as an empty result while a scoped refresh is
-            // in flight. Session detail and mutation requests remain owner-scoped.
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
-                credentials: "include",
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (version !== sessionListRequestVersionRef.current)
-                return;
-            if (!res.ok) {
-                setError(body.error?.message ?? `会话列表加载失败（HTTP ${res.status}）`);
-                return;
-            }
-            const sessions = body.sessions ?? [];
-            const belongsToVisibleWorkspace = (item) => params.workspacesLoading ||
-                !item.workspaceId ||
-                visibleWorkspaceIds.has(item.workspaceId);
-            const durable = sessions.filter((item) => belongsToVisibleWorkspace(item) &&
-                !pendingDeletedIdsRef.current.has(item.sessionId));
-            const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => belongsToVisibleWorkspace(item) &&
-                !durable.some((session) => session.sessionId === item.sessionId));
-            // Preserve summaries for visible workspaces. ChatWorkspaceSidebar applies
-            // the recent-item limit independently inside each workspace group.
-            const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
-            sessionListRef.current = next;
-            setSessionList(next);
-            if (body.workspaceErrors?.length) {
-                setError(`部分工作区的会话加载失败（${body.workspaceErrors.length} 个）`);
-            }
-        }
-        catch (error) {
-            if (version !== sessionListRequestVersionRef.current)
-                return;
-            setError(`会话列表加载失败：${error instanceof Error ? error.message : String(error)}`);
+            return Promise.resolve(); // AC-R5-002: fail-closed, zero requests
+        if (sessionListRefreshRef.current) {
+            // The newest refresh may carry a different visible-workspace projection.
+            // Do not briefly commit the older scope before the queued baseline runs.
+            sessionListRequestVersionRef.current += 1;
+            sessionListRefreshQueuedRef.current = true;
+            return sessionListRefreshRef.current;
         }
+        const request = (async () => {
+            do {
+                sessionListRefreshQueuedRef.current = false;
+                const version = ++sessionListRequestVersionRef.current;
+                setSessionListStatus((current) => ({
+                    ...current,
+                    state: "loading",
+                    error: null,
+                }));
+                try {
+                    // The sidebar is one unscoped multi-workspace index. Session detail
+                    // and mutations remain owner-scoped.
+                    const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
+                        credentials: "include",
+                    });
+                    let rawBody;
+                    try {
+                        rawBody = await res.json();
+                    }
+                    catch {
+                        throw new Error("会话列表响应不是有效 JSON");
+                    }
+                    if (version !== sessionListRequestVersionRef.current) {
+                        sessionListRefreshQueuedRef.current = true;
+                        continue;
+                    }
+                    if (!res.ok) {
+                        const message = isRecord(rawBody) &&
+                            isRecord(rawBody.error) &&
+                            typeof rawBody.error.message === "string"
+                            ? rawBody.error.message
+                            : `会话列表加载失败（HTTP ${res.status}）`;
+                        throw new Error(message);
+                    }
+                    const baseline = parseSessionListBaseline(rawBody);
+                    if (baseline.workspaceErrors.length > 0) {
+                        throw new Error(`部分工作区的会话加载失败（${baseline.workspaceErrors.length} 个）`);
+                    }
+                    const belongsToVisibleWorkspace = (item) => params.workspacesLoading ||
+                        !item.workspaceId ||
+                        visibleWorkspaceIds.has(item.workspaceId);
+                    const durable = baseline.sessions.filter((item) => belongsToVisibleWorkspace(item) &&
+                        !pendingDeletedIdsRef.current.has(item.sessionId));
+                    const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => belongsToVisibleWorkspace(item) &&
+                        !durable.some((session) => session.sessionId === item.sessionId));
+                    const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
+                    sessionListRef.current = next;
+                    setSessionList(next);
+                    setSessionListStatus({ phase: "ready", state: "idle", error: null });
+                    const previousListError = sessionListGlobalErrorRef.current;
+                    if (previousListError) {
+                        setError((current) => current === previousListError ? null : current);
+                        sessionListGlobalErrorRef.current = null;
+                    }
+                }
+                catch (error) {
+                    if (version !== sessionListRequestVersionRef.current) {
+                        sessionListRefreshQueuedRef.current = true;
+                        continue;
+                    }
+                    const message = `会话列表加载失败：${error instanceof Error ? error.message : String(error)}`;
+                    setSessionListStatus((current) => ({
+                        ...current,
+                        state: "error",
+                        error: message,
+                    }));
+                    sessionListGlobalErrorRef.current = message;
+                    setError(message);
+                }
+            } while (sessionListRefreshQueuedRef.current && !blocked);
+        })();
+        sessionListRefreshRef.current = request;
+        void request.finally(() => {
+            if (sessionListRefreshRef.current === request) {
+                sessionListRefreshRef.current = null;
+            }
+        });
+        return request;
     }, [origin, blocked, setError, visibleWorkspaceIds, params.workspacesLoading]);
+    const invalidateSessionListBaseline = useCallback(() => {
+        sessionListRequestVersionRef.current += 1;
+        if (sessionListRefreshRef.current) {
+            sessionListRefreshQueuedRef.current = true;
+        }
+    }, []);
     const deleteSession = useCallback(async (sessionId) => {
         if (pendingDeletedIdsRef.current.has(sessionId))
             return false;
@@ -308,7 +410,7 @@ export function useChatSessions(params) {
         if (!removed || removedIndex < 0)
             return false;
         // No pre-mutation snapshot may overwrite this deletion or its rollback.
-        sessionListRequestVersionRef.current += 1;
+        invalidateSessionListBaseline();
         pendingDeletedIdsRef.current.add(sessionId);
         deleteRequestVersionsRef.current.set(sessionId, requestId);
         const activeSession = refs.sessionRef.current?.sessionId === sessionId
@@ -341,7 +443,7 @@ export function useChatSessions(params) {
         const restore = () => {
             if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
                 return;
-            sessionListRequestVersionRef.current += 1;
+            invalidateSessionListBaseline();
             pendingDeletedIdsRef.current.delete(sessionId);
             deleteRequestVersionsRef.current.delete(sessionId);
             const restored = restoreSessionAt(sessionListRef.current.filter((item) => item.sessionId !== sessionId), removed, removedIndex);
@@ -412,6 +514,7 @@ export function useChatSessions(params) {
         setError,
         sessionOwnerQuery,
         workspaceId,
+        invalidateSessionListBaseline,
     ]);
     const forgetLostSession = useCallback((sessionId, ownerWorkspaceId) => {
         const active = refs.sessionRef.current;
@@ -424,6 +527,7 @@ export function useChatSessions(params) {
         forgetActiveChatSession(window.localStorage, scope, sessionId);
         releaseSession(identity);
         pendingDeletedIdsRef.current.add(sessionId);
+        invalidateSessionListBaseline();
         const { next } = removeSessionById(sessionListRef.current, sessionId);
         sessionListRef.current = next;
         setSessionList(next);
@@ -436,7 +540,15 @@ export function useChatSessions(params) {
             setSession(null);
         }
         void refreshSessionList();
-    }, [refs, releaseSession, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
+    }, [
+        refs,
+        releaseSession,
+        resetActiveProjection,
+        setSession,
+        workspaceId,
+        refreshSessionList,
+        invalidateSessionListBaseline,
+    ]);
     const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
         const listedOwner = sessionListRef.current.find((item) => item.sessionId === sessionId)?.workspaceId;
@@ -503,10 +615,12 @@ export function useChatSessions(params) {
             applyActivatedSession({
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
+                turnStates: body.session.turnStates,
                 conversationEvents: body.conversationEvents,
                 sessionStats: body.sessionStats,
                 usage: body.usage,
                 turnTelemetry: body.turnTelemetry,
+                userTurnOutline: body.userTurnOutline,
                 sddSessionIdentity: body.sddDataAlignment ?? null,
                 streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                 turnPhase: body.session.turnPhase ??
@@ -543,6 +657,32 @@ export function useChatSessions(params) {
         forgetLostSession,
     ]);
     activateSessionRef.current = activateSession;
+    const forkSessionAt = useCallback(async (throughMessageId) => {
+        const current = refs.sessionRef.current;
+        if (!current || refs.activeTurnIdRef.current)
+            return false;
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/fork${sessionOwnerQuery(current.workspaceId)}`, {
+                method: "POST",
+                credentials: "include",
+                headers: {
+                    "content-type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                body: JSON.stringify({ throughMessageId }),
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok || !body.sessionId) {
+                throw new Error(body.error?.message ?? "创建分叉会话失败");
+            }
+            await refreshSessionList();
+            return activateSession(body.sessionId, current.workspaceId);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+            return false;
+        }
+    }, [activateSession, origin, refreshSessionList, refs, sessionOwnerQuery, setError]);
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
@@ -639,10 +779,12 @@ export function useChatSessions(params) {
                 applyActivatedSession({
                     messages: hydrated.messages,
                     toolCalls: hydrated.toolCalls,
+                    turnStates: body.session.turnStates,
                     conversationEvents: body.conversationEvents,
                     sessionStats: body.sessionStats,
                     usage: body.usage,
                     turnTelemetry: body.turnTelemetry,
+                    userTurnOutline: body.userTurnOutline,
                     sddSessionIdentity: body.sddDataAlignment ?? null,
                     streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                     turnPhase: body.session.turnPhase ??
@@ -698,6 +840,7 @@ export function useChatSessions(params) {
             optimisticState: "creating",
         };
         pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
+        invalidateSessionListBaseline();
         const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
         sessionListRef.current = optimisticList;
         setSessionList(optimisticList);
@@ -713,6 +856,14 @@ export function useChatSessions(params) {
                 creatingRef: creatingSessionRef,
             });
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            const durableRow = sessionListRef.current.find((item) => item.sessionId === created.sessionId);
+            if (durableRow) {
+                pendingCreatedRowsRef.current.set(created.sessionId, durableRow);
+                invalidateSessionListBaseline();
+                void refreshSessionList().finally(() => {
+                    pendingCreatedRowsRef.current.delete(created.sessionId);
+                });
+            }
             return created;
         }
         catch (error) {
@@ -722,7 +873,13 @@ export function useChatSessions(params) {
             setSessionList(cleaned);
             throw error;
         }
-    }, [origin, refreshSessionList, workspaceId, setError]);
+    }, [
+        origin,
+        refreshSessionList,
+        workspaceId,
+        setError,
+        invalidateSessionListBaseline,
+    ]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
         if (creatingSessionRef.current)
@@ -904,11 +1061,13 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        sessionListStatus,
         selectedSession,
         sessionSwitching: Boolean(selectedSession &&
             refs.sessionRef.current?.sessionId !== selectedSession.sessionId),
         creatingSession,
         activateSession,
+        forkSessionAt,
         refreshSessionList,
         deleteSession,
         createSession,