@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

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

@@ -5,6 +5,8 @@ import { requestId } from "./format.js";
 import { parseAssistantContent, } from "../../chat/assistant-content.js";
 import { sortChatTimelineMessages, upsertCompactionMessage, } from "./compaction-message.js";
 import { replacePendingUserMessage } from "./pending-user-message.js";
+import { conversationNodeFromEvent, upsertConversationNode, } from "../../chat/conversation-nodes.js";
+import { createAnimationFrameBatcher } from "./animation-frame-batcher.js";
 /** Shared handler for a single parsed Chat SSE event (M1 reconnect).
  *
  * Used by BOTH the inline prompt POST SSE and the background reconnect
@@ -12,7 +14,7 @@ import { replacePendingUserMessage } from "./pending-user-message.js";
  * original request would have. `assistantId` is the in-flight assistant
  * message id to patch for streaming text; reconnect creates one if none. */
 export function createChatSseEventApplier(deps) {
-    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setDeferredTurns = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, onTelemetryRefresh, setMessages, setToolCalls, setPendingQuestion = () => undefined, setTodos = () => undefined, setGoal = () => undefined, getMessages, } = deps;
+    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setDeferredTurns = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, onTelemetryRefresh, setMessages, setToolCalls, setPendingQuestion = () => undefined, setTodos = () => undefined, setGoal = () => undefined, setOperatorActions = () => undefined, setSddSessionIdentity = () => undefined, setConversationNodes = () => undefined, setTurnState = () => undefined, getMessages, } = deps;
     let queueOwner;
     let queueRevision = -1;
     /** Retained-replay text per turn. Pi `message_update.text` is the cumulative
@@ -20,6 +22,36 @@ export function createChatSseEventApplier(deps) {
      *  turn matters and buffering cannot lose content. Flushed on `stream_ready`
      *  onto the turn's newest assistant row (2026-09-08). */
     const replayTextByTurn = new Map();
+    const messageUpdateBatcher = createAnimationFrameBatcher({
+        schedule: (callback) => {
+            if (typeof window !== "undefined" && window.requestAnimationFrame) {
+                return window.requestAnimationFrame(callback);
+            }
+            return globalThis.setTimeout(callback, 16);
+        },
+        cancel: (handle) => {
+            if (typeof window !== "undefined" && window.cancelAnimationFrame) {
+                window.cancelAnimationFrame(handle);
+            }
+            else {
+                globalThis.clearTimeout(handle);
+            }
+        },
+        publish: (values) => {
+            const sessionId = refs.sessionRef.current?.sessionId;
+            const generation = refs.sessionGenerationRef.current;
+            setMessages((messages) => {
+                let next = messages;
+                for (const item of values.values()) {
+                    if (item.sessionId !== sessionId || item.generation !== generation)
+                        continue;
+                    next = item.apply(next);
+                }
+                return next;
+            });
+        },
+    });
+    const useFrameBatching = typeof window !== "undefined" && typeof window.requestAnimationFrame === "function";
     const flushReplayText = () => {
         if (replayTextByTurn.size === 0)
             return;
@@ -94,6 +126,9 @@ export function createChatSseEventApplier(deps) {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
             return;
+        if (typeof data.sessionId === "string" &&
+            data.sessionId !== refs.sessionRef.current?.sessionId)
+            return;
         const replay = options?.replay === true;
         if (eventName === "stream_ready") {
             // The retained replay is fully buffered: publish it now so a reconnect
@@ -101,6 +136,10 @@ export function createChatSseEventApplier(deps) {
             flushReplayText();
             return;
         }
+        // Structural events define visible boundaries in the DSH timeline. Publish
+        // any coalesced text before applying them so rows never appear out of order.
+        if (eventName !== "message_update" || replay)
+            messageUpdateBatcher.flush();
         if (eventName === "reconcile") {
             // Cursor aged out of the server ring (or the turn changed under us):
             // retained history may be incomplete. Surface recovery via the callback
@@ -173,6 +212,64 @@ export function createChatSseEventApplier(deps) {
         const eventAt = typeof data.at === "string" && Number.isFinite(Date.parse(data.at))
             ? Date.parse(data.at)
             : Date.now();
+        const nodeKinds = new Set([
+            "step_start",
+            "step_end",
+            "model_retry",
+            "turn_error",
+            "turn_max_tokens",
+            "request_context",
+            "command",
+            "unknown",
+        ]);
+        if (nodeKinds.has(eventName) &&
+            turnId &&
+            eventSeq !== undefined &&
+            typeof data.eventId === "string") {
+            const node = conversationNodeFromEvent({
+                eventId: data.eventId,
+                kind: eventName,
+                seq: eventSeq,
+                turnId,
+                at: new Date(eventAt).toISOString(),
+                data: payload,
+            });
+            if (node)
+                setConversationNodes((current) => upsertConversationNode(current, node));
+            return;
+        }
+        if (eventName === "operator-action") {
+            const eventId = typeof data.eventId === "string" ? data.eventId : undefined;
+            if (!eventId ||
+                eventSeq === undefined ||
+                data.sessionId !== refs.sessionRef.current?.sessionId ||
+                payload.action !== "sdd-bingo" ||
+                typeof payload.skillName !== "string" ||
+                !payload.skillName.trim() ||
+                typeof payload.telemetrySessionId !== "string" ||
+                !payload.telemetrySessionId.trim())
+                return;
+            const action = {
+                eventId,
+                seq: eventSeq,
+                at: eventAt,
+                ...(turnId ? { turnId } : {}),
+                action: "sdd-bingo",
+                skillName: payload.skillName.trim(),
+                telemetrySessionId: payload.telemetrySessionId.trim(),
+            };
+            setOperatorActions((current) => {
+                const existing = current.findIndex((item) => item.eventId === eventId);
+                const next = existing < 0
+                    ? [...current, action]
+                    : current.map((item, index) => (index === existing ? action : item));
+                return next.sort((left, right) => left.seq - right.seq || left.at - right.at);
+            });
+            setSddSessionIdentity({
+                telemetrySessionId: action.telemetrySessionId,
+            });
+            return;
+        }
         if (eventName === "queue_update") {
             const revision = typeof payload.revision === "number" ? payload.revision : -1;
             const owner = refs.sessionRef.current?.sessionId;
@@ -228,6 +325,9 @@ export function createChatSseEventApplier(deps) {
                             : {}),
                         ...(eventSeq === undefined ? {} : { eventSeq }),
                         ...(turnId ? { turnId } : {}),
+                        ...(Array.isArray(message.attachments)
+                            ? { attachments: message.attachments }
+                            : {}),
                     };
                     // Any frame carrying the clientRequestId replaces the optimistic
                     // row in place — even after a /state reconcile already released
@@ -407,6 +507,8 @@ export function createChatSseEventApplier(deps) {
             if (turnId) {
                 refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
+                if (!replay)
+                    setTurnState(turnId, "running");
             }
             if (refs.stopRequestedRef.current &&
                 (!turnId ||
@@ -425,13 +527,17 @@ export function createChatSseEventApplier(deps) {
             return;
         }
         if (eventName === "agent_settled" || eventName === "agent_end") {
-            if (turnId)
-                refs.settledTurnIdsRef.current.add(turnId);
             // `agent_end` means the SDK run ended, but the Console keeps the only
             // GET stream through an idle grace for agent_settled/state reconciliation
             // (M4.4). It must not prematurely close the visible turn.
             if (eventName === "agent_end")
                 return;
+            if (turnId) {
+                refs.settledTurnIdsRef.current.add(turnId);
+                // Settlement proves closure but not its outcome. The stream owner starts
+                // an authoritative /state reconcile; do not guess settled here because
+                // abort/error closeout persists the exact state just after this event.
+            }
             const pending = refs.pendingSubmissionRef.current;
             if (pending && turnId && pending.acceptedTurnId === turnId) {
                 refs.releasedClientRequestIdsRef.current.add(pending.clientRequestId);
@@ -643,7 +749,7 @@ export function createChatSseEventApplier(deps) {
                 refs.sealedAssistantIdsRef.current.add(durableMessageId);
             }
             const assistantIdForEvent = resolvedAssistantId;
-            setMessages((m) => {
+            const applyMessageUpdate = (m) => {
                 // Rename a locally-generated row to the durable id in place so we
                 // never render a twin bubble for the same persistence.
                 const rows = durableMessageId
@@ -686,7 +792,20 @@ export function createChatSseEventApplier(deps) {
                         ...(content ? { content } : {}),
                     },
                 ]);
-            });
+            };
+            if (eventName === "message_update" && useFrameBatching) {
+                const sessionId = refs.sessionRef.current?.sessionId;
+                if (sessionId) {
+                    messageUpdateBatcher.enqueue(`${sessionId}:${assistantIdForEvent}`, {
+                        sessionId,
+                        generation: refs.sessionGenerationRef.current,
+                        apply: applyMessageUpdate,
+                    });
+                }
+            }
+            else {
+                setMessages(applyMessageUpdate);
+            }
             if (eventName === "message_end")
                 sealedIds.add(assistantIdForEvent);
         }
@@ -696,6 +815,10 @@ export function createChatSseEventApplier(deps) {
                 : requestId("t");
             const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
             const argsPreview = typeof payload.argsPreview === "string" ? payload.argsPreview : "{}";
+            const toolStep = typeof payload.step === "number" ? payload.step : undefined;
+            const parentToolCallId = typeof payload.parentToolCallId === "string" && payload.parentToolCallId
+                ? payload.parentToolCallId
+                : undefined;
             setToolCalls((prev) => {
                 if (prev.some((t) => t.id === id)) {
                     return prev.map((t) => {
@@ -707,6 +830,8 @@ export function createChatSseEventApplier(deps) {
                             status: "running",
                             turnId: turnId ?? t.turnId,
                             assistantMessageId: resolvedAssistantId,
+                            ...(toolStep === undefined ? {} : { step: toolStep }),
+                            ...(parentToolCallId ? { parentToolCallId } : {}),
                             ...(eventSeq === undefined ? {} : { eventSeq }),
                         };
                     });
@@ -722,6 +847,54 @@ export function createChatSseEventApplier(deps) {
                         ...(eventSeq === undefined ? {} : { eventSeq }),
                         turnId,
                         assistantMessageId: resolvedAssistantId,
+                        ...(toolStep === undefined ? {} : { step: toolStep }),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
+                    },
+                ];
+            });
+        }
+        else if (eventName === "tool_update") {
+            const id = typeof payload.toolCallId === "string"
+                ? payload.toolCallId
+                : requestId("u");
+            const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
+            const resultText = typeof payload.resultPreview === "string"
+                ? payload.resultPreview
+                : "";
+            const toolStep = typeof payload.step === "number" ? payload.step : undefined;
+            const parentToolCallId = typeof payload.parentToolCallId === "string" && payload.parentToolCallId
+                ? payload.parentToolCallId
+                : undefined;
+            setToolCalls((prev) => {
+                const exists = prev.some((tool) => tool.id === id);
+                if (exists) {
+                    return prev.map((tool) => tool.id !== id
+                        ? tool
+                        : {
+                            ...tool,
+                            result: resultText,
+                            resultText,
+                            status: "running",
+                            turnId: turnId ?? tool.turnId,
+                            assistantMessageId: tool.assistantMessageId ?? resolvedAssistantId,
+                            ...(toolStep === undefined ? {} : { step: toolStep }),
+                            ...(parentToolCallId ? { parentToolCallId } : {}),
+                        });
+                }
+                return [
+                    ...prev,
+                    {
+                        id,
+                        toolName,
+                        result: resultText,
+                        resultText,
+                        status: "running",
+                        createdAt: eventAt,
+                        ...(eventSeq === undefined ? {} : { eventSeq }),
+                        turnId,
+                        assistantMessageId: resolvedAssistantId,
+                        ...(toolStep === undefined ? {} : { step: toolStep }),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
                     },
                 ];
             });
@@ -735,6 +908,10 @@ export function createChatSseEventApplier(deps) {
             const resultText = typeof payload.resultPreview === "string"
                 ? payload.resultPreview
                 : "{}";
+            const toolStep = typeof payload.step === "number" ? payload.step : undefined;
+            const parentToolCallId = typeof payload.parentToolCallId === "string" && payload.parentToolCallId
+                ? payload.parentToolCallId
+                : undefined;
             // Plan A (2026-08-16): the server carries the accepted-operation link on
             // the frame; persist it on the tool entry so the semantic event resolves
             // an operation:<id> ref (mirrors the hydrated path backfill).
@@ -756,6 +933,8 @@ export function createChatSseEventApplier(deps) {
                             ...(eventSeq === undefined ? {} : { finishedSeq: eventSeq }),
                             turnId: turnId ?? t.turnId,
                             assistantMessageId: t.assistantMessageId ?? resolvedAssistantId,
+                            ...(toolStep === undefined ? {} : { step: toolStep }),
+                            ...(parentToolCallId ? { parentToolCallId } : {}),
                             ...(resultOperationId
                                 ? { operationId: resultOperationId }
                                 : t.operationId
@@ -779,6 +958,8 @@ export function createChatSseEventApplier(deps) {
                             : { eventSeq, finishedSeq: eventSeq }),
                         turnId,
                         assistantMessageId: resolvedAssistantId,
+                        ...(toolStep === undefined ? {} : { step: toolStep }),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
                         ...(resultOperationId ? { operationId: resultOperationId } : {}),
                     },
                 ];

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

@@ -0,0 +1,101 @@
+/** Parse the persisted Chat SSE cursor shape `<epoch>:<seq>`. */
+export function parseChatEventCursor(eventId) {
+    const raw = eventId?.trim();
+    if (!raw)
+        return null;
+    const separator = raw.lastIndexOf(":");
+    if (separator <= 0)
+        return null;
+    const epoch = raw.slice(0, separator);
+    const seqPart = raw.slice(separator + 1);
+    if (!/^\d+$/.test(seqPart))
+        return null;
+    const seq = Number(seqPart);
+    if (!Number.isSafeInteger(seq) || seq < 0)
+        return null;
+    return { epoch, seq };
+}
+/** Keep a cursor monotonic within one epoch; a valid new epoch replaces it. */
+export function selectLaterChatEventId(currentEventId, candidateEventId) {
+    const candidate = parseChatEventCursor(candidateEventId);
+    if (!candidate)
+        return currentEventId ?? null;
+    const current = parseChatEventCursor(currentEventId);
+    if (!current ||
+        current.epoch !== candidate.epoch ||
+        candidate.seq > current.seq) {
+        return candidateEventId.trim();
+    }
+    return currentEventId.trim();
+}
+function sseBlockEventId(block) {
+    for (const rawLine of block.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (!line.startsWith("id:"))
+            continue;
+        return line.slice(3).trimStart().trimEnd() || null;
+    }
+    return null;
+}
+/**
+ * A repair buffer belongs to the event-log generation that produced it. If the
+ * reconnect crossed a Console restart, replay from the replacement epoch is
+ * authoritative and old buffered frames must not be applied or restore the old
+ * Last-Event-ID. Control/comment frames are not persisted repair facts.
+ */
+export function selectChatSseRepairBlocks(blocks, readyCursor) {
+    const ready = parseChatEventCursor(readyCursor);
+    if (!ready)
+        return [];
+    return blocks.filter((block) => {
+        const buffered = parseChatEventCursor(sseBlockEventId(block));
+        return buffered?.epoch === ready.epoch;
+    });
+}
+/** Read the dense event-store watermark that starts the live follow phase. */
+export function readChatStreamReadyCursor(block) {
+    let eventName = "message";
+    let dataText = "";
+    for (const rawLine of block.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (line.startsWith("event:"))
+            eventName = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            dataText += line.slice(5).trimStart();
+    }
+    if (eventName !== "stream_ready" || !dataText)
+        return null;
+    try {
+        const data = JSON.parse(dataText);
+        if (typeof data.epoch !== "string" ||
+            !data.epoch ||
+            typeof data.lastSeq !== "number" ||
+            !Number.isSafeInteger(data.lastSeq) ||
+            data.lastSeq < 0)
+            return null;
+        return `${data.epoch}:${data.lastSeq}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect a dropped live persisted frame before it can advance the replay cursor.
+ * Epoch changes remain server-owned because an epoch_mismatch reconcile frame
+ * is followed by snapshot events from the replacement epoch.
+ */
+export function inspectChatSseContinuity(block, lastEventId) {
+    const current = parseChatEventCursor(lastEventId);
+    const incoming = parseChatEventCursor(sseBlockEventId(block));
+    if (!current || !incoming || current.epoch !== incoming.epoch) {
+        return { action: "apply" };
+    }
+    if (incoming.seq > current.seq + 1) {
+        return {
+            action: "reconnect",
+            expectedSeq: current.seq + 1,
+            receivedSeq: incoming.seq,
+        };
+    }
+    return { action: "apply" };
+}

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

@@ -1,4 +1,4 @@
-import { compareChatOrder } from "../../chat/turn-order.js";
+import { ensureLinkedSubmissionOrder } from "../../chat/timeline-message-order.js";
 function finiteToken(value) {
     return typeof value === "number" && Number.isFinite(value)
         ? Math.max(0, Math.floor(value))
@@ -59,9 +59,24 @@ export function compactionMessageFromEvent(item) {
         },
     };
 }
-/** Stable chronological order: server sequence first, legacy time fallback. */
+/** Stable chronological order: server sequence first, legacy time/id fallback. */
 export function sortChatTimelineMessages(messages) {
-    return [...messages].sort(compareChatOrder);
+    return ensureLinkedSubmissionOrder([...messages].sort((a, b) => {
+        if (a.eventSeq !== undefined &&
+            b.eventSeq !== undefined &&
+            a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        if (a.eventSeq !== undefined && b.eventSeq === undefined)
+            return 1;
+        if (a.eventSeq === undefined && b.eventSeq !== undefined)
+            return -1;
+        // Modern JS sort is stable; keep insertion order for indistinguishable
+        // legacy rows instead of inventing chronology from random ids.
+        return 0;
+    }));
 }
 export function upsertCompactionMessage(messages, item) {
     const next = compactionMessageFromEvent(item);

package/dist/worker/console/static-src/operator-chat/context-insights-store.js

@@ -0,0 +1,64 @@
+/**
+ * Operator Chat — context insights store (dsh-context parity).
+ *
+ * Module-level external store so every surface that needs the dashboard
+ * (Details-rail context tab, /context overlay) shares one fetch lifecycle
+ * keyed by sessionId. Read-only GET; no mutation gate needed.
+ */
+import { useSyncExternalStore } from "react";
+let state = { sessionId: null, loading: false };
+const listeners = new Set();
+function emit() {
+    for (const listener of listeners)
+        listener();
+}
+function setState(next) {
+    state = next;
+    emit();
+}
+/** Attach the store to a session; null detaches and clears. */
+export function attachContextInsights(sessionId) {
+    if (state.sessionId === sessionId)
+        return;
+    setState({ sessionId, loading: Boolean(sessionId) });
+    if (!sessionId)
+        return;
+    void refreshContextInsights();
+}
+/** Force a refetch (spatial overlay open, manual refresh button). */
+export async function refreshContextInsights() {
+    const sessionId = state.sessionId;
+    if (!sessionId)
+        return;
+    setState({ ...state, loading: true });
+    try {
+        const res = await fetch(`/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/context-insights`, { credentials: "include" });
+        const body = (await res.json().catch(() => null));
+        if (state.sessionId !== sessionId)
+            return; // stale reply
+        if (!res.ok || !body?.insights) {
+            setState({
+                sessionId,
+                loading: false,
+                error: body?.error?.message ?? `加载上下文洞察失败（${res.status}）`,
+            });
+            return;
+        }
+        setState({ sessionId, loading: false, insights: body.insights });
+    }
+    catch (error) {
+        if (state.sessionId !== sessionId)
+            return;
+        setState({
+            sessionId,
+            loading: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+export function useContextInsights() {
+    return useSyncExternalStore((onStoreChange) => {
+        listeners.add(onStoreChange);
+        return () => listeners.delete(onStoreChange);
+    }, () => state, () => state);
+}

package/dist/worker/console/static-src/operator-chat/details-rail-surfaces.js

@@ -0,0 +1,98 @@
+export const DETAILS_SURFACE_ORDER = [
+    "repo",
+    "session",
+    "bench",
+];
+export const DETAILS_SURFACES = {
+    repo: {
+        id: "repo",
+        label: "仓库",
+        description: "当前仓库的文件与 Git",
+        pages: ["files", "scm"],
+    },
+    session: {
+        id: "session",
+        label: "会话",
+        description: "这次对话的注入与检查",
+        pages: [
+            "context",
+            "insights",
+            "calls",
+            "activity",
+            "trajectory",
+            "goal",
+            "dag",
+        ],
+    },
+    bench: {
+        id: "bench",
+        label: "工作台",
+        description: "终端、预览、数据库",
+        pages: ["terminals", "browser", "databases"],
+    },
+};
+const TAB_TO_SURFACE = {
+    files: "repo",
+    scm: "repo",
+    context: "session",
+    insights: "session",
+    calls: "session",
+    activity: "session",
+    trajectory: "session",
+    goal: "session",
+    dag: "session",
+    terminals: "bench",
+    browser: "bench",
+    databases: "bench",
+};
+export const DEFAULT_PAGE_BY_SURFACE = {
+    repo: "files",
+    session: "context",
+    bench: "terminals",
+};
+export function surfaceForTab(tab) {
+    return TAB_TO_SURFACE[tab];
+}
+export function pagesOnSurface(surface, available) {
+    const allowed = new Set(DETAILS_SURFACES[surface].pages);
+    return available.filter((tab) => allowed.has(tab));
+}
+export function surfacesWithPages(available) {
+    return DETAILS_SURFACE_ORDER.filter((surface) => pagesOnSurface(surface, available).length > 0);
+}
+export function restorePageOnSurface(surface, available, last) {
+    const pages = pagesOnSurface(surface, available);
+    if (pages.length === 0)
+        return null;
+    if (last && pages.includes(last))
+        return last;
+    return pages[0] ?? null;
+}
+export function adjacentSurface(current, availableSurfaces, delta) {
+    if (availableSurfaces.length < 2)
+        return null;
+    const index = availableSurfaces.indexOf(current);
+    if (index < 0)
+        return availableSurfaces[0] ?? null;
+    return availableSurfaces[(index + delta + availableSurfaces.length) % availableSurfaces.length] ?? null;
+}
+export function adjacentPage(current, pages, delta) {
+    if (pages.length < 2)
+        return null;
+    const index = pages.indexOf(current);
+    if (index < 0)
+        return pages[0] ?? null;
+    return pages[(index + delta + pages.length) % pages.length] ?? null;
+}
+export function temporaryDetailsTab(id) {
+    switch (id) {
+        case "context":
+        case "insights":
+        case "calls":
+        case "activity":
+        case "goal":
+            return id;
+        default:
+            return null;
+    }
+}