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

package/dist/worker/console/chat/pi-runtime.js

@@ -297,6 +297,35 @@ export function createWizardLocalHeadersExtension(options) {
 export { THINKING_LEVELS, RuntimeSnapshotUnavailableError, projectRuntimeSnapshot, };
 export { createDefaultPiSdkBindings } from "./pi-runtime/sdk-bindings.js";
 export { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage };
+export function buildRequestContextEvent(input) {
+    const systemPrompt = input.session.state?.systemPrompt ?? input.session.systemPrompt ?? "";
+    const activeTools = input.session.getActiveToolNames()
+        .filter((name) => typeof name === "string" && name.trim())
+        .slice(0, 256);
+    const provider = input.session.model?.provider;
+    const modelId = input.session.model?.modelId ?? input.session.model?.id;
+    const sources = ["system", "conversation"];
+    if (activeTools.length > 0)
+        sources.push("tools");
+    if (input.imageCount > 0)
+        sources.push("images");
+    return {
+        type: "request_context",
+        sessionId: input.sessionId,
+        requestId: `${input.turnId}:request:1`,
+        step: 1,
+        ...(provider && modelId ? { model: { provider, modelId } } : {}),
+        ...(input.session.thinkingLevel
+            ? { thinkingLevel: input.session.thinkingLevel }
+            : {}),
+        systemPromptHash: createHash("sha256").update(systemPrompt).digest("hex"),
+        systemPromptChars: systemPrompt.length,
+        activeTools,
+        inputChars: input.text.length,
+        imageCount: input.imageCount,
+        sources,
+    };
+}
 function readSessionManagerId(manager) {
     if (!manager || typeof manager !== "object")
         return undefined;
@@ -438,12 +467,12 @@ export class ConsolePiRuntime {
             downloadsDir: path.join(this.options.sessionDir, "..", "browser-downloads"),
             screenshotsDir: path.join(this.options.sessionDir, "..", "browser-screenshots"),
         });
-        // Governed DB connections persist under the repo app-data namespace
-        // (`<repoNamespace>/db/connections.json`) — never inside the repo.
+        // Governed DB connections are Console-global, not repository-scoped.
+        // This keeps named connections available when the user switches folders.
         this.ownsDbConnections = options.dbConnections === undefined;
         this.dbConnections =
             options.dbConnections ??
-                new DbConnectionRegistry(path.join(this.options.sessionDir, "..", "db"));
+                new DbConnectionRegistry(path.join(options.globalAppDataRoot ?? path.resolve(this.options.sessionDir, ".."), "db"), undefined, undefined, path.join(this.options.sessionDir, "..", "db"));
         this.exploreOrchestrator = new ExploreOrchestrator({
             cwd: this.options.cwd,
             bindings: this.bindings,
@@ -1977,6 +2006,14 @@ export class ConsolePiRuntime {
             };
             emitContextUsage();
             await this.runPrePromptCompaction(sessionId, session, text, options?.images?.length ?? 0, onEvent);
+            onEvent(buildRequestContextEvent({
+                sessionId,
+                turnId: options?.turnId ?? `${sessionId}:active`,
+                session,
+                text,
+                imageCount: options?.images?.length ?? 0,
+            }));
+            let step = 0;
             let stepStartedAt;
             let firstTokenAt;
             let pendingProviderError;
@@ -1985,12 +2022,24 @@ export class ConsolePiRuntime {
             const emitPendingProviderError = () => {
                 if (!pendingProviderError)
                     return;
-                onEvent(pendingProviderError);
+                const error = pendingProviderError;
+                onEvent(error);
+                onEvent({
+                    type: "turn_error",
+                    sessionId,
+                    step: Math.max(1, step),
+                    ...(error.providerError.code === undefined
+                        ? {}
+                        : { code: String(error.providerError.code) }),
+                    message: error.message,
+                });
                 pendingProviderError = undefined;
                 providerErrorEmitted = true;
             };
             unsub = session.subscribe((event) => {
                 const observedAt = Date.now();
+                if (event.type === "turn_start")
+                    step += 1;
                 if (event.type === "message_start" && isUserSdkMessage(event.message)) {
                     if (!initialUserMessageStarted) {
                         // The first user message_start belongs to session.prompt(text), not
@@ -2021,7 +2070,7 @@ export class ConsolePiRuntime {
                 const compactionId = event.type === "compaction_start" || event.type === "compaction_end"
                     ? activeCompaction?.compactionId ?? newCompactionId(sessionId)
                     : undefined;
-                const mapped = mapSdkEvent(sessionId, event, compactionId);
+                const mapped = mapSdkEvent(sessionId, event, compactionId, Math.max(1, step));
                 if (event.type === "compaction_end")
                     activeCompaction = undefined;
                 if (mapped?.type === "error") {
@@ -2046,7 +2095,7 @@ export class ConsolePiRuntime {
                 if (mapped?.type === "agent_settled") {
                     emitPendingProviderError();
                 }
-                if (mapped?.type === "agent_start") {
+                if (mapped?.type === "step_start" || mapped?.type === "agent_start") {
                     stepStartedAt = observedAt;
                     firstTokenAt = undefined;
                 }
@@ -2074,6 +2123,13 @@ export class ConsolePiRuntime {
                                 : { outputTokens: usage.outputTokens }),
                         };
                     onEvent({ ...mapped, ...(timing ? { timing } : {}) });
+                    if (mapped.stopReason === "length") {
+                        onEvent({
+                            type: "turn_max_tokens",
+                            sessionId,
+                            step: mapped.step ?? Math.max(1, step),
+                        });
+                    }
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
                     emitContextUsage();
@@ -2331,7 +2387,7 @@ export class ConsolePiRuntime {
             this.dbConnections.dispose();
     }
 }
-function mapAssistantMessageEvent(type, sessionId, message) {
+function mapAssistantMessageEvent(type, sessionId, message, step) {
     const record = message !== null && typeof message === "object"
         ? message
         : undefined;
@@ -2355,6 +2411,10 @@ function mapAssistantMessageEvent(type, sessionId, message) {
         sessionId,
         text: extractAssistantText(message),
         ...(content.length > 0 ? { content } : {}),
+        step,
+        ...(type === "message_end" && typeof record?.stopReason === "string"
+            ? { stopReason: record.stopReason }
+            : {}),
     };
 }
 function isUserSdkMessage(message) {
@@ -2362,10 +2422,12 @@ function isUserSdkMessage(message) {
         typeof message === "object" &&
         message.role === "user");
 }
-function mapSdkEvent(sessionId, event, compactionId) {
+export function mapSdkEvent(sessionId, event, compactionId, step = 1) {
     switch (event.type) {
         case "agent_start":
             return { type: "agent_start", sessionId };
+        case "turn_start":
+            return { type: "step_start", sessionId, step };
         case "agent_end":
             return {
                 type: "agent_end",
@@ -2375,15 +2437,50 @@ function mapSdkEvent(sessionId, event, compactionId) {
         case "message_update":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_update", sessionId, event.message);
+            return mapAssistantMessageEvent("message_update", sessionId, event.message, step);
         case "message_end":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_end", sessionId, event.message);
-        case "turn_end":
-            // Usage is emitted from message_end (see prompt subscribe). turn_end
-            // carries the same final assistant message and would double-count.
-            return undefined;
+            return mapAssistantMessageEvent("message_end", sessionId, event.message, step);
+        case "turn_end": {
+            const record = event.message && typeof event.message === "object"
+                ? event.message
+                : undefined;
+            const reason = record?.stopReason;
+            return {
+                type: "step_end",
+                sessionId,
+                step,
+                outcome: reason === "error"
+                    ? "failed"
+                    : reason === "aborted"
+                        ? "interrupted"
+                        : "completed",
+            };
+        }
+        case "auto_retry_start":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                maxAttempts: event.maxAttempts,
+                delayMs: event.delayMs,
+                errorMessage: redactRuntimeText(event.errorMessage, 600),
+                state: "scheduled",
+            };
+        case "auto_retry_end":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                state: event.success ? "completed" : "failed",
+                success: event.success,
+                ...(event.finalError
+                    ? { errorMessage: redactRuntimeText(event.finalError, 600) }
+                    : {}),
+            };
         case "tool_execution_start":
             return {
                 type: "tool_call",
@@ -2391,6 +2488,10 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
                 args: event.args,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
             };
         case "tool_execution_end":
             return {
@@ -2400,6 +2501,10 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolName: event.toolName,
                 result: event.result,
                 isError: event.isError,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
             };
         case "agent_settled":
             return { type: "agent_settled", sessionId };
@@ -2446,8 +2551,19 @@ function mapSdkEvent(sessionId, event, compactionId) {
                     : {}),
             };
         }
-        default:
+        case "message_start":
+        case "queue_update":
             return undefined;
+        default:
+            {
+                const unknownEvent = event;
+                return {
+                    type: "unknown",
+                    sessionId,
+                    eventType: String(unknownEvent.type ?? "unknown"),
+                    value: unknownEvent,
+                };
+            }
     }
 }
 function newCompactionId(sessionId) {

package/dist/worker/console/chat/provider-error.js

@@ -85,15 +85,3 @@ export function parseProviderError(value) {
         category: classify({ message, raw, code }),
     };
 }
-export function providerErrorTitle(category) {
-    switch (category) {
-        case "authentication":
-            return "认证失败";
-        case "context-overflow":
-            return "上下文过大";
-        case "rate-limit":
-            return "请求过于频繁";
-        default:
-            return "Provider 请求失败";
-    }
-}

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

@@ -19,7 +19,7 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_
 import { InvalidChatSessionModeError, SESSION_MODE_ACTION_DENIED_CODE, SESSION_MODE_ACTION_DENIED_MESSAGE, SESSION_MODE_IMMUTABLE_CODE, UnknownChatSessionModeError, isWorkflowSessionMode, parseCreateSessionMode, readStoredSessionMode, shouldAcceptOperatorSnapshot, } from "./session-mode.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle, acceptedOperationIdFromResult, isBlankChatSession } from "./session-store.js";
-import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
+import { hashChatTurnPayload, projectChatToolEventPayload, projectUnknownChatEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./deferred-turn.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
 import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
@@ -197,6 +197,16 @@ export function projectStoredMessagesWithEventOrder(messages, events) {
             ...(finish
                 ? { finishedSeq: finish.seq, finishedAt: finish.at }
                 : {}),
+            ...(start && typeof start.data.step === "number"
+                ? { step: start.data.step }
+                : {}),
+            ...(start &&
+                typeof start.data.parentToolCallId ===
+                    "string"
+                ? {
+                    parentToolCallId: start.data.parentToolCallId,
+                }
+                : {}),
         };
     });
 }
@@ -243,10 +253,99 @@ function writeChatSse(res, event) {
 /** Map a runtime ChatTurnEvent to the persisted event-store partial.
  *
  * Returns undefined for heartbeat (not persisted — keep-alive only). */
-function turnEventToStorePartial(event) {
+export function turnEventToStorePartial(event) {
     switch (event.type) {
         case "agent_start":
             return { kind: "agent_start", data: {} };
+        case "step_start":
+        case "step_end":
+            return {
+                kind: event.type,
+                data: {
+                    step: Number(event.step ?? 1),
+                    ...(event.type === "step_end"
+                        ? { outcome: String(event.outcome ?? "completed") }
+                        : {}),
+                },
+            };
+        case "model_retry":
+            {
+                const retryState = event.state === "completed" || event.state === "failed"
+                    ? event.state
+                    : "scheduled";
+                return {
+                    kind: "model_retry",
+                    data: {
+                        step: Number(event.step ?? 1),
+                        attempt: Number(event.attempt ?? 1),
+                        ...(typeof event.maxAttempts === "number"
+                            ? { maxAttempts: event.maxAttempts }
+                            : {}),
+                        ...(typeof event.delayMs === "number" ? { delayMs: event.delayMs } : {}),
+                        ...(typeof event.errorMessage === "string"
+                            ? { errorMessage: event.errorMessage }
+                            : {}),
+                        state: retryState,
+                        ...(typeof event.success === "boolean" ? { success: event.success } : {}),
+                    },
+                };
+            }
+        case "turn_max_tokens":
+            return {
+                kind: "turn_max_tokens",
+                data: { step: Number(event.step ?? 1) },
+            };
+        case "turn_error":
+            return {
+                kind: "turn_error",
+                data: {
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.code === "string" ? { code: event.code } : {}),
+                    message: String(event.message ?? "模型请求失败"),
+                },
+            };
+        case "request_context":
+            return {
+                kind: "request_context",
+                data: {
+                    requestId: String(event.requestId ?? ""),
+                    step: Number(event.step ?? 1),
+                    ...(event.model && typeof event.model === "object"
+                        ? { model: event.model }
+                        : {}),
+                    ...(typeof event.thinkingLevel === "string"
+                        ? { thinkingLevel: event.thinkingLevel }
+                        : {}),
+                    systemPromptHash: String(event.systemPromptHash ?? ""),
+                    systemPromptChars: Number(event.systemPromptChars ?? 0),
+                    activeTools: Array.isArray(event.activeTools) ? event.activeTools : [],
+                    inputChars: Number(event.inputChars ?? 0),
+                    imageCount: Number(event.imageCount ?? 0),
+                    sources: Array.isArray(event.sources) ? event.sources : [],
+                },
+            };
+        case "command":
+            return {
+                kind: "command",
+                data: {
+                    commandId: String(event.commandId ?? ""),
+                    name: String(event.name ?? "unknown"),
+                    ...(typeof event.argsPreview === "string"
+                        ? { argsPreview: event.argsPreview }
+                        : {}),
+                    ...(typeof event.action === "string" ? { action: event.action } : {}),
+                    outcome: event.outcome === "failed" ? "failed" : "completed",
+                    ...(typeof event.message === "string" ? { message: event.message } : {}),
+                },
+            };
+        case "unknown":
+            return {
+                kind: "unknown",
+                data: projectUnknownChatEventPayload({
+                    eventType: String(event.eventType ?? "unknown"),
+                    value: event.value,
+                }),
+            };
         case "message_update":
         case "message_end": {
             const content = parseAssistantContent(event.content);
@@ -291,6 +390,10 @@ function turnEventToStorePartial(event) {
                         event.messageId
                         ? { messageId: event.messageId }
                         : {}),
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.stopReason === "string"
+                        ? { stopReason: event.stopReason }
+                        : {}),
                 },
             };
         }
@@ -304,6 +407,10 @@ function turnEventToStorePartial(event) {
                     toolCallId: String(event.toolCallId ?? ""),
                     toolName: String(event.toolName ?? ""),
                     value: event.args,
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.parentToolCallId === "string"
+                        ? { parentToolCallId: event.parentToolCallId }
+                        : {}),
                 }),
             };
         case "tool_result": {
@@ -318,6 +425,10 @@ function turnEventToStorePartial(event) {
                     toolName: String(event.toolName ?? ""),
                     value: event.result,
                     isError: Boolean(event.isError),
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.parentToolCallId === "string"
+                        ? { parentToolCallId: event.parentToolCallId }
+                        : {}),
                     ...(resultOperationId ? { operationId: resultOperationId } : {}),
                 }),
             };
@@ -1029,6 +1140,16 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
             turnId: event.turnId,
             data: event.data,
         })),
+        conversationEvents: snapshot.filter((event) => [
+            "step_start",
+            "step_end",
+            "model_retry",
+            "turn_error",
+            "turn_max_tokens",
+            "request_context",
+            "command",
+            "unknown",
+        ].includes(event.kind)),
         lastEventId: lastEvent?.eventId ?? null,
         lastEventSeq: lastEvent?.seq ?? 0,
     });
@@ -2982,7 +3103,8 @@ async function handleSddBingo(req, res, deps, sessionId) {
             throw new SddDataAlignmentError("SDD_INVALID_SKILL_NAME", "请求体只允许 skillName 字段", 400);
         }
         const result = await deps.sddDataAlignment.report(sessionId, body.skillName);
-        deps.events.append(sessionId, deps.events.latestTurnId(sessionId) ?? `${sessionId}:operator-action`, {
+        const turnId = deps.events.latestTurnId(sessionId) ?? `${sessionId}:operator-action`;
+        deps.events.append(sessionId, turnId, {
             kind: "operator-action",
             data: {
                 schemaVersion: 1,
@@ -2991,6 +3113,17 @@ async function handleSddBingo(req, res, deps, sessionId) {
                 telemetrySessionId: result.telemetrySessionId,
             },
         });
+        deps.events.append(sessionId, `${sessionId}:command:${result.telemetrySessionId}`, {
+            kind: "command",
+            data: {
+                commandId: `sdd-bingo:${result.telemetrySessionId}`,
+                name: "sdd-bingo",
+                ...(result.skillName ? { argsPreview: result.skillName } : {}),
+                action: "sdd-bingo",
+                outcome: "completed",
+                message: `Session: ${result.telemetrySessionId}`,
+            },
+        });
         sendJson(res, 200, {
             ok: true,
             skillName: result.skillName,

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

@@ -3,7 +3,89 @@
  */
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
 import { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
+import { compareChatOrder } from "./turn-order.js";
 import { ensureLinkedSubmissionOrder } from "./timeline-message-order.js";
+function conversationNodeOrder(node) {
+    return { eventSeq: node.anchorSeq, createdAt: node.at };
+}
+function processItemOrder(item, group) {
+    const createdAt = item.createdAt ??
+        (item.kind === "tool" ? item.tool.createdAt : undefined) ??
+        group.assistants[0]?.createdAt ??
+        0;
+    const eventSeq = item.eventSeq ?? (item.kind === "tool" ? item.tool.eventSeq : undefined);
+    return eventSeq === undefined ? { createdAt } : { eventSeq, createdAt };
+}
+function compareFlowEntries(a, b) {
+    return compareChatOrder(a.order, b.order);
+}
+/** Base identity for a rendered process row. Content is deliberately excluded
+ * so streaming text updates keep the same React instance. */
+function processItemKey(item, order) {
+    if (item.kind === "tool")
+        return `tool:${item.tool.id}`;
+    if (item.kind === "activity")
+        return `activity:${item.activity.id}`;
+    if (item.kind === "dag-progress")
+        return `dag-progress:${item.progress.id}`;
+    const anchor = order.eventSeq ?? order.createdAt;
+    return `${item.kind}:${anchor}`;
+}
+export function turnProcessItemKey(item, occurrence = 0) {
+    const order = {
+        ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
+        createdAt: item.createdAt ?? (item.kind === "tool" ? item.tool.createdAt : 0),
+    };
+    const base = processItemKey(item, order);
+    return occurrence === 0 ? base : `${base}:${occurrence}`;
+}
+/**
+ * Project one turn into the same ordered buckets used by the main timeline and
+ * the trajectory view. Only existing request/running-step nodes are prelude;
+ * retry and other lifecycle nodes stay in the collapsible process window.
+ */
+export function projectTurnFlow(group) {
+    const conversationItems = group.conversationItems ?? [];
+    const prelude = conversationItems
+        .filter((item) => item.kind === "request" ||
+        (item.kind === "step" && item.node.status === "running"))
+        .sort((a, b) => compareChatOrder(conversationNodeOrder(a.node), conversationNodeOrder(b.node)));
+    const postAnswer = conversationItems
+        .filter((item) => item.kind === "max-tokens")
+        .sort((a, b) => compareChatOrder(conversationNodeOrder(a.node), conversationNodeOrder(b.node)));
+    const preludeKeys = new Set(prelude.map((item) => item.node.key));
+    const postAnswerKeys = new Set(postAnswer.map((item) => item.node.key));
+    const process = [];
+    for (const item of group.processItems) {
+        process.push({
+            source: "process",
+            key: "",
+            item,
+            order: processItemOrder(item, group),
+        });
+    }
+    for (const item of conversationItems) {
+        if (preludeKeys.has(item.node.key) || postAnswerKeys.has(item.node.key))
+            continue;
+        process.push({
+            source: "conversation",
+            key: `conversation:${item.node.key}`,
+            item,
+            order: conversationNodeOrder(item.node),
+        });
+    }
+    process.sort(compareFlowEntries);
+    const occurrences = new Map();
+    for (const entry of process) {
+        const base = entry.source === "conversation"
+            ? entry.key
+            : processItemKey(entry.item, entry.order);
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        entry.key = occurrence === 0 ? base : `${base}:${occurrence}`;
+    }
+    return { prelude, process, postAnswer };
+}
 function emptyGroup(key, turnId) {
     return {
         key,
@@ -11,6 +93,7 @@ function emptyGroup(key, turnId) {
         assistants: [],
         tools: [],
         processItems: [],
+        conversationItems: [],
         live: false,
     };
 }
@@ -92,6 +175,10 @@ export function hydrateSessionThread(raw) {
                     ? finishedAtMs
                     : createdAt,
                 turnId: item.turnId ?? turnId,
+                ...(item.step === undefined ? {} : { step: item.step }),
+                ...(item.parentToolCallId
+                    ? { parentToolCallId: item.parentToolCallId }
+                    : {}),
                 ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
                 ...(item.finishedSeq === undefined
                     ? {}
@@ -132,17 +219,21 @@ function flushToolBuffer(processItems, buffer) {
         return;
     const sorted = sortToolsStable(buffer);
     for (const tool of sorted) {
+        const order = {
+            ...(tool.eventSeq === undefined ? {} : { eventSeq: tool.eventSeq }),
+            createdAt: tool.createdAt,
+        };
         const dagProgress = dagProgressActivityForTool(tool);
         if (dagProgress) {
-            processItems.push({ kind: "dag-progress", progress: dagProgress });
+            processItems.push({ kind: "dag-progress", progress: dagProgress, ...order });
             continue;
         }
         const activity = semanticActivityForTool(tool);
         if (activity) {
-            processItems.push({ kind: "activity", activity });
+            processItems.push({ kind: "activity", activity, ...order });
         }
         else {
-            processItems.push({ kind: "tool", tool });
+            processItems.push({ kind: "tool", tool, ...order });
         }
     }
 }
@@ -185,12 +276,23 @@ function fillProcessDetails(group) {
         };
         for (const block of blocks) {
             if (block.type === "thinking") {
-                items.push({ kind: "thinking", thinking: block.thinking });
+                items.push({
+                    kind: "thinking",
+                    thinking: block.thinking,
+                    ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                    createdAt: anchorAt,
+                });
                 continue;
             }
             if (block.type === "text") {
-                if (block.text.trim())
-                    items.push({ kind: "text", text: block.text });
+                if (block.text.trim()) {
+                    items.push({
+                        kind: "text",
+                        text: block.text,
+                        ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                        createdAt: anchorAt,
+                    });
+                }
                 continue;
             }
             const tool = group.tools.find((entry) => entry.id === block.toolCallId);
@@ -213,7 +315,12 @@ function fillProcessDetails(group) {
             anchorAt = tool.createdAt;
         }
         if (includeProviderError && assistant.providerError) {
-            items.push({ kind: "provider-error", error: assistant.providerError });
+            items.push({
+                kind: "provider-error",
+                error: assistant.providerError,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: anchorAt,
+            });
         }
         flushItems();
         // Preserve the old-data fallback after this stage. Sequenced unmatched
@@ -401,6 +508,14 @@ export function buildTurnProcessGroups(input) {
             assigned.add(tool.id);
         }
     }
+    for (const node of input.conversationNodes ?? []) {
+        if (node.location.kind === "session")
+            continue;
+        const turnId = node.location.turnId;
+        if (!groups.some((group) => group.turnId === turnId)) {
+            startGroup(`turn-${turnId}`, turnId);
+        }
+    }
     for (const group of groups) {
         group.tools.sort((a, b) => {
             if (a.eventSeq !== undefined && b.eventSeq !== undefined) {
@@ -413,6 +528,12 @@ export function buildTurnProcessGroups(input) {
                 input.activeAssistantId !== null &&
                 group.assistants.some((a) => a.id === input.activeAssistantId);
         fillProcessDetails(group);
+        group.conversationItems = (input.conversationNodes ?? [])
+            .filter((node) => node.location.kind !== "session" && node.location.turnId === group.turnId)
+            .map((node) => ({ kind: node.kind, node }));
+        if (group.conversationItems.some((item) => item.kind === "turn-error")) {
+            group.processItems = group.processItems.filter((item) => item.kind !== "provider-error");
+        }
     }
     return groups;
 }