@botbotgo/agent-harness 0.0.250 → 0.0.252

package/dist/flow/build-flow-graph.js

@@ -1,6 +1,7 @@
 import { projectRuntimeTimeline } from "../runtime/harness/events/timeline.js";
 import { createUpstreamTimelineReducer } from "../upstream-events.js";
 import { formatAgentName } from "../utils/agent-display.js";
+import { buildSurfaceId, resolveSurfaceAction, stripStepPrefix, } from "../runtime/harness/run/surface-semantics.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
 }
@@ -10,16 +11,54 @@ function readString(value) {
 function extractUpstreamEventEnvelope(value) {
     const typed = asObject(value);
     const nestedEvent = typed && Object.prototype.hasOwnProperty.call(typed, "event") ? typed.event : undefined;
+    const surfaceItem = asObject(typed?.surfaceItem);
     const event = typed
         && nestedEvent
         && typeof nestedEvent === "object"
         && !Array.isArray(nestedEvent)
-        && Object.prototype.hasOwnProperty.call(typed, "agentId")
         ? nestedEvent
         : value;
-    const agentId = readString(typed?.agentId);
-    const agentName = readString(typed?.agentName);
-    return { event, agentId: agentId ?? undefined, agentName: agentName ?? undefined };
+    const agentId = readString(typed?.agentId) ?? readString(surfaceItem?.agentId);
+    const agentName = readString(typed?.agentName) ?? readString(surfaceItem?.agentName);
+    return {
+        event,
+        agentId: agentId ?? undefined,
+        agentName: agentName ?? undefined,
+        ...(surfaceItem ? { surfaceItem } : {}),
+    };
+}
+function normalizeRuntimeEventType(eventType) {
+    switch (eventType) {
+        case "request.created":
+            return "run.created";
+        case "request.queued":
+            return "run.queued";
+        case "request.dequeued":
+            return "run.dequeued";
+        case "request.state.changed":
+            return "run.state.changed";
+        case "request.resumed":
+            return "run.resumed";
+        default:
+            return eventType;
+    }
+}
+function normalizeRuntimeEvents(events) {
+    return events.map((event) => {
+        const typed = event;
+        const threadId = readString(typed.threadId) ?? readString(typed.sessionId) ?? "";
+        const runId = readString(typed.runId) ?? readString(typed.requestId) ?? "";
+        return {
+            eventId: String(event.eventId),
+            eventType: normalizeRuntimeEventType(String(event.eventType)),
+            timestamp: String(event.timestamp),
+            threadId,
+            runId,
+            sequence: Number(event.sequence),
+            source: event.source,
+            payload: event.payload ?? {},
+        };
+    });
 }
 function collectNestedAgentNames(value, names = new Set()) {
     if (Array.isArray(value)) {
@@ -50,9 +89,6 @@ function slugify(value) {
         .replace(/^-+|-+$/g, "")
         .slice(0, 80) || "node";
 }
-function buildSurfaceId(kind, value) {
-    return `${kind}:${slugify(value)}`;
-}
 function titleCase(value) {
     return value
         .replace(/[_-]+/g, " ")
@@ -360,6 +396,68 @@ function deriveInitialAgentId(input, runtimeTimeline) {
 function deriveAgentName(agentId, explicitName) {
     return explicitName && explicitName.trim().length > 0 ? explicitName.trim() : formatAgentName(agentId);
 }
+function buildSurfaceStepLabel(surfaceItem) {
+    const kind = surfaceItem.kind;
+    const name = typeof surfaceItem.name === "string" && surfaceItem.name.trim().length > 0
+        ? surfaceItem.name.trim()
+        : typeof surfaceItem.id === "string"
+            ? surfaceItem.id
+            : "";
+    const status = surfaceItem.status;
+    if (!kind || !name || !status || (status !== "started" && status !== "completed" && status !== "failed")) {
+        return null;
+    }
+    if (kind === "llm") {
+        return status === "started" ? `Calling LLM ${name}` : `Completed LLM ${name}`;
+    }
+    if (kind === "tool") {
+        if (status === "failed") {
+            return `Tool ${name} failed`;
+        }
+        return status === "started" ? `Calling tool ${name}` : `Completed tool ${name}`;
+    }
+    if (kind === "skill") {
+        return status === "started" ? `Calling skill ${name}` : `Completed skill ${name}`;
+    }
+    if (kind === "memory") {
+        return status === "started" ? `Accessing memory ${name}` : `Completed memory ${name}`;
+    }
+    return null;
+}
+function createDelegationNodeFromSurfaceItem(surfaceItem, fallbackAgentId, fallbackAgentName, sourceEventId, ordinal) {
+    if (surfaceItem.kind !== "agent") {
+        return null;
+    }
+    const toAgentId = typeof surfaceItem.agentId === "string" && surfaceItem.agentId.trim().length > 0
+        ? surfaceItem.agentId.trim()
+        : fallbackAgentId;
+    const toAgentName = deriveAgentName(toAgentId, typeof surfaceItem.agentName === "string" ? surfaceItem.agentName : undefined);
+    const fromAgentId = typeof surfaceItem.ownerAgentId === "string" && surfaceItem.ownerAgentId.trim().length > 0
+        ? surfaceItem.ownerAgentId.trim()
+        : fallbackAgentId;
+    const fromAgentName = deriveAgentName(fromAgentId, typeof surfaceItem.ownerAgentName === "string" ? surfaceItem.ownerAgentName : fallbackAgentName);
+    return {
+        id: `delegate:${slugify(fromAgentId)}:${slugify(toAgentId)}:${ordinal}`,
+        layer: "execution",
+        kind: "agent",
+        label: `Delegate to ${titleCase(typeof surfaceItem.name === "string" ? surfaceItem.name : toAgentId)}`,
+        status: surfaceItem.status === "failed" ? "failed" : surfaceItem.status === "started" ? "started" : "completed",
+        sessionId: "",
+        requestId: "",
+        threadId: "",
+        runId: "",
+        agentId: toAgentId,
+        agentName: toAgentName,
+        sourceEventIds: [sourceEventId],
+        detail: {
+            fromAgentId,
+            fromAgentName,
+            toAgentId,
+            toAgentName,
+            ...(typeof surfaceItem.action === "string" ? { action: surfaceItem.action } : {}),
+        },
+    };
+}
 function extractDelegatedAgentId(event) {
     const typed = asObject(event);
     if (!typed) {
@@ -372,26 +470,20 @@ function extractDelegatedAgentId(event) {
     }
     const data = asObject(typed.data);
     const input = asObject(data?.input);
+    const nestedInput = typeof input?.input === "string"
+        ? asObject(JSON.parse(input.input))
+        : asObject(input?.input);
     const subagentType = typeof input?.subagent_type === "string"
         ? input.subagent_type
         : typeof input?.subagentType === "string"
             ? input.subagentType
-            : null;
+            : typeof nestedInput?.subagent_type === "string"
+                ? nestedInput.subagent_type
+                : typeof nestedInput?.subagentType === "string"
+                    ? nestedInput.subagentType
+                    : null;
     return subagentType && subagentType.trim().length > 0 ? subagentType.trim() : null;
 }
-function extractAgentFromNestedMessages(event, currentAgentId) {
-    const typed = asObject(event);
-    if (!typed) {
-        return null;
-    }
-    const data = asObject(typed.data);
-    const input = asObject(data?.input);
-    const output = asObject(data?.output);
-    const names = new Set();
-    collectNestedAgentNames(input?.messages, names);
-    collectNestedAgentNames(output?.messages, names);
-    return [...names].find((name) => name !== currentAgentId) ?? null;
-}
 function convertUpstreamEventsWithAgents(upstreamEvents, initialAgentId) {
     const reducer = createUpstreamTimelineReducer();
     const projections = [];
@@ -409,35 +501,11 @@ function convertUpstreamEventsWithAgents(upstreamEvents, initialAgentId) {
         else if (envelope.agentName) {
             currentAgentName = deriveAgentName(currentAgentId, envelope.agentName);
         }
-        const nestedAgentId = extractAgentFromNestedMessages(envelope.event, currentAgentId);
-        if (nestedAgentId && nestedAgentId !== currentAgentId) {
-            const nestedAgentName = deriveAgentName(nestedAgentId);
-            ordinal += 1;
-            delegationNodes.push({
-                id: `delegate:${slugify(currentAgentId)}:${slugify(nestedAgentId)}:${ordinal}`,
-                layer: "execution",
-                kind: "agent",
-                label: `Delegate to ${titleCase(nestedAgentId)}`,
-                status: "completed",
-                sessionId: "",
-                requestId: "",
-                threadId: "",
-                runId: "",
-                agentId: nestedAgentId,
-                agentName: nestedAgentName,
-                sourceEventIds: [sourceEventId],
-                detail: {
-                    fromAgentId: currentAgentId,
-                    fromAgentName: currentAgentName,
-                    toAgentId: nestedAgentId,
-                    toAgentName: nestedAgentName,
-                },
-            });
-            currentAgentId = nestedAgentId;
-            currentAgentName = nestedAgentName;
-        }
         const emitted = reducer.consume(envelope.event);
         for (const projection of emitted) {
+            if (envelope.surfaceItem && projection.type === "step") {
+                continue;
+            }
             projections.push({
                 projection,
                 agentId: currentAgentId,
@@ -445,6 +513,33 @@ function convertUpstreamEventsWithAgents(upstreamEvents, initialAgentId) {
                 sourceEventId,
             });
         }
+        if (envelope.surfaceItem) {
+            const delegationNode = createDelegationNodeFromSurfaceItem(envelope.surfaceItem, currentAgentId, currentAgentName, sourceEventId, ordinal + 1);
+            if (delegationNode) {
+                ordinal += 1;
+                delegationNodes.push(delegationNode);
+            }
+            else {
+                const step = buildSurfaceStepLabel(envelope.surfaceItem);
+                if (step) {
+                    projections.push({
+                        projection: {
+                            type: "step",
+                            key: `surface:${index + 1}:${envelope.surfaceItem.id ?? step}`,
+                            category: envelope.surfaceItem.kind,
+                            status: envelope.surfaceItem.status,
+                            step,
+                        },
+                        agentId: currentAgentId,
+                        agentName: currentAgentName,
+                        sourceEventId,
+                    });
+                }
+            }
+        }
+        if (envelope.surfaceItem) {
+            return;
+        }
         const delegatedAgentId = extractDelegatedAgentId(envelope.event);
         if (!delegatedAgentId || delegatedAgentId === currentAgentId) {
             return;
@@ -544,6 +639,44 @@ function buildAttempts(projectionRecords, delegationNodes, runtimeGroups, thread
     }
     for (const record of projectionRecords) {
         const projection = record.projection;
+        if (!pendingDelegationNode
+            && delegationIndex < delegationNodes.length
+            && delegationNodes[delegationIndex]?.agentId === record.agentId
+            && (!previousAttempt || previousAttempt.agentId !== record.agentId)) {
+            const sourceNode = delegationNodes[delegationIndex];
+            delegationIndex += 1;
+            pendingDelegationNode = {
+                ...sourceNode,
+                sessionId: threadId,
+                requestId: runId,
+                threadId,
+                runId,
+                groupId: currentGroup?.id,
+            };
+            nodes.push(pendingDelegationNode);
+            if (previousAttempt) {
+                edges.push({
+                    id: `edge:${previousAttempt.id}->${pendingDelegationNode.id}`,
+                    from: previousAttempt.id,
+                    to: pendingDelegationNode.id,
+                    kind: "spawn",
+                    label: "delegate",
+                    sourceEventIds: [...pendingDelegationNode.sourceEventIds],
+                    confidence: 0.9,
+                });
+            }
+            else if (currentGroup?.anchorNodeId) {
+                edges.push({
+                    id: `edge:${currentGroup.anchorNodeId}->${pendingDelegationNode.id}`,
+                    from: currentGroup.anchorNodeId,
+                    to: pendingDelegationNode.id,
+                    kind: "spawn",
+                    label: "delegate",
+                    sourceEventIds: [...pendingDelegationNode.sourceEventIds],
+                    confidence: 0.9,
+                });
+            }
+        }
         if (previousAttempt
             && previousAttempt.agentId
             && record.agentId !== previousAttempt.agentId
@@ -743,18 +876,18 @@ function resolveContext(input, runtimeTimeline, projections) {
     return { sessionId: inputSessionId, requestId: inputRequestId };
 }
 export function buildFlowGraph(input) {
-    const runtimeTimeline = input.runtimeTimeline
-        ?? (input.runtimeEvents ? projectRuntimeTimeline(input.runtimeEvents, {
+    const runtimeData = input.runtimeTimeline
+        ?? (input.runtimeEvents ? projectRuntimeTimeline(normalizeRuntimeEvents(input.runtimeEvents), {
             ...(readSessionId(input) ? { threadId: readSessionId(input) } : {}),
             ...(readRequestId(input) ? { runId: readRequestId(input) } : {}),
         }) : []);
-    const initialAgentId = deriveInitialAgentId(input, runtimeTimeline);
+    const initialAgentId = deriveInitialAgentId(input, runtimeData);
     const upstreamContext = input.upstreamEvents
         ? convertUpstreamEventsWithAgents(input.upstreamEvents, initialAgentId)
         : { projections: [], delegationNodes: [] };
     const upstreamProjections = input.upstreamProjections ?? upstreamContext.projections.map((record) => record.projection);
-    const { sessionId, requestId } = resolveContext(input, runtimeTimeline, upstreamProjections);
-    const { nodes: runtimeNodes, edges: runtimeEdges, groups: runtimeGroups } = buildRuntimeNodes(runtimeTimeline);
+    const { sessionId, requestId } = resolveContext(input, runtimeData, upstreamProjections);
+    const { nodes: runtimeNodes, edges: runtimeEdges, groups: runtimeGroups } = buildRuntimeNodes(runtimeData);
     for (const node of runtimeNodes) {
         node.agentId = typeof node.detail.agentId === "string" ? node.detail.agentId : initialAgentId;
         node.agentName = deriveAgentName(node.agentId);
@@ -776,20 +909,15 @@ export function buildFlowGraph(input) {
         id: buildSurfaceId(node.kind, node.kind === "agent" ? (node.agentId ?? node.agentName ?? "agent") : node.label),
         name: node.kind === "agent"
             ? (node.agentName ?? node.agentId ?? "Agent")
-            : normalizeLabel(node.label)
-                .replace(/^Delegate to\s+/i, "")
-                .replace(/^Calling LLM\s+/i, "")
-                .replace(/^Completed LLM\s+/i, "")
-                .replace(/^Calling tool\s+/i, "")
-                .replace(/^Completed tool\s+/i, "")
-                .replace(/^Tool\s+/i, "")
-                .replace(/\s+failed$/i, "")
-                .replace(/^Calling skill\s+/i, "")
-                .replace(/^Completed skill\s+/i, "")
-                .replace(/^Accessing memory\s+/i, "")
-                .replace(/^Completed memory\s+/i, ""),
-        label: node.label,
+            : stripStepPrefix(node.label),
+        action: resolveSurfaceAction({
+            kind: node.kind,
+            step: node.label,
+            event: node.detail,
+        }),
         status: node.status === "resolved" ? "completed" : node.status,
+        agentId: node.agentId,
+        agentName: node.agentName,
         ownerAgentId: node.kind === "agent"
             ? (typeof node.detail.fromAgentId === "string" ? node.detail.fromAgentId : node.agentId)
             : node.agentId,
@@ -797,6 +925,7 @@ export function buildFlowGraph(input) {
             ? (typeof node.detail.fromAgentName === "string" ? node.detail.fromAgentName : node.agentName)
             : node.agentName,
         sourceEventId: node.sourceEventIds[0],
+        detail: { ...node.detail },
     }));
     return {
         graphId: `${sessionId}/${requestId}`,
@@ -809,7 +938,9 @@ export function buildFlowGraph(input) {
         edges: [...runtimeEdges, ...attemptEdges],
         groups: [...runtimeGroups, ...attemptGroups],
         metadata: {
-            runtimeTimelineCount: runtimeTimeline.length,
+            initialAgentId,
+            initialAgentName: deriveAgentName(initialAgentId),
+            runtimeTimelineCount: runtimeData.length,
             upstreamProjectionCount: upstreamProjections.length,
             delegationCount: upstreamContext.delegationNodes.length,
             runtimeSurface,