@tea-agent/loop-agent 0.41.1-beta.0 → 0.41.1

package/dist/worker/console/chat/routes.js

@@ -34,7 +34,7 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { makeHumanGateCard, } from "./human-gate-card.js";
 import { ContractApplyReceiptStore } from "./contract-apply-receipt-store.js";
 import { projectTaskContext } from "./context-panel.js";
-import { deriveChatSessionTelemetry } from "./session-stats.js";
+import { deriveChatSessionTelemetry, deriveChatTurnTelemetry } from "./session-stats.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
 import { openSseResponse, writeSseEvent } from "../operation-sse.js";
@@ -99,8 +99,16 @@ export function projectStoredMessagesWithEventOrder(messages, events) {
         }
         return {
             ...message,
-            ...(start ? { eventSeq: start.seq, turnId: start.turnId } : {}),
-            ...(finish ? { finishedSeq: finish.seq } : {}),
+            ...(start
+                ? {
+                    eventSeq: start.seq,
+                    turnId: start.turnId,
+                    startedAt: start.at,
+                }
+                : {}),
+            ...(finish
+                ? { finishedSeq: finish.seq, finishedAt: finish.at }
+                : {}),
         };
     });
 }
@@ -828,6 +836,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
+        turnTelemetry: deriveChatTurnTelemetry(snapshot),
         contextPressure: typeof deps.runtime.getContextPressureTelemetry === "function"
             ? deps.runtime.getContextPressureTelemetry(sessionId)
             : undefined,
@@ -1056,20 +1065,10 @@ export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientR
     }
     const item = claim.deferredTurn;
     try {
-        await deps.runtime.steer(sessionId, item.text, item.images);
-        const userMessage = await deps.store.appendMessage(sessionId, {
-            role: "user",
-            text: item.text,
-        });
-        deps.events.append(sessionId, active.turnId, {
-            kind: "user_message",
-            data: {
-                clientRequestId: item.clientRequestId,
-                message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
-            },
-        });
-        await deps.store.clearDeferredTurnForRequest(sessionId, item.clientRequestId);
-        await emitDeferredTurnUpdate(deps, sessionId, active.turnId, undefined, item.revision + 2);
+        await deps.runtime.steer(sessionId, item.clientRequestId, item.text, item.images);
+        // session.steer() only acknowledges queueing. Keep the durable item in
+        // dispatching until Pi emits the corresponding user message_start.
+        await emitDeferredTurnUpdate(deps, sessionId, active.turnId, item, item.revision);
         sendJson(res, 200, {
             ok: true,
             accepted: true,
@@ -1093,6 +1092,21 @@ export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientR
         });
     }
 }
+async function persistAcceptedSteering(deps, sessionId, turnId, userMessage, clientRequestId) {
+    deps.events.append(sessionId, turnId, {
+        kind: "user_message",
+        data: {
+            clientRequestId,
+            steering: true,
+            message: {
+                id: userMessage.id,
+                text: userMessage.text,
+                at: userMessage.at,
+            },
+        },
+    });
+    await emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, 0);
+}
 /** Lightweight busy-truth endpoint for the client reconcile loop (pi-web
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
@@ -1652,6 +1666,9 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
                 if (!res.writableEnded)
                     writeChatSse(res, persisted);
             },
+            onSteeringMessagePersisted: async (_record, userMessage, accepted) => {
+                await persistAcceptedSteering(deps, sessionId, turnId, userMessage, accepted.clientRequestId);
+            },
             onOperationAccepted: (accepted) => deps.operationLinker.link({
                 sessionId,
                 turnId,
@@ -1962,6 +1979,9 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                     if (placeholder)
                         emitSessionTitle(deps, sessionId, turn.turnId, placeholder);
                 },
+                onSteeringMessagePersisted: async (_record, userMessage, accepted) => {
+                    await persistAcceptedSteering(deps, sessionId, turn.turnId, userMessage, accepted.clientRequestId);
+                },
                 persistUserMessage: trustedPayload?.persistUserMessage,
                 onOperationAccepted: (accepted) => deps.operationLinker.link({
                     sessionId,
@@ -2637,13 +2657,13 @@ async function handleRepoHtmlPreview(res, deps, rawPath) {
             "Cache-Control": "no-store",
             "X-Content-Type-Options": "nosniff",
             "Referrer-Policy": "no-referrer",
-            // The iframe also has an empty sandbox attribute. This response-level
-            // sandbox keeps direct/popup loads isolated, while explicit local-origin
-            // style/image/font/media sources let relative project assets render.
+            // Project scripts may drive tabs and other local interactions, but the
+            // opaque sandbox still withholds same-origin access, forms, popups and
+            // top-level navigation. Network requests remain disabled below.
             "Content-Security-Policy": [
-                "sandbox",
+                "sandbox allow-scripts",
                 "default-src 'none'",
-                "script-src 'none'",
+                `script-src 'unsafe-inline' ${origin}`,
                 "object-src 'none'",
                 "frame-src 'none'",
                 "form-action 'none'",

package/dist/worker/console/chat/semantic-activity.js

@@ -296,13 +296,6 @@ function operationIdFromArgs(args) {
     const operationId = record?.operationId;
     return typeof operationId === "string" && operationId ? operationId : undefined;
 }
-function maxWaitSeconds(args) {
-    const record = parseJsonRecord(args);
-    const raw = record?.maxWaitMs;
-    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
-        return undefined;
-    return Math.max(1, Math.round(raw / 1000));
-}
 function activityRefForTool(tool) {
     // Plan A (2026-08-16): server backfills operationId on the persisted tool
     // entry (and live tool_result frames carry it in the result payload), so
@@ -313,6 +306,17 @@ function activityRefForTool(tool) {
         operationIdFromArgs(tool.resultText);
     return operationId ? `operation:${operationId}` : `tool:${tool.id}`;
 }
+export function dagProgressActivityForTool(tool) {
+    if (tool.toolName !== "operationWait")
+        return undefined;
+    const activityRef = activityRefForTool(tool);
+    if (!activityRef.startsWith("operation:"))
+        return undefined;
+    return {
+        id: `dag-progress:${activityRef}`,
+        activityRef,
+    };
+}
 function semanticKindForStatus(status) {
     if (status === "running")
         return "progress";
@@ -377,14 +381,11 @@ function nodeActivityFromMessages(messages, id, activityRef) {
 function operationWaitActivity(tool) {
     const activityRef = activityRefForTool(tool);
     const id = `activity:${tool.id}`;
-    const seconds = maxWaitSeconds(tool.args);
     if (tool.status === "running") {
         return {
             id,
             kind: "progress",
-            title: seconds
-                ? `正在等待新的执行进展，最长等待时间 ${seconds} 秒`
-                : "正在等待新的执行进展",
+            title: "正在等待新的执行进展",
             activityRef,
         };
     }

package/dist/worker/console/chat/session-stats.js

@@ -156,6 +156,102 @@ export function deriveChatSessionTelemetry(events) {
 export function billedInputTokens(usage) {
     return usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
 }
+export function deriveChatTurnTelemetry(events) {
+    const byTurn = new Map();
+    const turnOf = (turnId) => {
+        let entry = byTurn.get(turnId);
+        if (!entry) {
+            entry = {
+                turnId,
+                steps: 0,
+                llmMs: 0,
+                toolMs: 0,
+                toolCalls: 0,
+                samples: [],
+            };
+            byTurn.set(turnId, entry);
+        }
+        return entry;
+    };
+    const toolStarts = new Map();
+    for (const event of events) {
+        const at = eventTime(event);
+        const turn = turnOf(event.turnId);
+        if (event.kind === "usage") {
+            const sample = usageSample(event.data);
+            if (sample)
+                turn.samples.push(sample);
+            continue;
+        }
+        if (event.kind === "user_message") {
+            if (turn.startedAt === undefined && at !== undefined)
+                turn.startedAt = at;
+            continue;
+        }
+        if (event.kind === "agent_start") {
+            if (at !== undefined)
+                turn.stepStart = at;
+            continue;
+        }
+        if (event.kind === "tool_call") {
+            turn.toolCalls += 1;
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                toolStarts.set(`${event.turnId}\u0000${toolCallId}`, at);
+            }
+            continue;
+        }
+        if (event.kind === "tool_result") {
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                const key = `${event.turnId}\u0000${toolCallId}`;
+                const startedAt = toolStarts.get(key);
+                if (startedAt !== undefined && at >= startedAt) {
+                    turn.toolMs += at - startedAt;
+                }
+                toolStarts.delete(key);
+                // Next assistant step within the same turn starts after this tool.
+                turn.stepStart = at;
+            }
+            continue;
+        }
+        if (event.kind !== "message_end")
+            continue;
+        turn.steps += 1;
+        const recorded = stepTiming(event.data);
+        if (recorded?.llmMs !== undefined)
+            turn.llmMs += recorded.llmMs;
+        else if (at !== undefined &&
+            turn.stepStart !== undefined &&
+            at >= turn.stepStart) {
+            turn.llmMs += at - turn.stepStart;
+        }
+        if (recorded?.ttftMs !== undefined) {
+            turn.ttftMs = (turn.ttftMs ?? 0) + recorded.ttftMs;
+        }
+        if (recorded?.decodeMs !== undefined &&
+            recorded.decodeMs > 0 &&
+            recorded.outputTokens !== undefined) {
+            turn.decodeMs = (turn.decodeMs ?? 0) + recorded.decodeMs;
+            turn.decodeTokens = (turn.decodeTokens ?? 0) + recorded.outputTokens;
+        }
+        turn.stepStart = undefined;
+    }
+    return [...byTurn.values()].map((entry) => ({
+        turnId: entry.turnId,
+        steps: entry.steps,
+        llmMs: entry.llmMs,
+        toolMs: entry.toolMs,
+        toolCalls: entry.toolCalls,
+        ...(entry.ttftMs !== undefined ? { ttftMs: entry.ttftMs } : {}),
+        ...(entry.decodeMs !== undefined ? { decodeMs: entry.decodeMs } : {}),
+        ...(entry.decodeTokens !== undefined
+            ? { decodeTokens: entry.decodeTokens }
+            : {}),
+        usage: aggregateUsage(entry.samples),
+        ...(entry.startedAt !== undefined ? { startedAt: entry.startedAt } : {}),
+    }));
+}
 export function cacheHitPercent(usage) {
     const billed = billedInputTokens(usage);
     return billed > 0 ? Math.round((usage.cacheReadTokens / billed) * 100) : null;

package/dist/worker/console/chat/session-store.js

@@ -384,6 +384,44 @@ export class ChatSessionStore {
             return { deferredTurn: existing, clearedRevision: existing.revision + 1 };
         });
     }
+    /**
+     * Commit Pi's steering acceptance as one durable record transition. Removing
+     * the dispatching queue item and appending its user message together prevents
+     * a crash between two writes from replaying or losing the accepted input.
+     */
+    async acceptSteeringMessage(sessionId, clientRequestId, text) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                throw new Error(`chat session not found: ${sessionId}`);
+            const queue = [...(record.deferredTurns ?? [])];
+            const index = queue.findIndex((item) => item.clientRequestId === clientRequestId);
+            const deferredTurn = index >= 0 ? queue[index] : undefined;
+            if (!deferredTurn || deferredTurn.state !== "dispatching")
+                return undefined;
+            const message = {
+                id: `m_${record.messages.length + 1}_${Math.random().toString(36).slice(2, 8)}`,
+                role: "user",
+                text,
+                at: new Date().toISOString(),
+            };
+            queue.splice(index, 1);
+            record.messages.push(message);
+            record.deferredTurns = queue;
+            record.deferredTurn = queue[0];
+            record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
+            if (!record.displayTitle)
+                record.displayTitle = cleanChatTitle(message.text);
+            record.updatedAt = message.at;
+            await this.persist(record);
+            return {
+                record,
+                message,
+                deferredTurn,
+                clearedRevision: deferredTurn.revision + 1,
+            };
+        });
+    }
     async appendMessage(sessionId, message) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -520,84 +558,91 @@ export async function runChatTurn(options) {
     // observable to tests and to a reconnecting client reading the record).
     const pending = [];
     let settledEvent;
-    try {
-        await runtime.prompt(sessionId, text, (event) => {
-            if (event.type === "agent_settled") {
-                // The durable operation-ref linker may perform an async canonical
-                // operation read. Hold settled until those writes finish so replay
-                // never observes agent_settled before its accepted operation ref.
-                settledEvent = event;
-            }
-            else {
-                options.onEvent?.(event);
+    let eventChain = Promise.resolve();
+    const processEvent = async (event) => {
+        if (event.type === "steering_accepted") {
+            const committed = await store.acceptSteeringMessage(sessionId, event.clientRequestId, event.text);
+            if (committed) {
+                await options.onSteeringMessagePersisted?.(committed.record, committed.message, {
+                    clientRequestId: event.clientRequestId,
+                });
             }
-            switch (event.type) {
-                case "message_update":
-                case "message_end":
-                    if (event.type === "message_end") {
-                        pending.push(store.appendMessage(sessionId, {
-                            role: "assistant",
-                            text: event.text,
-                            ...(event.content && event.content.length > 0
-                                ? { content: event.content }
-                                : {}),
-                        }));
-                    }
-                    break;
-                case "tool_call":
-                    // Forwarded to the caller (SSE) for UI feedback. The actual tool
-                    // execution happens in the SDK's customTools[].execute(), which
-                    // routes to dispatchChatToolCall (Gate 3). Do NOT dispatch here —
-                    // that would double-execute every tool call (P0.2).
-                    break;
-                case "tool_result": {
-                    const acceptedOperationId = acceptedOperationIdFromResult(event.toolName, event.result);
-                    if (acceptedOperationId && options.onOperationAccepted) {
-                        pending.push(Promise.resolve(options.onOperationAccepted({
-                            sessionId,
-                            toolCallId: event.toolCallId,
-                            toolName: event.toolName,
-                            operationId: acceptedOperationId,
-                        })));
-                    }
-                    // tool_execution_end carries the real result of the tool call.
-                    // Persist exactly once (the tool message + audit trail). This is
-                    // the single point of record for tool outcomes (P0.2).
-                    const resultText = safeStringifyResult(event.result);
-                    // ChatSessionStore serializes writes per session, so these two calls
-                    // are safe to fire concurrently — neither clobbers the other.
-                    pending.push(store.appendMessage(sessionId, {
-                        role: "tool",
-                        text: resultText,
-                        toolCallId: event.toolCallId,
-                        toolName: event.toolName,
-                        isError: event.isError,
-                        // Durable tool→operation link (plan A): the restored timeline can
-                        // resolve operation:<id> refs without the live operation-ref event.
-                        ...(acceptedOperationId
-                            ? { operationId: acceptedOperationId }
-                            : {}),
-                    }));
-                    pending.push(store.recordToolInvocation(sessionId, {
-                        toolCallId: event.toolCallId,
-                        toolName: event.toolName,
-                        ok: !event.isError,
-                    }));
-                    break;
-                }
-                case "error":
-                    turnError = { code: "CHAT_TURN_ERROR", message: event.message };
+            return;
+        }
+        if (event.type === "agent_settled") {
+            // The durable operation-ref linker may perform an async canonical
+            // operation read. Hold settled until those writes finish so replay
+            // never observes agent_settled before its accepted operation ref.
+            settledEvent = event;
+        }
+        else {
+            options.onEvent?.(event);
+        }
+        switch (event.type) {
+            case "message_update":
+            case "message_end":
+                if (event.type === "message_end") {
                     pending.push(store.appendMessage(sessionId, {
                         role: "assistant",
-                        kind: "provider-error",
-                        text: event.providerError.message,
-                        providerError: event.providerError,
+                        text: event.text,
                         ...(event.content && event.content.length > 0
                             ? { content: event.content }
                             : {}),
                     }));
-                    break;
+                }
+                break;
+            case "tool_call":
+                // Forwarded to the caller (SSE) for UI feedback. The actual tool
+                // execution happens in the SDK's customTools[].execute(), which
+                // routes to dispatchChatToolCall (Gate 3). Do NOT dispatch here —
+                // that would double-execute every tool call (P0.2).
+                break;
+            case "tool_result": {
+                const acceptedOperationId = acceptedOperationIdFromResult(event.toolName, event.result);
+                if (acceptedOperationId && options.onOperationAccepted) {
+                    pending.push(Promise.resolve(options.onOperationAccepted({
+                        sessionId,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        operationId: acceptedOperationId,
+                    })));
+                }
+                const resultText = safeStringifyResult(event.result);
+                pending.push(store.appendMessage(sessionId, {
+                    role: "tool",
+                    text: resultText,
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    isError: event.isError,
+                    ...(acceptedOperationId ? { operationId: acceptedOperationId } : {}),
+                }));
+                pending.push(store.recordToolInvocation(sessionId, {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    ok: !event.isError,
+                }));
+                break;
             }
+            case "error":
+                turnError = { code: "CHAT_TURN_ERROR", message: event.message };
+                pending.push(store.appendMessage(sessionId, {
+                    role: "assistant",
+                    kind: "provider-error",
+                    text: event.providerError.message,
+                    providerError: event.providerError,
+                    ...(event.content && event.content.length > 0
+                        ? { content: event.content }
+                        : {}),
+                }));
+                break;
+        }
+    };
+    try {
+        await runtime.prompt(sessionId, text, (event) => {
+            // Pi's event callback is synchronous. Serialize projection work so the
+            // accepted steering user_message is durable and sequenced before any
+            // assistant/tool event that follows it.
+            eventChain = eventChain.then(() => processEvent(event)).catch(() => undefined);
         }, {
             signal: options.signal,
             images: options.images,
@@ -605,10 +650,12 @@ export async function runChatTurn(options) {
         });
     }
     catch (error) {
+        await eventChain;
         await Promise.allSettled(pending);
         const message = error instanceof Error ? error.message : String(error);
         return { ok: false, error: { code: "CHAT_TURN_FAILED", message } };
     }
+    await eventChain;
     await Promise.allSettled(pending);
     if (settledEvent)
         options.onEvent?.(settledEvent);

package/dist/worker/console/chat/shortcuts.js

@@ -37,7 +37,7 @@ export const SHORTCUTS = [
     {
         command: "/reload",
         label: "Reload session",
-        description: "重新加载当前 Pi 会话的设置、扩展、技能、提示词、主题与上下文文件（不产生消息）",
+        description: "重新加载当前 Pi 会话的设置、扩展、技能、提示词、主题、上下文文件及模型与认证配置（不产生消息）",
         action: "reload",
         source: "operator",
     },