@pasko70/pibo 3.4.4 → 3.5.1

package/dist/session-ui/terminalRows.js

@@ -16,14 +16,15 @@ export function buildCompactTerminalRows(traceView, options) {
     if (!traceView)
         return [];
     const turnById = mapTurnNodes(traceView.nodes);
+    const showToolDebugMetrics = Boolean(options.debugMode && (options.debugFeatures?.toolMetrics ?? true));
     const flatNodes = flattenTraceNodes(traceView.nodes)
         .sort((left, right) => compareTraceNodes(left.node, right.node))
         .filter((item) => item.node.type !== "agent.turn" && (options.showThinking || item.node.type !== "model.reasoning"));
     const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
     applyCompletedTurnTiming(candidates, turnById);
     const reconciled = reconcileConceptualRowCandidates(candidates);
-    const rows = !options.debugMode && (options.toolDisplayMode ?? "default") === "default"
-        ? groupRelatedToolCandidates(reconciled).map((candidate) => candidate.row)
+    const rows = (options.toolDisplayMode ?? "default") === "default"
+        ? groupRelatedToolCandidates(reconciled, showToolDebugMetrics).map((candidate) => candidate.row)
         : reconciled.map((candidate) => candidate.row);
     return applyToolDisplayMode(rows, options.toolDisplayMode ?? "default");
 }
@@ -159,18 +160,34 @@ function createRowCandidate(node, turnId) {
             };
             break;
     }
+    const isToolCall = node.type === "tool.call" || node.type === "tool.result" || (node.type === "agent.delegation" && Boolean(node.toolCallId));
+    const reference = isToolCall ? toolCallReference(node) : undefined;
     return {
         ...candidate,
         row: {
             ...candidate.row,
             id: compactTerminalRowIdentity(node),
             intent: node.intent,
-            isToolCall: node.type === "tool.call" || node.type === "tool.result" || (node.type === "agent.delegation" && Boolean(node.toolCallId)),
+            isToolCall,
+            toolCallReference: reference,
+            expandable: reference || Object.values(node.payloadRefs ?? {}).some(Boolean) ? true : candidate.row.expandable,
             toolMetrics: node.toolMetrics,
+            modelInferences: node.modelInferences,
             ...debugFields(node),
         },
     };
 }
+function toolCallReference(node) {
+    if (!node.toolCallId)
+        return undefined;
+    const parsed = parseTraceToolNodeIdentity(node.id);
+    return {
+        traceNodeId: node.id,
+        toolCallId: node.toolCallId,
+        eventId: node.eventId ?? parsed?.qualifier?.eventId,
+        invocationOrdinal: node.toolInvocationOrdinal ?? parsed?.qualifier?.invocationOrdinal,
+    };
+}
 export function compactTerminalRowIdentity(node) {
     if (node.type === "tool.call" || node.type === "tool.result" || node.type === "agent.delegation") {
         if (node.toolCallId) {
@@ -226,6 +243,7 @@ function reconcileConceptualRowCandidates(candidates) {
                 output: candidate.row.output ?? existing.row.output,
                 error: candidate.row.error ?? existing.row.error,
                 payloadRefs: { ...existing.row.payloadRefs, ...candidate.row.payloadRefs },
+                modelInferences: mergeModelInferences(existing.row.modelInferences, candidate.row.modelInferences),
                 imagePreviews: mergeImagePreviews(existing.row.imagePreviews, candidate.row.imagePreviews),
             },
         };
@@ -310,6 +328,16 @@ function assistantPartIndex(rowId) {
     const index = Number(match[1]);
     return Number.isSafeInteger(index) ? index : undefined;
 }
+function mergeModelInferences(existing, candidate) {
+    if (!existing?.length)
+        return candidate;
+    if (!candidate?.length)
+        return existing;
+    const merged = new Map(existing.map((record) => [record.id, record]));
+    for (const record of candidate)
+        merged.set(record.id, record);
+    return [...merged.values()];
+}
 function mergeImagePreviews(existing, candidate) {
     if (!existing?.length)
         return candidate?.slice(0, MAX_COMPACT_TERMINAL_IMAGE_PREVIEWS);
@@ -329,6 +357,9 @@ function applyCompletedTurnTiming(candidates, turnById) {
             continue;
         const turnCandidates = candidates.filter((candidate) => candidate.turnId === turn.id);
         const finalCandidate = turnCandidates.at(-1);
+        if (finalCandidate && turn.modelInferences?.length) {
+            finalCandidate.row.modelInferences = mergeModelInferences(finalCandidate.row.modelInferences, turn.modelInferences);
+        }
         if (finalCandidate?.row.kind !== "message.assistant" || finalCandidate.row.status === "running")
             continue;
         finalCandidate.row.startedAt = turn.startedAt;
@@ -362,7 +393,8 @@ function createUserMessageRow(node) {
         lines: [{ prefix: "prompt", tokens: [token(text)] }],
         sourceNodeIds: [node.id],
         forkEntryId: node.entryId,
-        pendingMessageDelivery: pendingUserMessageDelivery(node),
+        pendingMessageDelivery: pendingUserMessageDelivery(node) ?? (node.status === "running" && node.messageDeliveryState ? "queue" : undefined),
+        messageDeliveryState: node.messageDeliveryState,
         startedAt: node.startedAt,
         output: text,
         payloadRefs: node.payloadRefs,
@@ -657,9 +689,16 @@ function createCompactionRow(node) {
         input: node.input,
         output: node.output,
         error: node.error,
-        expandable: node.input !== undefined || node.output !== undefined || Boolean(node.error),
+        compactionStats: node.compactionStats,
+        compactionMarkdown: compactionMarkdown(node.output),
+        expandable: node.status === "error" && (node.input !== undefined || node.output !== undefined || Boolean(node.error)),
     };
 }
+function compactionMarkdown(value) {
+    if (!isRecord(value))
+        return undefined;
+    return stringValue(value.summary);
+}
 function createExecutionCommandRow(node) {
     if (node.title === "status") {
         return createStatusToolRow(node);
@@ -903,12 +942,12 @@ function isThinkingOutput(value) {
 function isThinkingLevelSetOutput(value) {
     return isRecord(value) && value.action === "set_thinking_level";
 }
-function groupRelatedToolCandidates(candidates) {
+function groupRelatedToolCandidates(candidates, imagesOnly = false) {
     const grouped = [];
     for (let index = 0; index < candidates.length; index += 1) {
         const candidate = candidates[index];
         const groupKind = candidateGroupKind(candidate);
-        if (!groupKind) {
+        if (!groupKind || (imagesOnly && groupKind !== "images")) {
             grouped.push(candidate);
             continue;
         }
@@ -966,13 +1005,14 @@ function createExploringGroup(candidates) {
                 }] : []),
         ],
         sourceNodeIds: candidates.flatMap((candidate) => candidate.row.sourceNodeIds),
+        modelInferences: candidates.reduce((records, candidate) => mergeModelInferences(records, candidate.row.modelInferences), undefined),
         eventId: firstRow?.eventId,
         runId: firstRow?.runId,
         orderSource: firstRow?.orderSource,
         orderStreamId: firstRow?.orderStreamId,
         orderStreamFrameIndex: firstRow?.orderStreamFrameIndex,
         detailItems,
-        expandable: detailItems.some((item) => item.input !== undefined || item.output !== undefined || Boolean(item.error)),
+        expandable: detailItems.some((item) => item.toolCallReference || item.input !== undefined || item.output !== undefined || Boolean(item.error)),
         previewOmission: omittedDetailCount > 0 ? {
             source: "details",
             visibleLineCount: visibleDetailItems.length,
@@ -988,21 +1028,20 @@ function createImageGroup(candidates) {
     const omittedDetailCount = Math.max(0, detailItems.length - visibleDetailItems.length);
     const firstRow = candidates[0]?.row;
     const firstId = firstRow?.id ?? "images";
-    const lastId = candidates[candidates.length - 1]?.row.id ?? firstId;
     const status = candidates.some((candidate) => candidate.row.status === "running")
         ? "running"
         : candidates.some((candidate) => candidate.row.status === "error")
             ? "error"
             : "done";
     return {
-        id: `group:images:${firstId}:${lastId}`,
+        id: firstId,
         kind: "tool.group.images",
         status,
         errorKind: status === "error" ? "tool" : undefined,
         lines: [
             {
                 prefix: "bullet",
-                tokens: [token(status === "running" ? "Viewing images" : status === "error" ? "Image reads failed" : "Viewed images", toneForStatus(status), "semibold")],
+                tokens: [token(status === "running" ? `Viewing ${detailItems.length} images` : status === "error" ? `${detailItems.length} image reads · error` : `${detailItems.length} ${detailItems.length === 1 ? "Image Viewed" : "Images Viewed"}`, toneForStatus(status), "semibold")],
             },
             ...visibleDetailItems.map((item, index) => ({
                 prefix: index === 0 ? "detail" : "continuation",
@@ -1014,14 +1053,15 @@ function createImageGroup(candidates) {
                 }] : []),
         ],
         sourceNodeIds: candidates.flatMap((candidate) => candidate.row.sourceNodeIds),
+        modelInferences: candidates.reduce((records, candidate) => mergeModelInferences(records, candidate.row.modelInferences), undefined),
         eventId: firstRow?.eventId,
         runId: firstRow?.runId,
         orderSource: firstRow?.orderSource,
         orderStreamId: firstRow?.orderStreamId,
         orderStreamFrameIndex: firstRow?.orderStreamFrameIndex,
         detailItems,
-        expandable: detailItems.some((item) => item.input !== undefined || item.output !== undefined || Boolean(item.error)),
-        imagePreviews: detailItems.flatMap((item) => item.imagePreviews ?? []).slice(0, MAX_COMPACT_TERMINAL_IMAGE_PREVIEWS),
+        expandable: detailItems.some((item) => item.toolCallReference || item.input !== undefined || item.output !== undefined || Boolean(item.error)),
+        imagePreviews: detailItems.flatMap((item) => item.imagePreviews ?? []),
         previewOmission: omittedDetailCount > 0 ? {
             source: "details",
             visibleLineCount: visibleDetailItems.length,
@@ -1043,6 +1083,7 @@ function detailItemsForGroup(candidates, kind) {
             error: candidate.row.error,
             payloadRefs: candidate.row.payloadRefs,
             linkedPiboSessionId: candidate.row.linkedPiboSessionId,
+            toolCallReference: candidate.row.toolCallReference,
             previewOmission: candidate.row.previewOmission,
             imagePreviews: candidate.row.imagePreviews,
         };

package/dist/sessions/pibo-data-store.js

@@ -49,6 +49,7 @@ export class PiboDataSessionStore {
         const row = this.db.prepare(`${SESSION_SELECT} WHERE s.id = ? AND s.deleted_at IS NULL`).get(id);
         return row ? sessionFromRow(row) : undefined;
     }
+    getStructureRevision() { return this.db.prepare("SELECT revision FROM chat_navigation_clock WHERE id=1").get().revision; }
     list() {
         return this.db.prepare(`${SESSION_SELECT} WHERE s.deleted_at IS NULL ORDER BY s.updated_at DESC`).all().map(sessionFromRow);
     }
@@ -226,21 +227,21 @@ export class PiboDataSessionStore {
                 if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0)
                     continue;
                 maximum = Math.max(maximum, index);
-                persistedParts.push({ index, attributes });
+                persistedParts.push({ index, type: row.type, attributes });
             }
-            // An unfinished durable part may still belong to another process. Only a
-            // completed turn provides enough evidence to reattach an exact replay.
-            if (turnCompleted) {
-                const matchesReplay = ({ attributes }) => attributes.outputPartFingerprint === input.fingerprint
-                    || attributes.identityFingerprint === input.identityFingerprint;
-                const replay = (input.suppliedIndex === undefined
-                    ? undefined
-                    : persistedParts.find((part) => part.index === input.suppliedIndex && matchesReplay(part)))
-                    ?? persistedParts.find(matchesReplay);
-                if (replay) {
-                    this.observeOutputPartIndex(input, replay.index);
-                    return replay.index;
-                }
+            // A completed turn or an exact terminal-part fingerprint is durable
+            // evidence for replay. Nonterminal parts remain unattached while the turn
+            // is open because another producer may still own them.
+            const matchesReplay = ({ type, attributes }) => (turnCompleted || outputPartEventIsTerminal(type))
+                && (attributes.outputPartFingerprint === input.fingerprint
+                    || attributes.identityFingerprint === input.identityFingerprint);
+            const replay = (input.suppliedIndex === undefined
+                ? undefined
+                : persistedParts.find((part) => part.index === input.suppliedIndex && matchesReplay(part)))
+                ?? (turnCompleted ? persistedParts.find(matchesReplay) : undefined);
+            if (replay) {
+                this.observeOutputPartIndex(input, replay.index);
+                return replay.index;
             }
             const minimum = Math.max(input.proposedIndex, maximum + 1);
             const row = this.db.prepare(`
@@ -537,6 +538,7 @@ export class PiboDataSessionStore {
                         actorId: session.id,
                         event,
                         createdAt: at,
+                        persistenceProvenance: { producer: "runtime-recovery", projection: "product-history", phase: "startup-recovery" },
                     });
                 results.push({
                     turnId: recovered.turn.turnId,
@@ -725,6 +727,9 @@ function outputPartEventTypes(kind) {
         case "compaction": return ["compaction_start", "compaction_end"];
     }
 }
+function outputPartEventIsTerminal(type) {
+    return type === "assistant_message" || type === "thinking_finished" || type === "assistant_usage" || type === "compaction_end";
+}
 function parseJsonObject(json) {
     if (!json)
         return {};

package/dist/shared/debug-features.js

@@ -0,0 +1,4 @@
+export const DEFAULT_DEBUG_FEATURE_SETTINGS = {
+    toolMetrics: true,
+    modelInferenceMetrics: true,
+};

package/dist/shared/model-inference-metrics.js

@@ -0,0 +1,23 @@
+export function modelInferenceInputTokens(metrics) {
+    const total = tokenCount(metrics?.totalTokens);
+    const output = tokenCount(metrics?.outputTokens);
+    if (total !== undefined && output !== undefined)
+        return Math.max(0, total - output);
+    return tokenCount(metrics?.inputTokens);
+}
+export function modelInferenceCachedInputTokens(metrics) {
+    const cacheRead = tokenCount(metrics?.cacheReadTokens);
+    const cacheWrite = tokenCount(metrics?.cacheWriteTokens);
+    if (cacheRead === undefined && cacheWrite === undefined)
+        return undefined;
+    return (cacheRead ?? 0) + (cacheWrite ?? 0);
+}
+export function modelInferenceUncachedInputTokens(metrics) {
+    const input = modelInferenceInputTokens(metrics);
+    if (input === undefined)
+        return undefined;
+    return Math.max(0, input - (modelInferenceCachedInputTokens(metrics) ?? 0));
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}

package/dist/shared/trace-event-projection.js

@@ -6,6 +6,10 @@ import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subage
 import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
+    if (payload.type === "assistant_usage") {
+        attachModelInferenceToLatestOutput(nodes, byId, payload, storedEvent);
+        return;
+    }
     if (payload.type === "message_started" && payload.source === "user" && payload.eventId) {
         const persistedUser = flattenTraceNodes([...nodes]).find((node) => node.type === "user.message"
             && isPersistedHistorySource(node.source)
@@ -42,6 +46,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     }
     if (payload.type === "assistant_message") {
         const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
+        applyStoredPayloadRef(node, payload, storedEvent.storedPayloadRef);
         const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
@@ -153,8 +158,12 @@ function applyRenderSequenceToHistoryNode(byId, storedEvent, event) {
             && typeof event.toolCallId === "string"
             && node.toolCallId === event.toolCallId
             && (!eventId || !node.eventId || node.eventId === eventId)));
-    if (target)
-        applyRenderSequence(target, storedEvent, event);
+    if (!target)
+        return;
+    applyRenderSequence(target, storedEvent, event);
+    if (event.type === "tool_execution_finished" && event.toolMetrics) {
+        target.toolMetrics = event.toolMetrics;
+    }
 }
 function applyRenderSequence(node, storedEvent, event) {
     const renderSequence = storedEvent.renderSequence ?? event.renderSequence;
@@ -171,6 +180,9 @@ function applyRenderSequence(node, storedEvent, event) {
 function applyStoredPayloadRef(node, event, storedPayloadRef) {
     if (!storedPayloadRef)
         return;
+    if (event.type === "assistant_message" || event.type === "thinking_finished") {
+        node.payloadRefs = { ...node.payloadRefs, [storedPayloadRef.payloadKind ?? "output"]: storedPayloadRef };
+    }
     if (event.type === "tool_call" || event.type === "tool_execution_started") {
         node.payloadRefs = { ...node.payloadRefs, input: storedPayloadRef };
     }
@@ -524,6 +536,57 @@ export function latestTraceStreamId(events, initial) {
     }
     return latest;
 }
+function attachModelInferenceToLatestOutput(nodes, byId, event, storedEvent) {
+    const eventId = event.eventId;
+    const candidates = flattenTraceNodes(nodes)
+        .filter((node) => node.eventId === eventId && (event.inferenceTarget || traceNodeStartedBeforeInference(node, storedEvent)) && (node.type === "assistant.message"
+        || node.type === "model.reasoning"
+        || node.type === "tool.call"
+        || node.type === "agent.delegation"))
+        .sort(compareTraceNodes);
+    const anchor = event.inferenceTarget;
+    const turnNode = eventId ? byId.get(messageTurnNodeId(eventId)) : undefined;
+    const target = anchor
+        ? (anchor.type === "tool"
+            ? candidates.find((node) => node.toolCallId === anchor.toolCallId)
+            : anchor.type === "assistant"
+                ? candidates.find((node) => node.stableKey === `assistant:${eventId}:assistant:${anchor.assistantIndex}`)
+                : turnNode) ?? turnNode
+        : candidates.at(-1) ?? turnNode;
+    if (!target)
+        return;
+    const id = event.inferenceId
+        ? `${eventId ?? storedEvent.piboSessionId}:inference:${event.inferenceId}`
+        : eventId ? `${eventId}:usage:${event.usageIndex ?? 0}` : storedEvent.id;
+    const record = {
+        id,
+        completedAt: storedEvent.createdAt,
+        metrics: {
+            ...(event.inputTokens === undefined ? {} : { inputTokens: event.inputTokens }),
+            ...(event.outputTokens === undefined ? {} : { outputTokens: event.outputTokens }),
+            ...(event.cacheReadTokens === undefined ? {} : { cacheReadTokens: event.cacheReadTokens }),
+            ...(event.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: event.cacheWriteTokens }),
+            ...(event.reasoningTokens === undefined ? {} : { reasoningTokens: event.reasoningTokens }),
+            totalTokens: event.totalTokens,
+            ...(event.costUsd === undefined ? {} : { costUsd: event.costUsd }),
+        },
+    };
+    target.modelInferences = [...(target.modelInferences ?? []).filter((item) => item.id !== id), record];
+}
+function traceNodeStartedBeforeInference(node, storedEvent) {
+    const inferenceRenderSequence = storedEvent.renderSequence;
+    const nodeRenderSequence = node.orderKey?.renderSequence;
+    if (inferenceRenderSequence !== undefined && nodeRenderSequence !== undefined) {
+        return nodeRenderSequence <= inferenceRenderSequence;
+    }
+    const inferenceSequence = storedEvent.eventSequence ?? storedEvent.streamId;
+    const nodeSequence = node.orderKey?.eventSequence ?? node.orderKey?.streamId;
+    if (inferenceSequence !== undefined && nodeSequence !== undefined)
+        return nodeSequence <= inferenceSequence;
+    const inferenceTime = Date.parse(storedEvent.createdAt);
+    const nodeTime = Date.parse(node.startedAt ?? node.completedAt ?? "");
+    return !Number.isFinite(inferenceTime) || !Number.isFinite(nodeTime) || nodeTime <= inferenceTime;
+}
 // ── event → node helpers ─────────────────────────────────────────
 function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
@@ -562,6 +625,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 type: "user.message",
                 title: "User Message",
                 status: isOptimisticUserMessageEvent(event) ? "running" : "done",
+                messageDeliveryState: isOptimisticUserMessageEvent(event) ? "sending" : undefined,
                 summary: event.text,
                 output: event.text,
             };
@@ -711,6 +775,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 input: { reason: event.reason },
                 output: event.result,
                 error: event.errorMessage,
+                compactionStats: event.compactionStats,
                 stableKey: `compaction:${eventInstanceKey}`,
             };
         }
@@ -768,6 +833,7 @@ function findMatchingContentNode(byId, update) {
     return [...byId.values()].find((candidate) => candidate.type === update.type && candidate.stableKey === update.stableKey);
 }
 function mergeAssistantMessageEvent(target, update) {
+    target.payloadRefs = { ...target.payloadRefs, ...update.payloadRefs };
     target.status = update.status;
     target.summary = update.summary ?? target.summary;
     target.output = update.output ?? target.output;
@@ -1163,6 +1229,7 @@ function mergeCompactionEvent(target, update) {
     target.input = update.input ?? target.input;
     target.output = update.output ?? target.output;
     target.error = update.error ?? target.error;
+    target.compactionStats = update.compactionStats ?? target.compactionStats;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
 function hasVisibleText(value) {

package/dist/shared/trace-history.js

@@ -710,6 +710,7 @@ function createUserMessageNode(piboSessionId, entry, entryIndex, timing, fallbac
         startedAt: entry.createdAt,
         summary: text,
         output: text,
+        payloadRefs: historyContentPayloadRef(entry),
         error: entry.error,
         source,
         stableKey: eventIdentity ?? historyEntryStableKey(entry),
@@ -902,6 +903,7 @@ function createAssistantMessageNode(input) {
         completedAt: input.completedAt,
         summary: input.text,
         output: input.text,
+        payloadRefs: historyContentPayloadRef(input.entry),
         error: input.error,
         source,
         stableKey: eventIdentity ? `assistant:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:response:${input.contentPartIndex}`,
@@ -909,6 +911,13 @@ function createAssistantMessageNode(input) {
         children: input.children ?? [],
     };
 }
+/** Preserve a stored full body when the bounded history page contains its preview. */
+function historyContentPayloadRef(entry) {
+    const ref = entry.source === "product" ? entry.metadata?.tracePayloadRef : undefined;
+    if (!ref || typeof ref !== "object" || Array.isArray(ref) || typeof ref.ref !== "string" || typeof ref.byteLength !== "number" || typeof ref.preview !== "string")
+        return undefined;
+    return { output: ref };
+}
 function historyMessageParts(entry) {
     return typeof entry.content === "string" ? [{ type: "text", text: entry.content }] : [...entry.content];
 }

package/dist/shared/trace-live-reducer.js

@@ -165,6 +165,7 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
         streamId: typeof streamEvent.streamId === "number" ? streamEvent.streamId : undefined,
         streamFrameIndex,
         traceSource: "live",
+        storedPayloadRef: streamEvent.storedPayloadRef,
         eventId: typeof positionedPayload.eventId === "string" ? positionedPayload.eventId : undefined,
         type,
         createdAt: streamEventCreatedAt(streamEvent) ?? now(),

package/dist/shared/trace-patch-nodes.js

@@ -64,6 +64,7 @@ function traceNodeShallowEqual(left, right) {
         left.toolMetrics?.inputTokens === right.toolMetrics?.inputTokens &&
         left.toolMetrics?.outputTokens === right.toolMetrics?.outputTokens &&
         left.toolMetrics?.tokenBasis === right.toolMetrics?.tokenBasis &&
+        modelInferenceRecordsEqual(left.modelInferences, right.modelInferences) &&
         left.summary === right.summary &&
         left.input === right.input &&
         left.output === right.output &&
@@ -73,6 +74,24 @@ function traceNodeShallowEqual(left, right) {
         left.stableKey === right.stableKey &&
         traceOrderKeyEqual(left.orderKey, right.orderKey));
 }
+function modelInferenceRecordsEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right || left.length !== right.length)
+        return false;
+    return left.every((item, index) => {
+        const other = right[index];
+        return item.id === other?.id
+            && item.completedAt === other.completedAt
+            && item.metrics.inputTokens === other.metrics.inputTokens
+            && item.metrics.outputTokens === other.metrics.outputTokens
+            && item.metrics.cacheReadTokens === other.metrics.cacheReadTokens
+            && item.metrics.cacheWriteTokens === other.metrics.cacheWriteTokens
+            && item.metrics.reasoningTokens === other.metrics.reasoningTokens
+            && item.metrics.totalTokens === other.metrics.totalTokens
+            && item.metrics.costUsd === other.metrics.costUsd;
+    });
+}
 function traceOrderKeyEqual(left, right) {
     if (left === right)
         return true;