@tea-agent/loop-agent 0.31.1 → 0.32.1

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

@@ -0,0 +1,253 @@
+import { artifactFromEventPayload, mergeArtifactCardState, } from "../../chat/artifact-card.js";
+import { humanGateCardFromEventPayload, mergeHumanGateCardState, } from "../../chat/human-gate-card.js";
+import { mergeOperationCardState, operationFromEventPayload, } from "../../chat/operation-card.js";
+import { requestId } from "./format.js";
+/** Shared handler for a single parsed Chat SSE event (M1 reconnect).
+ *
+ * Used by BOTH the inline prompt POST SSE and the background reconnect
+ * GET /events stream, so a page refresh reapplies the same events the
+ * 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, setError, setProcessOpen, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    return (eventName, data, assistantId, options) => {
+        const replay = options?.replay === true;
+        if (eventName === "reconcile") {
+            // Cursor aged out of the server ring: history may be incomplete.
+            // Surface a non-fatal notice rather than silently rendering a gap.
+            const reason = typeof data.reason === "string" ? data.reason : "cursor_expired";
+            setError(`会话事件窗口已过期（${reason}），建议刷新历史或新建会话。`);
+            return;
+        }
+        const payload = data.data && typeof data.data === "object"
+            ? data.data
+            : data;
+        const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
+        let resolvedAssistantId = assistantId;
+        if (turnId) {
+            const mapped = refs.turnAssistantIdsRef.current.get(turnId);
+            if (mapped)
+                resolvedAssistantId = mapped;
+            else
+                refs.turnAssistantIdsRef.current.set(turnId, assistantId);
+        }
+        if (eventName === "interview-turn") {
+            setInterview((current) => ({
+                ...(current ?? {}),
+                interviewSessionId: typeof payload.interviewSessionId === "string"
+                    ? payload.interviewSessionId
+                    : current?.interviewSessionId,
+                taskId: typeof payload.taskId === "string"
+                    ? payload.taskId
+                    : current?.taskId,
+                state: typeof payload.state === "string" ? payload.state : current?.state,
+                question: payload.question && typeof payload.question === "object"
+                    ? payload.question
+                    : undefined,
+            }));
+            return;
+        }
+        if (eventName === "draft") {
+            setInterview((current) => ({
+                ...(current ?? {}),
+                taskId: typeof payload.taskId === "string"
+                    ? payload.taskId
+                    : current?.taskId,
+                draft: payload.draft && typeof payload.draft === "object"
+                    ? payload.draft
+                    : current?.draft,
+                draftSha256: typeof payload.draftSha256 === "string"
+                    ? payload.draftSha256
+                    : current?.draftSha256,
+                taskKindRecommendation: typeof payload.taskKindRecommendation === "string"
+                    ? payload.taskKindRecommendation
+                    : current?.taskKindRecommendation,
+            }));
+            return;
+        }
+        if (eventName === "assessment") {
+            setInterview((current) => ({
+                ...(current ?? {}),
+                assessment: payload,
+            }));
+            return;
+        }
+        if (eventName === "taskKind-confirmed") {
+            setInterview((current) => ({
+                ...(current ?? {}),
+                confirmedTaskKind: typeof payload.taskKind === "string"
+                    ? payload.taskKind
+                    : current?.confirmedTaskKind,
+                taskKindRecommendation: undefined,
+            }));
+            return;
+        }
+        if (eventName === "human-gate-card") {
+            const card = humanGateCardFromEventPayload(payload);
+            if (card)
+                setHumanGateCards((current) => mergeHumanGateCardState(current, card));
+            return;
+        }
+        if (eventName === "artifact-ref") {
+            const artifact = artifactFromEventPayload(payload);
+            if (artifact)
+                setArtifactCards((current) => mergeArtifactCardState(current, artifact));
+            return;
+        }
+        if (eventName === "agent_start") {
+            setStreaming(true);
+            setStreamingAssistantId(resolvedAssistantId);
+            return;
+        }
+        if (eventName === "agent_settled") {
+            setStreaming(false);
+            setStreamingAssistantId(null);
+            if (!replay && document.hidden)
+                setUnread((current) => current + 1);
+            return;
+        }
+        if (eventName === "operation-ref" || eventName === "operation-status") {
+            const operation = operationFromEventPayload(payload);
+            if (operation) {
+                setOperationCards((current) => mergeOperationCardState(current, operation));
+            }
+            return;
+        }
+        if (eventName === "usage") {
+            if (replay)
+                return;
+            const sample = payload;
+            const responseKey = typeof sample.responseKey === "string" && sample.responseKey
+                ? sample.responseKey
+                : undefined;
+            if (responseKey && refs.usageResponseKeysRef.current.has(responseKey)) {
+                return;
+            }
+            if (responseKey)
+                refs.usageResponseKeysRef.current.add(responseKey);
+            setUsage((current) => {
+                const input = sample.inputTokens ?? 0;
+                const output = sample.outputTokens ?? 0;
+                const cacheRead = sample.cacheReadTokens ?? 0;
+                const cacheWrite = sample.cacheWriteTokens ?? 0;
+                const total = sample.totalTokens ?? input + output + cacheRead + cacheWrite;
+                return {
+                    inputTokens: current.inputTokens + input,
+                    outputTokens: current.outputTokens + output,
+                    cacheReadTokens: current.cacheReadTokens + cacheRead,
+                    cacheWriteTokens: current.cacheWriteTokens + cacheWrite,
+                    totalTokens: current.totalTokens + total,
+                    cost: sample.cost === undefined
+                        ? current.cost
+                        : (current.cost ?? 0) + sample.cost,
+                };
+            });
+            return;
+        }
+        if (eventName === "message_update" || eventName === "message_end") {
+            if (replay) {
+                // Durable messages were restored from the session store; skip
+                // text replay so a fresh reconnect assistant id cannot create
+                // a duplicate bubble.
+                return;
+            }
+            const text = typeof payload.text === "string" ? payload.text : "";
+            setMessages((m) => {
+                const exists = m.some((msg) => msg.id === resolvedAssistantId);
+                if (exists) {
+                    return m.map((msg) => msg.id === resolvedAssistantId ? { ...msg, text } : msg);
+                }
+                // Reconnect path: the assistant message may not exist yet
+                // (e.g. only tool_call events arrived). Append a placeholder.
+                return [
+                    ...m,
+                    {
+                        id: resolvedAssistantId,
+                        role: "assistant",
+                        text,
+                        createdAt: Date.now(),
+                    },
+                ];
+            });
+        }
+        else if (eventName === "tool_call") {
+            const id = typeof payload.toolCallId === "string"
+                ? payload.toolCallId
+                : requestId("t");
+            const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
+            const argsPreview = typeof payload.argsPreview === "string" ? payload.argsPreview : "{}";
+            const now = Date.now();
+            setToolCalls((prev) => {
+                if (prev.some((t) => t.id === id)) {
+                    return prev.map((t) => t.id === id
+                        ? {
+                            ...t,
+                            args: argsPreview,
+                            status: "running",
+                            turnId: turnId ?? t.turnId,
+                            assistantMessageId: resolvedAssistantId,
+                        }
+                        : t);
+                }
+                return [
+                    ...prev,
+                    {
+                        id,
+                        toolName,
+                        args: argsPreview,
+                        status: "running",
+                        createdAt: now,
+                        turnId,
+                        assistantMessageId: resolvedAssistantId,
+                    },
+                ];
+            });
+        }
+        else if (eventName === "tool_result") {
+            const id = typeof payload.toolCallId === "string"
+                ? payload.toolCallId
+                : requestId("r");
+            const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
+            const isError = payload.isError === true;
+            const resultText = typeof payload.resultPreview === "string"
+                ? payload.resultPreview
+                : "{}";
+            const now = Date.now();
+            if (isError)
+                setProcessOpen(true);
+            setToolCalls((prev) => {
+                const exists = prev.find((t) => t.id === id);
+                if (exists) {
+                    return prev.map((t) => t.id === id
+                        ? {
+                            ...t,
+                            result: resultText,
+                            resultText,
+                            status: isError ? "error" : "ok",
+                            finishedAt: now,
+                            turnId: turnId ?? t.turnId,
+                            assistantMessageId: t.assistantMessageId ?? resolvedAssistantId,
+                        }
+                        : t);
+                }
+                return [
+                    ...prev,
+                    {
+                        id,
+                        toolName,
+                        result: resultText,
+                        resultText,
+                        status: isError ? "error" : "ok",
+                        createdAt: now,
+                        finishedAt: now,
+                        turnId,
+                        assistantMessageId: resolvedAssistantId,
+                    },
+                ];
+            });
+        }
+        else if (eventName === "error") {
+            setError(typeof payload.message === "string" ? payload.message : "chat error");
+        }
+    };
+}

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

@@ -0,0 +1,71 @@
+import { truncateToolResult } from "../../chat/tool-preview.js";
+export function confirmationToken() {
+    const w = window;
+    return w.__CONSOLE_CONFIRMATION_TOKEN__ ?? "";
+}
+export function requestId(prefix) {
+    return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Resolve after `ms`, but reject early (AbortError) if the signal aborts.
+ *  Used to back off / pace the reconnect loop without blocking teardown. */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+        }
+        const t = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        signal?.addEventListener("abort", onAbort);
+    });
+}
+export function fmtTime(ts) {
+    const d = new Date(ts);
+    return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+export function fmtDaySep(ts) {
+    const d = new Date(ts);
+    const now = new Date();
+    const isToday = d.getFullYear() === now.getFullYear() &&
+        d.getMonth() === now.getMonth() &&
+        d.getDate() === now.getDate();
+    if (isToday)
+        return "今天";
+    return d.toLocaleDateString([], { month: "long", day: "numeric" });
+}
+export function resultPreview(result) {
+    try {
+        const s = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        return truncateToolResult(s).text;
+    }
+    catch {
+        return String(result);
+    }
+}
+export function kindLabel(kind) {
+    switch (kind) {
+        case "mutation":
+            return "变更";
+        case "long-running":
+            return "长任务";
+        case "explore":
+            return "探查";
+        case "read":
+        default:
+            return "只读";
+    }
+}
+export function taskContextUnchanged(prev, next) {
+    if (!prev)
+        return false;
+    return (prev.taskId === next.taskId &&
+        prev.updatedAt === next.updatedAt &&
+        prev.lastEventId === next.lastEventId &&
+        prev.operations.length === next.operations.length);
+}

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

@@ -0,0 +1,47 @@
+import { useMemo, useRef } from "react";
+export function useChatRefs() {
+    const sessionRef = useRef(null);
+    const streamingRef = useRef(false);
+    const abortRef = useRef(null);
+    const sessionAbortControllersRef = useRef(new Map());
+    const inlineStreamSessionIdsRef = useRef(new Set());
+    const assistantIdRef = useRef(null);
+    const lastEventIdRef = useRef(null);
+    const seenEventIdsRef = useRef(new Set());
+    const turnAssistantIdsRef = useRef(new Map());
+    const reconnectAbortRef = useRef(null);
+    const usageResponseKeysRef = useRef(new Set());
+    const isComposingRef = useRef(false);
+    const compositionEndedAtRef = useRef(0);
+    // Keep the bag identity stable: individual refs never change, so domain
+    // hooks can safely list `refs` in useCallback/useEffect dependency arrays.
+    return useMemo(() => ({
+        sessionRef,
+        streamingRef,
+        abortRef,
+        sessionAbortControllersRef,
+        inlineStreamSessionIdsRef,
+        assistantIdRef,
+        lastEventIdRef,
+        seenEventIdsRef,
+        turnAssistantIdsRef,
+        reconnectAbortRef,
+        usageResponseKeysRef,
+        isComposingRef,
+        compositionEndedAtRef,
+    }), [
+        sessionRef,
+        streamingRef,
+        abortRef,
+        sessionAbortControllersRef,
+        inlineStreamSessionIdsRef,
+        assistantIdRef,
+        lastEventIdRef,
+        seenEventIdsRef,
+        turnAssistantIdsRef,
+        reconnectAbortRef,
+        usageResponseKeysRef,
+        isComposingRef,
+        compositionEndedAtRef,
+    ]);
+}

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

@@ -0,0 +1,77 @@
+/**
+ * ADR 0011: full Pi tools + optional safe-* explore surface.
+ */
+const EXPLORE_TOOLS = [
+    {
+        toolId: "read",
+        kind: "explore",
+        description: "Pi 内置读取文件。",
+    },
+    {
+        toolId: "write",
+        kind: "explore",
+        description: "Pi 内置写入文件（软约束：大改优先走 DAG）。",
+    },
+    {
+        toolId: "edit",
+        kind: "explore",
+        description: "Pi 内置编辑文件（软约束：大改优先走 DAG）。",
+    },
+    {
+        toolId: "bash",
+        kind: "explore",
+        description: "Pi 内置 shell 执行（软约束：优先受治路径）。",
+    },
+    {
+        toolId: "grep",
+        kind: "explore",
+        description: "Pi 内置内容搜索。",
+    },
+    {
+        toolId: "find",
+        kind: "explore",
+        description: "按名称查找文件路径。",
+    },
+    {
+        toolId: "ls",
+        kind: "explore",
+        description: "列出目录内容。",
+    },
+    {
+        toolId: "safe-read",
+        kind: "explore",
+        description: "安全读取仓库相对路径文件；拒绝敏感文件并自动脱敏 secret。",
+    },
+    {
+        toolId: "safe-grep",
+        kind: "explore",
+        description: "安全搜索仓库内容；跳过敏感文件并自动脱敏搜索结果。",
+    },
+    {
+        toolId: "git-status",
+        kind: "explore",
+        description: "固定参数执行 git status --porcelain（无 shell）。",
+    },
+    {
+        toolId: "git-diff",
+        kind: "explore",
+        description: "固定参数查看 git diff；敏感路径不可查看且结果自动脱敏。",
+    },
+];
+export function buildToolCatalog(capabilities) {
+    if (!capabilities)
+        return null;
+    const operatorTools = (capabilities.tools ?? []).map((t) => ({
+        toolId: t.toolId,
+        action: t.action,
+        description: t.description,
+        kind: t.kind ?? "read",
+        cli: t.cli,
+    }));
+    const explore = [...EXPLORE_TOOLS];
+    return {
+        explore,
+        operator: operatorTools,
+        total: explore.length + operatorTools.length,
+    };
+}

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

@@ -0,0 +1 @@
+export {};