@tea-agent/loop-agent 0.42.0-next.2 → 0.42.0-next.4

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",
     },

package/dist/worker/console/chat/turn-process.js

@@ -96,7 +96,10 @@ export function hydrateSessionThread(raw) {
                 ...(item.operationId ? { operationId: item.operationId } : {}),
             };
             toolCalls.push(entry);
-            pendingTools.push(entry);
+            // Durable rows with an event sequence are already self-ordering. Only
+            // legacy rows need the historical "next assistant" attribution fallback.
+            if (item.eventSeq === undefined)
+                pendingTools.push(entry);
         }
     }
     return { messages, toolCalls };
@@ -151,48 +154,81 @@ function collapseDagProgressItems(items) {
         return true;
     });
 }
-function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
-    let buffer = [];
-    for (const block of blocks) {
-        if (block.type === "thinking") {
-            flushToolBuffer(processItems, buffer);
-            buffer = [];
-            processItems.push({ kind: "thinking", thinking: block.thinking });
-            continue;
-        }
-        if (block.type === "text") {
-            flushToolBuffer(processItems, buffer);
-            buffer = [];
-            if (block.text.trim()) {
-                processItems.push({ kind: "text", text: block.text });
+function fillProcessDetails(group) {
+    const usedToolIds = new Set();
+    const nodes = [];
+    let insertionOrder = 0;
+    const addNode = (input) => {
+        if (input.items.length === 0)
+            return;
+        nodes.push({
+            ...(input.eventSeq === undefined ? {} : { eventSeq: input.eventSeq }),
+            createdAt: input.createdAt,
+            insertionOrder: insertionOrder++,
+            items: input.items,
+        });
+    };
+    const addAssistantNode = (assistant, blocks, includeProviderError = false) => {
+        let items = [];
+        let anchorSeq = assistant.eventSeq;
+        let anchorAt = assistant.createdAt;
+        const flushItems = () => {
+            addNode({
+                items,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: anchorAt,
+            });
+            items = [];
+        };
+        for (const block of blocks) {
+            if (block.type === "thinking") {
+                items.push({ kind: "thinking", thinking: block.thinking });
+                continue;
             }
-            continue;
+            if (block.type === "text") {
+                if (block.text.trim())
+                    items.push({ kind: "text", text: block.text });
+                continue;
+            }
+            const tool = group.tools.find((entry) => entry.id === block.toolCallId);
+            if (!tool || usedToolIds.has(tool.id))
+                continue;
+            flushItems();
+            usedToolIds.add(tool.id);
+            const toolItems = [];
+            flushToolBuffer(toolItems, [tool]);
+            addNode({
+                items: toolItems,
+                ...(tool.eventSeq === undefined
+                    ? anchorSeq === undefined
+                        ? {}
+                        : { eventSeq: anchorSeq }
+                    : { eventSeq: tool.eventSeq }),
+                createdAt: tool.createdAt,
+            });
+            anchorSeq = tool.eventSeq ?? anchorSeq;
+            anchorAt = tool.createdAt;
         }
-        const tool = group.tools.find((entry) => entry.id === block.toolCallId);
-        if (tool && !usedToolIds.has(tool.id)) {
-            buffer.push(tool);
+        if (includeProviderError && assistant.providerError) {
+            items.push({ kind: "provider-error", error: assistant.providerError });
+        }
+        flushItems();
+        // Preserve the old-data fallback after this stage. Sequenced unmatched
+        // tools stay independent and are merged by their own eventSeq below.
+        const legacyUnmatched = group.tools.filter((tool) => !usedToolIds.has(tool.id) &&
+            tool.eventSeq === undefined &&
+            tool.assistantMessageId === assistant.id);
+        for (const tool of sortToolsStable(legacyUnmatched)) {
             usedToolIds.add(tool.id);
+            const toolItems = [];
+            flushToolBuffer(toolItems, [tool]);
+            addNode({
+                items: toolItems,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: Math.max(anchorAt, tool.createdAt),
+            });
         }
-    }
-    flushToolBuffer(processItems, buffer);
-}
-/**
- * Insert tools attributed to this assistant stage but without a matching
- * content toolCall block (live SSE tool_call frames often arrive before the
- * assistant content does). They follow the stage's thinking/text instead of
- * sinking to the end of the whole turn.
- */
-function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds) {
-    const unmatched = group.tools.filter((tool) => !usedToolIds.has(tool.id) && tool.assistantMessageId === assistant.id);
-    if (unmatched.length === 0)
-        return;
-    for (const tool of unmatched)
-        usedToolIds.add(tool.id);
-    flushToolBuffer(processItems, unmatched);
-}
-function fillProcessDetails(group) {
-    const usedToolIds = new Set();
-    const processItems = [];
+    };
     const lastAssistant = group.assistants.at(-1);
     const finalAssistant = lastAssistant?.kind === "provider-error" ? undefined : lastAssistant;
     const finalIndex = finalAssistant
@@ -202,29 +238,46 @@ function fillProcessDetails(group) {
         if (index === finalIndex)
             continue;
         if (assistant.kind === "provider-error" && assistant.providerError) {
-            emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
-            appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
-            processItems.push({
-                kind: "provider-error",
-                error: assistant.providerError,
-            });
+            addAssistantNode(assistant, getDisplayableAssistantBlocks(assistant.content ?? []), true);
             continue;
         }
-        emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
-        appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+        addAssistantNode(assistant, getDisplayableAssistantBlocks(assistant.content ?? []));
     }
     const blocks = finalAssistant?.content ?? [];
     const split = splitFinalAssistantBlocks(blocks, { isStreaming: group.live });
-    emitProcessBlocks(split.processBlocks, group, processItems, usedToolIds);
     if (finalAssistant) {
-        appendAssistantUnmatchedTools(group, finalAssistant, processItems, usedToolIds);
+        addAssistantNode(finalAssistant, split.processBlocks);
     }
-    // Bounded fallback for legacy restored rows with no assistant attribution:
-    // keep them at this turn's end in stable server order instead of randomly
-    // interleaving them into earlier stages.
-    const orphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
-    if (orphans.length > 0)
-        flushToolBuffer(processItems, orphans);
+    // DSH-style peer nodes: a sequenced tool keeps its own anchor instead of
+    // being appended to whichever assistant id happens to own it at render time.
+    for (const tool of group.tools) {
+        if (usedToolIds.has(tool.id) || tool.eventSeq === undefined)
+            continue;
+        usedToolIds.add(tool.id);
+        const items = [];
+        flushToolBuffer(items, [tool]);
+        nodes.push({
+            eventSeq: tool.eventSeq,
+            createdAt: tool.createdAt,
+            insertionOrder: insertionOrder++,
+            items,
+        });
+    }
+    const fullySequenced = nodes.every((node) => node.eventSeq !== undefined);
+    nodes.sort((a, b) => {
+        if (fullySequenced && a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        return a.insertionOrder - b.insertionOrder;
+    });
+    const processItems = nodes.flatMap((node) => node.items);
+    // Bounded fallback for legacy restored rows with neither event sequence nor
+    // assistant attribution: keep them at the turn end in stable local order.
+    const legacyOrphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
+    if (legacyOrphans.length > 0)
+        flushToolBuffer(processItems, legacyOrphans);
     group.processItems = collapseDagProgressItems(processItems);
     if (!finalAssistant)
         return;
@@ -306,7 +359,9 @@ export function buildTurnProcessGroups(input) {
         if (assigned.has(tool.id))
             continue;
         if (tool.turnId) {
-            const byTurn = groups.find((group) => group.tools.some((t) => t.turnId === tool.turnId) ||
+            const byTurn = groups.find((group) => group.user?.turnId === tool.turnId ||
+                group.assistants.some((assistant) => assistant.turnId === tool.turnId) ||
+                group.tools.some((t) => t.turnId === tool.turnId) ||
                 group.key === `turn-${tool.turnId}` ||
                 (group.user && `restored-${group.user.id}` === tool.turnId));
             if (byTurn) {

package/dist/worker/console/frontend-human-decision-adapter.js

@@ -0,0 +1,19 @@
+import { parseFrontendHumanDecisionProjection } from "../../workflows/dag/frontend-human-decision.js";
+/** Worker/Console persistence seam. Canonical validation and freshness remain in the workflow service. */
+export function createFrontendHumanDecisionAdapter(store) {
+    return {
+        async load(operationId) {
+            const record = await store.get(operationId);
+            if (!record || record.revision === undefined || !record.frontendHumanDecision)
+                return undefined;
+            return { revision: record.revision, projection: parseFrontendHumanDecisionProjection(record.frontendHumanDecision) };
+        },
+        materialize(input) {
+            return store.materializeFrontendHumanDecision(input);
+        },
+        consume(input) {
+            return store.consumeFrontendHumanDecision(input);
+        },
+        initializeSplit: store.initializeFrontendHumanApprovedSplit.bind(store),
+    };
+}

package/dist/worker/console/frontend-split-operation-adapter.js

@@ -0,0 +1,20 @@
+import { FrontendSplitOrchestrator, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
+/** Worker/Console boundary adapter. All orchestration policy remains canonical. */
+export function createFrontendSplitOperationAdapter(dependencies) {
+    const ports = {
+        load: async (operationId) => {
+            const record = await dependencies.store.get(operationId);
+            return record?.frontendSplit === undefined ? undefined : frontendSplitProjectionSchema.parse(record.frontendSplit);
+        },
+        compareAndSwap: (input) => dependencies.store.compareAndSwapFrontendSplit(input),
+        materialize: async (request) => {
+            const result = await dependencies.materializer.materialize(request);
+            return { taskId: result.taskId, operationId: result.operationId };
+        },
+        schedule: dependencies.schedule,
+        auditStale: dependencies.auditStale,
+        loadChildCloseoutFacts: (input) => dependencies.store.loadChildCloseoutFacts(input),
+        settleAggregate: (input) => dependencies.store.settleFrontendSplitAggregate({ ...input, prepareAggregate: dependencies.prepareAggregate }),
+    };
+    return new FrontendSplitOrchestrator(ports);
+}

package/dist/worker/console/index.js

@@ -11,6 +11,9 @@ export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateT
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "../../infrastructure/console/app-data.js";
 export { OperationStore } from "../../infrastructure/console/operation-store.js";
+export { createFrontendSplitOperationAdapter } from "./frontend-split-operation-adapter.js";
+export { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+export { FrontendSplitTaskMaterializer } from "../materialize/frontend-split-task-materializer.js";
 export { createOperationEventStore } from "./operation-sse.js";
 export { DagConfirmationStore } from "./dag-confirmation.js";
 export { DraftStore } from "./draft-store.js";