@pasko70/pibo 1.9.8 → 1.9.9

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

@@ -1,789 +0,0 @@
-import { eventTraceOrder, liveTraceOrder } from "./trace-order.js";
-import { compareTraceNodes, flattenTraceNodes } from "./trace-nodes.js";
-import { attachAsyncAgentRunNode, isRunStartToolNode } from "./trace-async-agent-runs.js";
-import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
-import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subagent-links.js";
-export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, hasPersistedTranscript, openTranscriptEventIds, sessionStatus) {
-    const payload = storedEvent.payload;
-    if (hasPersistedTranscript &&
-        isTranscriptEchoEvent(payload) &&
-        !shouldKeepTranscriptEchoEvent(payload, openTranscriptEventIds)) {
-        return;
-    }
-    if (hasPersistedTranscript && isStaleToolCallEchoEvent(payload, sessionStatus)) {
-        return;
-    }
-    if (payload.type === "assistant_delta") {
-        mergeAssistantDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
-        return;
-    }
-    if (payload.type === "thinking_delta") {
-        mergeThinkingDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
-        return;
-    }
-    if (payload.type === "assistant_message") {
-        const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
-        const existing = byId.get(node.id);
-        if (existing) {
-            mergeAssistantMessageEvent(existing, node);
-            return;
-        }
-        nodes.push(node);
-        byId.set(node.id, node);
-        return;
-    }
-    const node = traceNodeFromEvent(piboSessionId, payload, childByParent, linkedChildByToolCallId, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
-    if (!node)
-        return;
-    if (node.type === "agent.turn" && node.eventId) {
-        const existingTurn = [...byId.values()].find((candidate) => candidate.type === "agent.turn" && candidate.eventId === node.eventId);
-        if (existingTurn) {
-            existingTurn.status = node.status;
-            existingTurn.completedAt = node.completedAt ?? existingTurn.completedAt;
-            return;
-        }
-    }
-    if (node.type === "assistant.message") {
-        const existing = byId.get(node.id);
-        if (existing) {
-            mergeAssistantMessageEvent(existing, node);
-            return;
-        }
-    }
-    if (node.type === "execution.compaction") {
-        const existing = findLatestCompactionNode(nodes);
-        if (existing) {
-            mergeCompactionEvent(existing, node);
-            return;
-        }
-    }
-    if (node.type === "model.reasoning") {
-        const existing = byId.get(node.id);
-        if (existing) {
-            mergeReasoningEvent(existing, node);
-            return;
-        }
-    }
-    if (node.type === "agent.delegation" && !node.toolCallId && node.linkedPiboSessionId) {
-        const existing = findLegacySubagentLinkTarget([...byId.values()], node);
-        if (existing) {
-            mergeSubagentSessionLink(existing, node);
-            return;
-        }
-    }
-    if (node.toolCallId) {
-        const existing = [...byId.values()].find((candidate) => candidate.toolCallId === node.toolCallId &&
-            (candidate.type === "tool.call" || candidate.type === "agent.delegation"));
-        if (existing) {
-            if (isRunStartToolNode(existing) && node.type === "agent.delegation") {
-                attachAsyncAgentRunNode(existing, piboSessionId, storedEvent.createdAt, node);
-                return;
-            }
-            mergeToolEvent(existing, node);
-            attachAsyncAgentRunNode(existing, piboSessionId, storedEvent.createdAt);
-            return;
-        }
-    }
-    if (node.eventId && byId.has(node.id))
-        return;
-    attachExecutionCommandToOpenTurn(node, byId);
-    attachAsyncAgentRunNode(node, piboSessionId, storedEvent.createdAt);
-    nodes.push(node);
-    for (const indexed of flattenTraceNodes([node]))
-        byId.set(indexed.id, indexed);
-}
-function assistantMessageNodeFromEvent(piboSessionId, event, createdAt, eventSequence, streamId, streamFrameIndex) {
-    const eventId = typeof event.eventId === "string" ? event.eventId : undefined;
-    const assistantId = assistantEventNodeId(event);
-    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:${event.type}:${cryptoSafeId(event)}`;
-    return {
-        id,
-        piboSessionId,
-        eventId,
-        parentId: eventId ? messageTurnNodeId(eventId) : undefined,
-        type: "assistant.message",
-        title: "Agent Message",
-        status: "done",
-        startedAt: createdAt,
-        completedAt: createdAt,
-        summary: event.text,
-        output: event.text,
-        source: "event-log",
-        stableKey: assistantId ? `assistant:${assistantId}` : eventStableKey(event),
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
-        children: [],
-    };
-}
-function attachExecutionCommandToOpenTurn(node, byId) {
-    if (node.type !== "execution.command")
-        return;
-    if (node.parentId && byId.has(node.parentId))
-        return;
-    const turn = [...byId.values()]
-        .filter((candidate) => {
-        if (candidate.type !== "agent.turn")
-            return false;
-        if (!candidate.startedAt || !node.startedAt)
-            return false;
-        if (candidate.startedAt > node.startedAt)
-            return false;
-        const closedAt = turnClosedAt(candidate, byId);
-        return closedAt === undefined || node.startedAt <= closedAt;
-    })
-        .sort(compareTraceNodes)
-        .at(-1);
-    if (!turn)
-        return;
-    node.parentId = turn.id;
-}
-function turnClosedAt(turn, byId) {
-    if (turn.completedAt)
-        return turn.completedAt;
-    const error = [...byId.values()]
-        .filter((candidate) => candidate.type === "error" &&
-        candidate.eventId !== undefined &&
-        candidate.eventId === turn.eventId &&
-        candidate.startedAt !== undefined)
-        .sort(compareTraceNodes)
-        .at(0);
-    return error?.startedAt;
-}
-export function eventsCanAffectAsyncAgentRunStatus(events) {
-    return events.some((event) => {
-        const type = event.payload.type;
-        return type !== "assistant_delta" && type !== "thinking_delta";
-    });
-}
-export function contentDeltaPatchNodeId(event) {
-    if (event.type === "assistant_delta") {
-        if (event.text.length === 0)
-            return undefined;
-        const assistantId = assistantEventNodeId(event);
-        return assistantId ? assistantMessageNodeId(assistantId) : undefined;
-    }
-    if (event.type === "thinking_delta") {
-        if (event.text.length === 0)
-            return undefined;
-        const thinkingId = thinkingEventNodeId(event);
-        return thinkingId ? thinkingNodeId(thinkingId) : undefined;
-    }
-    return undefined;
-}
-export function reconcileTranscriptUserMessageTimestamps(nodes, events) {
-    const transcriptUsers = nodes.filter((node) => node.type === "user.message" && node.source === "transcript");
-    let userCursor = 0;
-    for (const storedEvent of events) {
-        const event = storedEvent.payload;
-        if (event.type !== "message_queued" || event.source !== "user")
-            continue;
-        const eventId = typeof event.eventId === "string" ? event.eventId : storedEvent.eventId;
-        const text = typeof event.text === "string" ? event.text : undefined;
-        const matchIndex = transcriptUsers.findIndex((node, index) => {
-            if (index < userCursor)
-                return false;
-            if (eventId && (node.entryId === eventId || node.stableKey === `entry:${eventId}`))
-                return true;
-            return Boolean(text && traceNodeText(node) === text);
-        });
-        if (matchIndex === -1)
-            continue;
-        transcriptUsers[matchIndex].startedAt = storedEvent.createdAt;
-        userCursor = matchIndex + 1;
-    }
-}
-export function isConfirmedUserMessageEcho(nodes, event) {
-    const payload = event.payload;
-    if (payload.type !== "message_queued" || payload.source !== "user")
-        return false;
-    const eventId = typeof payload.eventId === "string" ? payload.eventId : event.eventId;
-    const text = typeof payload.text === "string" ? payload.text : undefined;
-    return nodes.some((node) => {
-        if (node.type !== "user.message" || node.source !== "transcript")
-            return false;
-        if (eventId && (node.entryId === eventId || node.stableKey === `entry:${eventId}`))
-            return true;
-        return Boolean(text && traceNodeText(node) === text);
-    });
-}
-function traceNodeText(node) {
-    if (typeof node.output === "string")
-        return node.output;
-    if (typeof node.summary === "string")
-        return node.summary;
-    return undefined;
-}
-export function dedupeTraceEvents(events) {
-    const seen = new Set();
-    const deduped = [];
-    for (const event of events) {
-        const key = traceEventDedupeKey(event);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        deduped.push(event);
-    }
-    return deduped;
-}
-export function traceEventDedupeKey(event) {
-    if (event.streamId !== undefined) {
-        const payload = event.payload;
-        if (event.streamFrameIndex !== undefined) {
-            return `stream:${event.streamId}:${event.streamFrameIndex}:${payload.type}`;
-        }
-        return `stream:${event.streamId}:${payload.type}`;
-    }
-    if (event.eventSequence !== undefined)
-        return `sequence:${event.piboSessionId ?? ""}:${event.eventSequence}`;
-    return `id:${event.id}`;
-}
-export function latestTraceStreamId(events, initial) {
-    let latest = initial;
-    for (const event of events) {
-        if (event.streamId === undefined)
-            continue;
-        latest = latest === undefined ? event.streamId : Math.max(latest, event.streamId);
-    }
-    return latest;
-}
-// ── event → node helpers ─────────────────────────────────────────
-function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex) {
-    const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
-    const id = `event:${event.type}:${eventId ?? cryptoSafeId(event)}`;
-    const turnParentId = eventId ? messageTurnNodeId(eventId) : undefined;
-    const base = {
-        id,
-        piboSessionId,
-        eventId,
-        startedAt: createdAt,
-        source: "event-log",
-        stableKey: eventStableKey(event),
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
-        children: [],
-    };
-    switch (event.type) {
-        case "message_queued": {
-            const notification = parseRunNotificationText(event.text);
-            if (event.source === "service" && notification) {
-                return createRunNotificationNode({
-                    id,
-                    piboSessionId,
-                    eventId,
-                    startedAt: createdAt,
-                    source: "event-log",
-                    stableKey: eventId ? `run-notification:${eventId}` : id,
-                    orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
-                    notification,
-                });
-            }
-            return {
-                ...base,
-                type: "user.message",
-                title: "User Message",
-                status: "done",
-                summary: event.text,
-                output: event.text,
-            };
-        }
-        case "message_started":
-        case "message_finished":
-            if (event.source === "service")
-                return undefined;
-            return {
-                ...base,
-                id: eventId ? messageTurnNodeId(eventId) : id,
-                type: "agent.turn",
-                startedAt: event.type === "message_started" ? createdAt : undefined,
-                title: "Agent Turn",
-                status: event.type === "message_finished" || sessionStatus !== "running" ? "done" : "running",
-                completedAt: event.type === "message_finished" ? createdAt : undefined,
-                stableKey: eventId ? `turn:${eventId}` : base.stableKey,
-            };
-        case "thinking_finished": {
-            if (!hasVisibleText(event.text))
-                return undefined;
-            const thinkingId = thinkingEventNodeId(event);
-            return {
-                ...base,
-                id: thinkingId ? thinkingNodeId(thinkingId) : id,
-                parentId: turnParentId,
-                type: "model.reasoning",
-                title: "Thinking",
-                status: "done",
-                summary: event.text,
-                output: event.text,
-                stableKey: thinkingId ? `reasoning:${thinkingId}` : base.stableKey,
-            };
-        }
-        case "assistant_message": {
-            const assistantId = assistantEventNodeId(event);
-            return {
-                ...base,
-                id: assistantId ? assistantMessageNodeId(assistantId) : id,
-                parentId: turnParentId,
-                type: "assistant.message",
-                title: "Agent Message",
-                status: "done",
-                completedAt: createdAt,
-                summary: event.text,
-                output: event.text,
-                stableKey: assistantId ? `assistant:${assistantId}` : base.stableKey,
-            };
-        }
-        case "tool_call":
-        case "tool_execution_started":
-        case "tool_execution_updated":
-        case "tool_execution_finished": {
-            const subagentTool = isSubagentToolName(event.toolName);
-            const linkedPiboSessionId = linkedChildByToolCallId.get(event.toolCallId) ??
-                (subagentTool
-                    ? findLikelyTraceChildSession(piboSessionId, event.toolName, event, childByParent)
-                    : undefined);
-            return {
-                ...base,
-                id: `tool:${event.toolCallId}`,
-                parentId: turnParentId,
-                toolCallId: event.toolCallId,
-                type: subagentTool ? "agent.delegation" : "tool.call",
-                title: event.toolName,
-                status: event.type === "tool_execution_finished"
-                    ? event.isError
-                        ? "error"
-                        : "done"
-                    : sessionStatus === "running" &&
-                        (event.type === "tool_execution_started" || event.type === "tool_execution_updated")
-                        ? "running"
-                        : "done",
-                completedAt: event.type === "tool_execution_finished" ? createdAt : undefined,
-                input: "args" in event ? event.args : undefined,
-                output: event.type === "tool_execution_finished"
-                    ? event.result
-                    : event.type === "tool_execution_updated"
-                        ? event.partialResult
-                        : undefined,
-                error: event.type === "tool_execution_finished" && event.isError
-                    ? stringifyPreview(event.result)
-                    : undefined,
-                linkedPiboSessionId,
-                stableKey: `tool:${event.toolCallId}`,
-                children: [],
-            };
-        }
-        case "subagent_session":
-            return {
-                ...base,
-                id: event.toolCallId ? `tool:${event.toolCallId}` : id,
-                eventId,
-                toolCallId: event.toolCallId,
-                type: "agent.delegation",
-                title: event.toolName,
-                status: sessionStatus === "running" ? "running" : "done",
-                summary: event.subagentName,
-                input: { subagentName: event.subagentName, threadKey: event.threadKey },
-                linkedPiboSessionId: event.childPiboSessionId,
-                stableKey: event.toolCallId ? `tool:${event.toolCallId}` : `subagent:${event.childPiboSessionId}`,
-                children: [],
-            };
-        case "execution_result":
-            if (isInternalSessionOperation(event.action))
-                return undefined;
-            return {
-                ...base,
-                type: "execution.command",
-                title: event.action,
-                status: "done",
-                input: { action: event.action },
-                output: event.result,
-            };
-        case "compaction_start":
-            return {
-                ...base,
-                id: `event:compaction:${eventSequence ?? streamId ?? cryptoSafeId(event)}`,
-                type: "execution.compaction",
-                title: "compact",
-                status: "running",
-                summary: "Compacting",
-                input: { reason: event.reason },
-                stableKey: "compaction:active",
-            };
-        case "compaction_end":
-            return {
-                ...base,
-                id: `event:compaction:end:${eventSequence ?? streamId ?? cryptoSafeId(event)}`,
-                type: "execution.compaction",
-                title: "compact",
-                status: event.errorMessage ? "error" : "done",
-                completedAt: createdAt,
-                summary: event.aborted ? "Compaction skipped" : event.errorMessage ? "Compaction failed" : "Compacted",
-                input: { reason: event.reason },
-                output: event.result,
-                error: event.errorMessage,
-                stableKey: "compaction:active",
-            };
-        case "session_error":
-            return {
-                ...base,
-                type: "error",
-                title: "Session Error",
-                status: "error",
-                summary: event.errorDetails?.userMessage,
-                input: event.errorDetails,
-                error: event.error,
-                output: event.error,
-            };
-        default:
-            return undefined;
-    }
-}
-function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex) {
-    if (event.text.length === 0)
-        return;
-    const assistantId = assistantEventNodeId(event);
-    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:assistant_delta:${cryptoSafeId(event)}`;
-    const existing = byId.get(id);
-    if (existing) {
-        const text = `${typeof existing.output === "string" ? existing.output : ""}${event.text}`;
-        existing.status = sessionStatus === "running" ? "running" : "done";
-        existing.summary = text;
-        existing.output = text;
-        return;
-    }
-    const node = {
-        id,
-        parentId: event.eventId ? messageTurnNodeId(event.eventId) : undefined,
-        piboSessionId: event.piboSessionId,
-        eventId: event.eventId,
-        type: "assistant.message",
-        title: "Agent Message",
-        status: sessionStatus === "running" ? "running" : "done",
-        startedAt: createdAt,
-        summary: event.text,
-        output: event.text,
-        source: "event-log",
-        stableKey: assistantId ? `assistant:${assistantId}` : id,
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
-        children: [],
-    };
-    nodes.push(node);
-    byId.set(node.id, node);
-}
-function mergeAssistantMessageEvent(target, update) {
-    target.status = update.status;
-    target.summary = update.summary ?? target.summary;
-    target.output = update.output ?? target.output;
-    target.error = update.error ?? target.error;
-    target.completedAt = update.completedAt ?? target.completedAt;
-}
-function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex) {
-    if (event.text.length === 0)
-        return;
-    const thinkingId = thinkingEventNodeId(event);
-    const id = thinkingId ? thinkingNodeId(thinkingId) : `event:thinking_delta:${cryptoSafeId(event)}`;
-    const existing = byId.get(id);
-    if (existing) {
-        const text = `${typeof existing.output === "string" ? existing.output : ""}${event.text}`;
-        existing.status = sessionStatus === "running" ? "running" : "done";
-        existing.summary = text;
-        existing.output = text;
-        return;
-    }
-    const node = {
-        id,
-        parentId: event.eventId ? messageTurnNodeId(event.eventId) : undefined,
-        piboSessionId: event.piboSessionId,
-        eventId: event.eventId,
-        type: "model.reasoning",
-        title: "Thinking",
-        status: sessionStatus === "running" ? "running" : "done",
-        startedAt: createdAt,
-        summary: event.text,
-        output: event.text,
-        source: "event-log",
-        stableKey: thinkingId ? `reasoning:${thinkingId}` : id,
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
-        children: [],
-    };
-    nodes.push(node);
-    byId.set(node.id, node);
-}
-function mergeReasoningEvent(target, update) {
-    target.status = update.status;
-    target.summary = update.summary ?? target.summary;
-    target.output = update.output ?? target.output;
-    target.completedAt = update.completedAt ?? target.completedAt;
-}
-function isInternalSessionOperation(action) {
-    return action === "session.fork" || action === "session.clone" || action === "session.switch";
-}
-function isTranscriptEchoEvent(event) {
-    return (event.type === "message_queued" ||
-        event.type === "message_started" ||
-        event.type === "message_finished" ||
-        event.type === "assistant_delta" ||
-        event.type === "assistant_message" ||
-        event.type === "thinking_started" ||
-        event.type === "thinking_delta" ||
-        event.type === "thinking_finished");
-}
-function shouldKeepTranscriptEchoEvent(event, openTranscriptEventIds) {
-    const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
-    return Boolean(eventId && openTranscriptEventIds.has(eventId));
-}
-function isStaleToolCallEchoEvent(event, sessionStatus) {
-    return sessionStatus !== "running" && event.type === "tool_call";
-}
-export function messageTurnTimingsFromEvents(events) {
-    const timings = new Map();
-    const completedEventIds = [];
-    const completedEventIdSet = new Set();
-    const ignoredEventIds = new Set();
-    for (const storedEvent of events) {
-        const event = storedEvent.payload;
-        if (event.type !== "message_started" && event.type !== "message_finished")
-            continue;
-        const eventId = typeof event.eventId === "string" ? event.eventId : undefined;
-        if (!eventId)
-            continue;
-        if (event.type === "message_started" && event.source === "service") {
-            ignoredEventIds.add(eventId);
-            continue;
-        }
-        if (ignoredEventIds.has(eventId))
-            continue;
-        const timing = timings.get(eventId) ?? {};
-        if (event.type === "message_started") {
-            timing.userText ??= event.text;
-            timing.startedAt ??= storedEvent.createdAt;
-        }
-        else {
-            timing.completedAt = storedEvent.createdAt;
-            if (!completedEventIdSet.has(eventId)) {
-                completedEventIds.push(eventId);
-                completedEventIdSet.add(eventId);
-            }
-        }
-        timings.set(eventId, timing);
-    }
-    return completedEventIds.flatMap((eventId) => {
-        const timing = timings.get(eventId);
-        if (!timing?.completedAt)
-            return [];
-        const startedAtMs = parseTimestamp(timing.startedAt);
-        const completedAtMs = parseTimestamp(timing.completedAt);
-        return [{
-                eventId,
-                userText: timing.userText,
-                startedAt: timing.startedAt,
-                completedAt: timing.completedAt,
-                durationMs: startedAtMs === undefined || completedAtMs === undefined
-                    ? undefined
-                    : Math.max(0, completedAtMs - startedAtMs),
-            }];
-    });
-}
-export function findOpenTranscriptEventIds(events, sessionStatus) {
-    if (sessionStatus !== "running")
-        return new Set();
-    const open = new Set();
-    for (const storedEvent of events) {
-        const event = storedEvent.payload;
-        const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
-        if (!eventId)
-            continue;
-        if (isOpenTranscriptEvent(event)) {
-            open.add(eventId);
-        }
-        else if (event.type === "message_finished" || event.type === "session_error") {
-            open.delete(eventId);
-        }
-    }
-    return open;
-}
-function isOpenTranscriptEvent(event) {
-    return (event.type === "message_queued" ||
-        event.type === "message_started" ||
-        event.type === "assistant_delta" ||
-        event.type === "assistant_message" ||
-        event.type === "thinking_started" ||
-        event.type === "thinking_delta" ||
-        event.type === "thinking_finished");
-}
-function eventTraceNodeOrder(eventSequence, type, streamId, streamFrameIndex) {
-    if (eventSequence === undefined && (streamId !== undefined || streamFrameIndex !== undefined)) {
-        return liveTraceOrder(streamId, streamFrameIndex, eventNodeKind(type));
-    }
-    return eventTraceOrder(eventSequence, eventNodeKind(type));
-}
-function eventNodeKind(type) {
-    switch (type) {
-        case "message_queued":
-            return "user.message";
-        case "message_started":
-        case "message_finished":
-            return "agent.turn";
-        case "thinking_started":
-        case "thinking_delta":
-        case "thinking_finished":
-            return "model.reasoning";
-        case "tool_call":
-        case "tool_execution_started":
-        case "tool_execution_updated":
-        case "tool_execution_finished":
-        case "subagent_session":
-            return "tool.call";
-        case "assistant_delta":
-        case "assistant_message":
-            return "assistant.message";
-        case "execution_result":
-            return "execution.command";
-        case "compaction_start":
-        case "compaction_end":
-            return "execution.compaction";
-        case "session_error":
-            return "error";
-        default:
-            return "execution.command";
-    }
-}
-function eventStableKey(event) {
-    const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
-    if (event.type === "tool_call" ||
-        event.type === "tool_execution_started" ||
-        event.type === "tool_execution_updated" ||
-        event.type === "tool_execution_finished") {
-        return `tool:${event.toolCallId}`;
-    }
-    if (event.type === "subagent_session" && event.toolCallId)
-        return `tool:${event.toolCallId}`;
-    if (eventId && (event.type === "message_started" || event.type === "message_finished"))
-        return `turn:${eventId}`;
-    if (event.type === "thinking_started" ||
-        event.type === "thinking_delta" ||
-        event.type === "thinking_finished") {
-        const thinkingId = thinkingEventNodeId(event);
-        if (thinkingId)
-            return `reasoning:${thinkingId}`;
-    }
-    if (event.type === "assistant_delta" || event.type === "assistant_message") {
-        const assistantId = assistantEventNodeId(event);
-        if (assistantId)
-            return `assistant:${assistantId}`;
-    }
-    return `event:${event.type}:${eventId ?? cryptoSafeId(event)}`;
-}
-export function messageTurnNodeId(eventId) {
-    return `event:message:${eventId}`;
-}
-export function assistantMessageNodeId(eventId) {
-    return `event:assistant:${eventId}`;
-}
-function assistantEventNodeId(event) {
-    if (!event.eventId)
-        return undefined;
-    const partIndex = typeof event.assistantIndex === "number" ? event.assistantIndex : event.contentIndex;
-    return typeof partIndex === "number" ? `${event.eventId}:assistant:${partIndex}` : event.eventId;
-}
-export function thinkingNodeId(eventId) {
-    return `event:thinking:${eventId}`;
-}
-function thinkingEventNodeId(event) {
-    if (!event.eventId)
-        return undefined;
-    const partIndex = typeof event.thinkingIndex === "number" ? event.thinkingIndex : event.contentIndex;
-    return typeof partIndex === "number" ? `${event.eventId}:thinking:${partIndex}` : event.eventId;
-}
-function mergeToolEvent(target, update) {
-    target.status = update.status;
-    target.summary = update.summary ?? target.summary;
-    target.input = mergeDelegationInput(target, update);
-    target.output = update.output ?? target.output;
-    target.error = update.error ?? target.error;
-    target.completedAt = update.completedAt ?? target.completedAt;
-    target.linkedPiboSessionId = update.linkedPiboSessionId ?? target.linkedPiboSessionId;
-}
-function mergeSubagentSessionLink(target, update) {
-    target.summary = update.summary ?? target.summary;
-    target.input = mergeDelegationInput(target, update);
-    target.linkedPiboSessionId = update.linkedPiboSessionId ?? target.linkedPiboSessionId;
-}
-function findLegacySubagentLinkTarget(nodes, update) {
-    const delegations = [...nodes].reverse().filter((candidate) => candidate.type === "agent.delegation");
-    const agentName = delegationAgentName(update);
-    const candidates = delegations.filter((candidate) => !candidate.linkedPiboSessionId && delegationAgentName(candidate) === agentName);
-    const threadKey = delegationThreadKey(update.input);
-    const matchingCandidate = threadKey
-        ? candidates.find((candidate) => delegationThreadKey(candidate.input) === threadKey)
-        : candidates.length === 1 ? candidates[0] : undefined;
-    if (matchingCandidate)
-        return matchingCandidate;
-    return delegations.find((candidate) => candidate.linkedPiboSessionId === update.linkedPiboSessionId);
-}
-function delegationAgentName(node) {
-    const input = isObjectRecord(node.input) ? node.input : undefined;
-    const value = typeof input?.subagentName === "string" ? input.subagentName : node.summary ?? node.title;
-    return typeof value === "string" ? value.replace(/^pibo_subagent_/, "").trim().toLowerCase() || undefined : undefined;
-}
-function delegationThreadKey(value) {
-    if (!isObjectRecord(value) || typeof value.threadKey !== "string")
-        return undefined;
-    return value.threadKey.trim() || undefined;
-}
-function mergeDelegationInput(target, update) {
-    if (target.type !== "agent.delegation" || !isObjectRecord(target.input) || !isObjectRecord(update.input)) {
-        return update.input ?? target.input;
-    }
-    return Object.fromEntries(Object.entries({ ...target.input, ...update.input }).filter(([, value]) => value !== undefined));
-}
-function isObjectRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function findLatestCompactionNode(nodes) {
-    return flattenTraceNodes([...nodes]).reverse().find((node) => node.type === "execution.compaction" && node.status === "running");
-}
-function mergeCompactionEvent(target, update) {
-    target.status = update.status;
-    target.summary = update.summary ?? target.summary;
-    target.input = update.input ?? target.input;
-    target.output = update.output ?? target.output;
-    target.error = update.error ?? target.error;
-    target.completedAt = update.completedAt ?? target.completedAt;
-}
-function hasVisibleText(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function stringifyPreview(value) {
-    if (typeof value === "string")
-        return value;
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-function parseTimestamp(value) {
-    if (!value)
-        return undefined;
-    const timestamp = new Date(value).getTime();
-    return Number.isFinite(timestamp) ? timestamp : undefined;
-}
-function cryptoSafeId(value) {
-    return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value))).slice(0, 48);
-}
-function base64UrlEncode(bytes) {
-    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-    let output = "";
-    let index = 0;
-    for (; index + 2 < bytes.length; index += 3) {
-        const value = (bytes[index] << 16) | (bytes[index + 1] << 8) | bytes[index + 2];
-        output += alphabet[(value >> 18) & 63] + alphabet[(value >> 12) & 63] + alphabet[(value >> 6) & 63] + alphabet[value & 63];
-    }
-    if (index < bytes.length) {
-        const first = bytes[index];
-        const second = index + 1 < bytes.length ? bytes[index + 1] : 0;
-        const value = (first << 16) | (second << 8);
-        output += alphabet[(value >> 18) & 63] + alphabet[(value >> 12) & 63];
-        if (index + 1 < bytes.length)
-            output += alphabet[(value >> 6) & 63];
-    }
-    return output;
-}