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

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

@@ -1,9 +1,9 @@
 import { isSubagentTool } from "../../chat/tool-preview.js";
 /**
  * Count the collapsed-turn disclosure buckets exactly like DSH
- * `TurnProcessNodeView`: tool calls, process messages and subagents, in that
- * order. Built-in subagent delegations (`Agent` tool) count as subagents, not
- * as ordinary tool calls (2026-09-08 alignment).
+ * `TurnProcessNodeView`: tool calls, durable assistant replies and subagents,
+ * in that order. Built-in subagent delegations (`Agent` tool) count as
+ * subagents, not as ordinary tool calls (2026-09-08 alignment).
  *
  * @param items - ordered process nodes of one turn.
  * @returns the three bucket counts.
@@ -15,17 +15,30 @@ function countEntries(entries) {
     let toolCalls = 0;
     let messages = 0;
     let subagents = 0;
+    const assistantMessageIds = new Set();
     for (const entry of entries) {
-        if (entry.source === "process" && entry.item.kind === "tool") {
-            const item = entry.item;
+        if (entry.source !== "process")
+            continue;
+        const item = entry.item;
+        if (item.kind === "tool") {
             if (isSubagentTool(item.tool.toolName))
                 subagents += 1;
             else
                 toolCalls += 1;
             continue;
         }
-        messages += 1;
+        if (item.kind === "activity" || item.kind === "dag-progress") {
+            toolCalls += item.toolCallCount ?? 0;
+            continue;
+        }
+        if (item.kind !== "text" || item.text.trim() === "")
+            continue;
+        if (item.assistantMessageId)
+            assistantMessageIds.add(item.assistantMessageId);
+        else
+            messages += 1;
     }
+    messages += assistantMessageIds.size;
     return { toolCalls, messages, subagents };
 }
 /** Count only the ordered process window; prelude/post-answer nodes are kept

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

@@ -0,0 +1,21 @@
+export const TRANSCRIPT_MODE_STORAGE_KEY = "loop-console.operator-chat.transcript-mode.v1";
+export function parseTranscriptMode(value) {
+    return value === "compact" || value === "full" ? value : null;
+}
+export function loadTranscriptMode(storage) {
+    try {
+        return parseTranscriptMode(storage?.getItem(TRANSCRIPT_MODE_STORAGE_KEY)) ?? "compact";
+    }
+    catch {
+        return "compact";
+    }
+}
+export function saveTranscriptMode(mode, storage) {
+    try {
+        storage?.setItem(TRANSCRIPT_MODE_STORAGE_KEY, mode);
+    }
+    catch {
+        // Preference storage is optional.
+    }
+    return mode;
+}

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

@@ -7,6 +7,8 @@ function sameReferences(previous, next) {
 export function sameTurnGroupInputs(previous, next) {
     return (previous.key === next.key &&
         previous.user === next.user &&
+        previous.turnState === next.turnState &&
+        previous.turnClosed === next.turnClosed &&
         previous.live === next.live &&
         sameReferences(previous.assistants, next.assistants) &&
         sameReferences(previous.tools, next.tools) &&

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

@@ -2,9 +2,17 @@ export function turnProcessDisclosureKey(groupKey, answerId) {
     return `${groupKey}:generation-${answerId ?? "none"}`;
 }
 export function isTurnProcessCompact(input) {
-    return (!input.historyHasMore &&
-        !input.live &&
-        !input.hasError &&
-        input.processItemCount > 0 &&
-        !input.expanded);
+    const eligible = !input.historyHasMore &&
+        input.turnClosed &&
+        input.hasFinalAnswer &&
+        input.processItemCount > 0;
+    if (!eligible)
+        return false;
+    if (input.manualOpen)
+        return false;
+    if (input.manualClosed)
+        return true;
+    if (input.mode === "full")
+        return false;
+    return true;
 }

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`;