@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

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

@@ -10,7 +10,9 @@ import { parseAssistantContent } from "../../chat/assistant-content.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, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = 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, } = deps;
+    let queueOwner;
+    let queueRevision = -1;
     return (eventName, data, assistantId, options) => {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
@@ -42,6 +44,26 @@ export function createChatSseEventApplier(deps) {
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
+        if (eventName === "todo_updated" || eventName === "todo_cleared") {
+            const todos = Array.isArray(payload.todos) ? payload.todos : [];
+            setTodos(todos.filter((item) => Boolean(item) && typeof item === "object" && typeof item.content === "string" && (item.status === "pending" || item.status === "in_progress" || item.status === "completed")));
+            return;
+        }
+        if ((eventName === "question_requested" ||
+            eventName === "question_resolved" ||
+            eventName === "question_cancelled") &&
+            payload.question &&
+            typeof payload.question === "object") {
+            const question = payload.question;
+            if (typeof question.requestId === "string" &&
+                typeof question.sessionId === "string" &&
+                question.sessionId === refs.sessionRef.current?.sessionId) {
+                setPendingQuestion(eventName === "question_requested" && question.status === "pending"
+                    ? question
+                    : null);
+            }
+            return;
+        }
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
         const eventSeq = typeof data.seq === "number" && Number.isFinite(data.seq)
             ? data.seq
@@ -51,13 +73,20 @@ export function createChatSseEventApplier(deps) {
             : Date.now();
         if (eventName === "queue_update") {
             const revision = typeof payload.revision === "number" ? payload.revision : -1;
-            setDeferredTurn((current) => {
-                if (current && revision < current.revision)
-                    return current;
-                return payload.deferredTurn && typeof payload.deferredTurn === "object"
-                    ? payload.deferredTurn
-                    : null;
-            });
+            const owner = refs.sessionRef.current?.sessionId;
+            if (owner !== queueOwner) {
+                queueOwner = owner;
+                queueRevision = -1;
+            }
+            if (revision < queueRevision)
+                return;
+            queueRevision = revision;
+            setDeferredTurn(payload.deferredTurn && typeof payload.deferredTurn === "object"
+                ? payload.deferredTurn
+                : null);
+            if (Array.isArray(payload.deferredTurns)) {
+                setDeferredTurns(payload.deferredTurns);
+            }
             return;
         }
         if (eventName === "user_message") {
@@ -84,6 +113,40 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "compact") {
+            const summary = typeof payload.summary === "string" ? payload.summary : "";
+            const tokensBefore = typeof payload.tokensBefore === "number" && Number.isFinite(payload.tokensBefore)
+                ? Math.max(0, Math.floor(payload.tokensBefore))
+                : undefined;
+            const firstKeptEntryId = typeof payload.firstKeptEntryId === "string" && payload.firstKeptEntryId
+                ? payload.firstKeptEntryId
+                : undefined;
+            const stableId = typeof data.eventId === "string" && data.eventId
+                ? `compaction-${data.eventId}`
+                : turnId && eventSeq !== undefined
+                    ? `compaction-${turnId}-${eventSeq}`
+                    : requestId("compaction");
+            setMessages((messages) => {
+                if (messages.some((message) => message.id === stableId))
+                    return messages;
+                return [
+                    ...messages,
+                    {
+                        id: stableId,
+                        role: "assistant",
+                        kind: "compaction",
+                        text: summary || "历史上下文已精简，关键决策与当前任务已保留。",
+                        createdAt: eventAt,
+                        compaction: {
+                            ...(tokensBefore === undefined ? {} : { tokensBefore }),
+                            ...(firstKeptEntryId ? { firstKeptEntryId } : {}),
+                            ...(typeof data.eventId === "string" ? { eventId: data.eventId } : {}),
+                        },
+                    },
+                ];
+            });
+            return;
+        }
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -236,10 +299,21 @@ export function createChatSseEventApplier(deps) {
                     return true;
                 return assistantOwnsTools;
             }));
+            if (!replay)
+                onTelemetryRefresh?.();
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {
             const operation = operationFromEventPayload(payload);
+            // R9: tombstones are session-scoped. The same operation may be linked
+            // to another session, but delayed frames cannot resurrect it here.
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operation &&
+                currentSessionId &&
+                refs.unlinkedOperationIdsRef.current
+                    .get(currentSessionId)
+                    ?.has(operation.operationId))
+                return;
             if (operation) {
                 const toolCallId = typeof payload.toolCallId === "string"
                     ? payload.toolCallId
@@ -256,6 +330,23 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "operation-unlinked") {
+            // R8 AC-001/AC-R8-001: durable tombstone — the server persisted an
+            // operation-unlinked event that OVERSHADOWS any earlier operation-ref.
+            // Drop the card from the projection; replay/recovery can never
+            // resurrect it because the tombstone is appended after the ref in
+            // the same ring.
+            const operationId = typeof payload.operationId === "string" ? payload.operationId : "";
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operationId && currentSessionId) {
+                const sessionTombstones = refs.unlinkedOperationIdsRef.current.get(currentSessionId) ??
+                    new Set();
+                sessionTombstones.add(operationId);
+                refs.unlinkedOperationIdsRef.current.set(currentSessionId, sessionTombstones);
+                setOperationCards((current) => current.filter((card) => card.operationId !== operationId));
+            }
+            return;
+        }
         if (eventName === "usage") {
             if (replay)
                 return;
@@ -451,6 +542,47 @@ export function createChatSseEventApplier(deps) {
             });
         }
         else if (eventName === "error") {
+            const candidate = payload.providerError && typeof payload.providerError === "object"
+                ? payload.providerError
+                : undefined;
+            if (candidate &&
+                typeof candidate.message === "string" &&
+                typeof candidate.raw === "string" &&
+                (candidate.category === "authentication" ||
+                    candidate.category === "context-overflow" ||
+                    candidate.category === "rate-limit" ||
+                    candidate.category === "provider")) {
+                // Session hydration already restores the durable card; retained replay
+                // must not add a second synthetic row on top of it.
+                if (replay)
+                    return;
+                const providerError = candidate;
+                const errorContent = parseAssistantContent(payload.content);
+                const id = turnId && eventSeq !== undefined
+                    ? `provider-error-${turnId}-${eventSeq}`
+                    : requestId("provider-error");
+                setMessages((messages) => {
+                    if (messages.some((message) => message.id === id))
+                        return messages;
+                    const activeAlreadyOwnsContent = messages.some((message) => message.id === resolvedAssistantId &&
+                        Boolean(message.content?.length));
+                    return [
+                        ...messages,
+                        {
+                            id,
+                            role: "assistant",
+                            kind: "provider-error",
+                            text: providerError.message,
+                            createdAt: eventAt,
+                            providerError,
+                            ...(!activeAlreadyOwnsContent && errorContent
+                                ? { content: errorContent }
+                                : {}),
+                        },
+                    ];
+                });
+                return;
+            }
             setError(typeof payload.message === "string" ? payload.message : "chat error");
         }
     };

package/dist/worker/console/static-src/operator-chat/details-dag-actions.js

@@ -0,0 +1,122 @@
+function resolveDagId(id) {
+    const value = typeof id === "function" ? id() : id;
+    return value?.trim() || null;
+}
+export function createDetailsDagActions(params) {
+    const fetchImpl = params.fetchFn ?? fetch;
+    let pending = false;
+    let error = null;
+    const completionListeners = new Set();
+    const emitState = () => params.onStateChange?.({ pending, error });
+    const emitCompletion = (outcome, identity, message) => {
+        for (const listener of [...completionListeners]) {
+            try {
+                listener(outcome, identity, message);
+            }
+            catch {
+                // a listener throwing must never break the request path
+            }
+        }
+    };
+    const run = (action, issue) => {
+        const sessionId = resolveDagId(params.sessionId);
+        const operationId = resolveDagId(params.operationId);
+        if (!sessionId || !operationId || pending)
+            return false;
+        const identity = {
+            action,
+            workspaceId: resolveDagId(params.workspaceId ?? null),
+            sessionId,
+            operationId,
+        };
+        pending = true;
+        error = null;
+        emitState();
+        void (async () => {
+            try {
+                const result = await issue(identity);
+                if (!result.ok) {
+                    error = result.message ?? `DAG 关联操作失败`;
+                    params.onFailure?.(identity, error);
+                    emitCompletion("failure", identity, error);
+                    return;
+                }
+                params.onSuccess?.(identity);
+                emitCompletion("success", identity);
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                params.onFailure?.(identity, error);
+                emitCompletion("failure", identity, error);
+            }
+            finally {
+                pending = false;
+                emitState();
+            }
+        })();
+        return true;
+    };
+    return {
+        get pending() {
+            return pending;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            completionListeners.add(listener);
+            return () => completionListeners.delete(listener);
+        },
+        onAddDag() {
+            return run("add", async (identity) => {
+                // AC-002: session-scoped mutations carry the session's durable
+                // owning workspace so a global active-workspace switch can never
+                // retarget the link to another workspace's store.
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links${ownerQuery}`, {
+                    method: "POST",
+                    credentials: "same-origin",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                    body: JSON.stringify({ operationId: identity.operationId }),
+                });
+                if (!res.ok) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `添加 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+        onRemoveDag() {
+            return run("remove", async (identity) => {
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links/${encodeURIComponent(identity.operationId)}${ownerQuery}`, {
+                    method: "DELETE",
+                    credentials: "same-origin",
+                    headers: {
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                });
+                if (!res.ok && res.status !== 404) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `移除 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+    };
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Pure composer input-history state machine for Operator Chat.
+ *
+ * Extracted so ArrowUp/ArrowUp recall, unsent-draft retention and history
+ * recording can be unit-tested without mounting the React composer.
+ */
+export const INPUT_HISTORY_LIMIT = 100;
+export function createInputHistoryState() {
+    return { entries: [], index: -1, draft: "" };
+}
+/** Record one sent text and reset browsing back to the present draft. */
+export function recordInputHistoryEntry(state, text) {
+    if (!text.trim())
+        return state;
+    if (state.entries[state.entries.length - 1] === text) {
+        return state.index === -1 ? state : { ...state, index: -1, draft: "" };
+    }
+    const entries = [...state.entries, text].slice(-INPUT_HISTORY_LIMIT);
+    return { entries, index: -1, draft: "" };
+}
+/** Leave browse mode (manual typing edits the recalled text in place). */
+export function resetInputHistoryBrowsing(state) {
+    return state.index === -1 ? state : { ...state, index: -1 };
+}
+/**
+ * Recall an earlier input with the arrow keys (terminal-style).
+ *
+ * Up only engages while the caret sits on the first line and Down while it
+ * sits on the last line, so plain caret movement inside multi-line drafts is
+ * never swallowed. The unsent draft is stashed when browsing leaves the
+ * present position and restored when Down walks past the newest entry.
+ */
+export function navigateInputHistory(state, direction, context) {
+    const { text, caretStart, caretEnd } = context;
+    if (state.entries.length === 0)
+        return { handled: false };
+    if (direction === "up") {
+        if (text.slice(0, caretStart).includes("\n"))
+            return { handled: false };
+        if (state.index === -1) {
+            const index = state.entries.length - 1;
+            return {
+                handled: true,
+                state: { ...state, index, draft: text },
+                text: state.entries[index],
+            };
+        }
+        if (state.index === 0) {
+            // Already at the oldest entry: stay there (terminal behaviour).
+            return { handled: true, state, text: state.entries[0] };
+        }
+        const index = state.index - 1;
+        return {
+            handled: true,
+            state: { ...state, index },
+            text: state.entries[index],
+        };
+    }
+    if (state.index === -1)
+        return { handled: false };
+    if (text.slice(caretEnd).includes("\n"))
+        return { handled: false };
+    if (state.index >= state.entries.length - 1) {
+        return {
+            handled: true,
+            state: { ...state, index: -1 },
+            text: state.draft,
+        };
+    }
+    const index = state.index + 1;
+    return {
+        handled: true,
+        state: { ...state, index },
+        text: state.entries[index],
+    };
+}

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

@@ -30,7 +30,7 @@ export function isStaleTokenFailure(code) {
 /** Chinese, actionable copy for mutation-gate rejections. */
 export function describeMutationGateFailure(code) {
     if (isStaleTokenFailure(code)) {
-        return "页面已过期（控制台已重启），请刷新页面（F5）后重试。";
+        return "页面凭证已失效（控制台可能已重启），请刷新页面（F5）后重试。";
     }
     if (code === "host-not-loopback") {
         return "请求主机校验失败：非回环绑定时要求 Host 头，请刷新页面或检查访问地址。";

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

@@ -24,6 +24,7 @@ export function useChatRefs() {
     const abortPostedTurnIdsRef = useRef(new Set());
     const releasedClientRequestIdsRef = useRef(new Set());
     const usageResponseKeysRef = useRef(new Set());
+    const unlinkedOperationIdsRef = useRef(new Map());
     const isComposingRef = useRef(false);
     const compositionEndedAtRef = useRef(0);
     // Keep the bag identity stable: individual refs never change, so domain
@@ -53,6 +54,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     }), [
@@ -80,6 +82,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     ]);

package/dist/worker/console/static-src/operator-chat/runtime-selection-labels.js

@@ -0,0 +1,27 @@
+import { formatModelRef } from "../../chat/runtime-selection.js";
+const THINKING_SHORT_LABELS = {
+    auto: "Auto",
+    off: "Off",
+    minimal: "Minimal",
+    low: "Low",
+    medium: "Medium",
+    high: "High",
+    xhigh: "XHigh",
+    max: "Max",
+};
+export function formatThinkingSelectionLabel(selection, effective) {
+    const normalized = selection || "auto";
+    const label = THINKING_SHORT_LABELS[normalized] ?? normalized;
+    if (normalized !== "auto" || !effective)
+        return label;
+    return `${label} · ${THINKING_SHORT_LABELS[effective] ?? effective}`;
+}
+export function resolveModelDisplayName(models, activeModelRef) {
+    if (!activeModelRef)
+        return "选择模型";
+    const current = models.find((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    if (current)
+        return current.name?.trim() || current.id;
+    const slash = activeModelRef.indexOf("/");
+    return slash === -1 ? activeModelRef : activeModelRef.slice(slash + 1);
+}

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

@@ -7,6 +7,10 @@
  * Choose the submission path from the mutable ownership facts, never from a
  * possibly stale React render. A stopping intent without a bound Turn must
  * remain held until reconciliation binds or releases that ownership.
+ *
+ * Since 2026-08-23 a running Turn also accepts a queued follow-up: Enter
+ * mid-turn binds the message to the active Turn (blockedByTurnId) and the
+ * server auto-dispatches it when the Turn settles or aborts.
  */
 export function decideSubmissionRoute(input) {
     if (input.turnPhase === "stopping") {
@@ -17,7 +21,15 @@ export function decideSubmissionRoute(input) {
             }
             : { action: "hold" };
     }
-    return input.turnPhase === "idle" ? { action: "send-now" } : { action: "hold" };
+    if (input.turnPhase === "running") {
+        return input.blockedByTurnId
+            ? {
+                action: "queue-deferred",
+                blockedByTurnId: input.blockedByTurnId,
+            }
+            : { action: "hold" };
+    }
+    return { action: "send-now" };
 }
 /**
  * Reconcile a deferred PUT that raced with Stop completion. The same
@@ -28,8 +40,9 @@ export function reconcileDeferredSubmissionFromState(input) {
     const { clientRequestId, blockedByTurnId, state } = input;
     if (!state)
         return { action: "hold" };
-    if (state.deferredTurn?.clientRequestId === clientRequestId) {
-        return { action: "deferred", deferredTurn: state.deferredTurn };
+    const queued = state.deferredTurns?.find((item) => item.clientRequestId === clientRequestId) ?? (state.deferredTurn?.clientRequestId === clientRequestId ? state.deferredTurn : undefined);
+    if (queued) {
+        return { action: "deferred", deferredTurn: queued };
     }
     if (state.activeTurn?.clientRequestId === clientRequestId) {
         return { action: "accepted", turn: state.activeTurn };