@pasko70/pibo 1.1.0 → 1.2.0

package/dist/shared/trace-async-agent-runs.js

@@ -0,0 +1,127 @@
+import { childTraceOrder } from "./trace-order.js";
+import { flattenTraceNodes } from "./trace-nodes.js";
+import { isSubagentToolName, subagentNameFromToolName } from "./trace-subagent-links.js";
+export function attachAsyncAgentRunNode(parent, piboSessionId, startedAt, delegation) {
+    const node = createAsyncAgentRunNode(parent, piboSessionId, startedAt, delegation);
+    if (!node)
+        return;
+    const existing = parent.children.find((child) => child.id === node.id);
+    if (existing) {
+        mergeAsyncAgentRunNode(existing, node);
+        existing.runId = node.runId ?? existing.runId;
+        return;
+    }
+    parent.children.push(node);
+}
+export function reconcileAsyncAgentRunStatuses(nodes) {
+    const runSnapshots = new Map();
+    for (const node of flattenTraceNodes(nodes)) {
+        const snapshot = extractRunSnapshot(node.output);
+        if (!snapshot)
+            continue;
+        const runId = stringValue(snapshot.runId);
+        if (!runId)
+            continue;
+        runSnapshots.set(runId, {
+            snapshot,
+            completedAt: stringValue(snapshot.completedAt) ?? stringValue(snapshot.updatedAt) ?? node.completedAt,
+        });
+    }
+    for (const node of flattenTraceNodes(nodes)) {
+        if (node.type !== "agent.async" || !node.runId)
+            continue;
+        const latest = runSnapshots.get(node.runId);
+        if (!latest)
+            continue;
+        const status = stringValue(latest.snapshot.status);
+        if (status !== "completed" && status !== "cancelled" && status !== "failed")
+            continue;
+        node.status = status === "failed" ? "error" : "done";
+        node.completedAt = latest.completedAt ?? node.completedAt;
+        node.output = latest.snapshot;
+        if (status === "failed")
+            node.error = stringValue(latest.snapshot.summary) ?? node.error;
+    }
+}
+function createAsyncAgentRunNode(parent, piboSessionId, startedAt, delegation) {
+    if (!isRunStartToolNode(parent))
+        return undefined;
+    const run = extractRunSnapshot(parent.output);
+    const input = isRecord(parent.input) ? parent.input : {};
+    const toolName = stringValue(run?.toolName) ?? stringValue(input.toolName) ?? delegation?.title;
+    if (!toolName || !isSubagentToolName(toolName))
+        return undefined;
+    const subagentName = stringValue(delegation?.summary) ?? subagentNameFromToolName(toolName);
+    const runId = stringValue(run?.runId);
+    const runStatus = stringValue(run?.status);
+    const delegatedArguments = input.arguments;
+    const completionPolicy = stringValue(run?.completionPolicy) ?? stringValue(input.completionPolicy);
+    return {
+        id: `${parent.id}:async-agent`,
+        parentId: parent.id,
+        piboSessionId,
+        eventId: parent.eventId,
+        toolCallId: parent.toolCallId,
+        runId,
+        type: "agent.async",
+        title: subagentName,
+        status: asyncAgentStatus(parent, runStatus),
+        startedAt: delegation?.startedAt ?? startedAt ?? parent.startedAt,
+        completedAt: runStatus === "completed" || runStatus === "cancelled" ? parent.completedAt : undefined,
+        summary: `Started by ${parent.title}`,
+        input: {
+            startedBy: parent.title,
+            startToolCallId: parent.toolCallId,
+            toolName,
+            subagentName,
+            runId,
+            completionPolicy,
+            arguments: delegatedArguments,
+            threadKey: isRecord(delegation?.input) ? delegation.input.threadKey : undefined,
+        },
+        output: run,
+        error: parent.error,
+        linkedPiboSessionId: delegation?.linkedPiboSessionId ?? parent.linkedPiboSessionId,
+        source: parent.source,
+        stableKey: runId ? `async-agent:${runId}` : `${parent.stableKey ?? parent.id}:async-agent`,
+        orderKey: childTraceOrder(parent.orderKey, "agent.async"),
+        children: [],
+    };
+}
+export function isRunStartToolNode(node) {
+    return node.type === "tool.call" && node.title === "pibo_run_start";
+}
+function mergeAsyncAgentRunNode(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;
+    target.linkedPiboSessionId = update.linkedPiboSessionId ?? target.linkedPiboSessionId;
+}
+function extractRunSnapshot(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (isRunSnapshot(value))
+        return value;
+    if (isRecord(value.details) && isRunSnapshot(value.details))
+        return value.details;
+    return undefined;
+}
+function isRunSnapshot(value) {
+    return typeof value.runId === "string" && typeof value.toolName === "string";
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asyncAgentStatus(parent, runStatus) {
+    if (parent.status === "error" || runStatus === "failed")
+        return "error";
+    if (runStatus === "completed" || runStatus === "cancelled")
+        return "done";
+    return "running";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/shared/trace-engine.js

@@ -0,0 +1,96 @@
+import { reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
+import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, traceEventDedupeKey, } from "./trace-event-projection.js";
+import { flattenTraceNodes, mapTraceNodesById, nestTraceNodes } from "./trace-nodes.js";
+import { nestMutableCopiedTraceNodes, shareUnchangedTraceNodes } from "./trace-patch-nodes.js";
+import { mapTraceChildSessionsByParent, mapTraceSubagentSessionLinks, } from "./trace-subagent-links.js";
+import { projectTranscriptEntries, traceNodesFromEntries } from "./trace-transcript.js";
+export { isRunStartToolNode } from "./trace-async-agent-runs.js";
+export { assistantMessageNodeId, dedupeTraceEvents, latestTraceStreamId, messageTurnNodeId, thinkingNodeId, traceEventDedupeKey, } from "./trace-event-projection.js";
+export { traceNodesFromEntries } from "./trace-transcript.js";
+export { compareTraceNodes, flattenTraceNodes, mapTraceNodesById, nestTraceNodes, sortTraceNodes, } from "./trace-nodes.js";
+export function buildTraceViewFromEvents(input) {
+    const sessionStatus = input.status ?? "idle";
+    const events = dedupeTraceEvents(input.events);
+    const allEntries = input.transcriptEntries ?? [];
+    const openTranscriptEventIds = findOpenTranscriptEventIds(events, sessionStatus);
+    const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds);
+    const nodes = traceNodesFromEntries(input.session.id, entries);
+    const byId = mapTraceNodesById(nodes);
+    const childByParent = mapTraceChildSessionsByParent(input.sessions ?? []);
+    const linkedChildByToolCallId = mapTraceSubagentSessionLinks(events);
+    const hasPersistedTranscript = entries.some((entry) => entry.type === "message");
+    for (const storedEvent of events) {
+        applySingleEventToNodes(nodes, byId, input.session.id, storedEvent, childByParent, linkedChildByToolCallId, hasPersistedTranscript, openTranscriptEventIds, sessionStatus);
+    }
+    const nestedNodes = nestTraceNodes(nodes);
+    reconcileAsyncAgentRunStatuses(nestedNodes);
+    return {
+        piboSessionId: input.session.id,
+        piSessionId: input.session.piSessionId,
+        title: input.session.title ?? "Untitled Session",
+        version: "",
+        latestStreamId: latestTraceStreamId(events, input.latestStreamId),
+        nodes: nestedNodes,
+        rawEvents: input.includeRawEvents === true
+            ? events.slice(-(input.rawEventsLimit ?? events.length))
+            : [],
+    };
+}
+// ── transcript helpers ───────────────────────────────────────────
+export function patchTraceViewWithEvent(view, event, sessionStatus) {
+    return patchTraceViewWithEvents(view, [event], sessionStatus);
+}
+export function patchTraceViewWithEvents(view, events, sessionStatus) {
+    if (!events.length)
+        return view;
+    const seenEventKeys = new Set(view.rawEvents.map((event) => traceEventDedupeKey(event)));
+    const candidateEvents = [];
+    for (const event of events) {
+        const eventKey = traceEventDedupeKey(event);
+        if (seenEventKeys.has(eventKey))
+            continue;
+        seenEventKeys.add(eventKey);
+        candidateEvents.push(event);
+    }
+    if (!candidateEvents.length)
+        return view;
+    const previousFlatNodes = flattenTraceNodes(view.nodes);
+    const allNodes = [];
+    const byId = new Map();
+    const previousById = new Map();
+    for (const previousNode of previousFlatNodes) {
+        previousById.set(previousNode.id, previousNode);
+        const nextNode = { ...previousNode, children: [] };
+        allNodes.push(nextNode);
+        byId.set(nextNode.id, nextNode);
+    }
+    const childByParent = new Map();
+    const linkedChildByToolCallId = new Map();
+    const openTranscriptEventIds = new Set();
+    const appliedEvents = [];
+    let contentDeltaChangedNodeIds = new Set();
+    for (const event of candidateEvents) {
+        if (isConfirmedUserMessageEcho(allNodes, event))
+            continue;
+        appliedEvents.push(event);
+        const contentDeltaNodeId = contentDeltaPatchNodeId(event.payload);
+        if (contentDeltaChangedNodeIds && contentDeltaNodeId)
+            contentDeltaChangedNodeIds.add(contentDeltaNodeId);
+        else
+            contentDeltaChangedNodeIds = undefined;
+        applySingleEventToNodes(allNodes, byId, view.piboSessionId, event, childByParent, linkedChildByToolCallId, false, openTranscriptEventIds, sessionStatus);
+    }
+    if (!appliedEvents.length)
+        return view;
+    const nestedNodes = nestMutableCopiedTraceNodes(allNodes);
+    if (eventsCanAffectAsyncAgentRunStatus(appliedEvents)) {
+        reconcileAsyncAgentRunStatuses(nestedNodes);
+    }
+    const sharedNodes = shareUnchangedTraceNodes(previousById, nestedNodes, contentDeltaChangedNodeIds);
+    return {
+        ...view,
+        rawEvents: view.rawEvents.length ? [...view.rawEvents, ...appliedEvents] : appliedEvents,
+        nodes: sharedNodes,
+        latestStreamId: latestTraceStreamId(appliedEvents, view.latestStreamId),
+    };
+}