@botbotgo/agent-harness 0.0.245 → 0.0.247

package/dist/flow/export-mermaid.js

@@ -1,4 +1,5 @@
 const PRODUCT_VIEW_KINDS = new Set(["agent", "llm", "tool", "skill"]);
+const STRUCTURAL_EDGE_KINDS = new Set(["sequence", "contains"]);
 function sanitizeMermaidId(value) {
     return value.replace(/[^A-Za-z0-9_]/g, "_");
 }
@@ -31,6 +32,68 @@ function renderEdge(edge, fromId, toId) {
         ? `  ${fromId} ${connector}|"${escapeMermaidLabel(label)}"| ${toId}`
         : `  ${fromId} ${connector} ${toId}`;
 }
+function edgeKey(edge) {
+    return `${edge.from}::${edge.to}::${edge.kind}::${edge.label ?? ""}::${edge.condition ?? ""}`;
+}
+function collapseEdgePath(source, target, path) {
+    const representative = [...path].reverse().find((edge) => !STRUCTURAL_EDGE_KINDS.has(edge.kind) || edge.label || edge.condition);
+    const sourceEventIds = [...new Set(path.flatMap((edge) => edge.sourceEventIds))];
+    return {
+        id: `collapsed:${source}:${target}:${sourceEventIds.join(",")}`,
+        from: source,
+        to: target,
+        kind: representative?.kind ?? "sequence",
+        label: representative?.label,
+        condition: representative?.condition,
+        sourceEventIds,
+    };
+}
+function collectVisibleEdges(graph, visibleNodes, includedEdgeKinds) {
+    const visibleNodeIds = new Set(visibleNodes.map((node) => node.id));
+    const candidateEdges = graph.edges.filter((edge) => includedEdgeKinds ? includedEdgeKinds.has(edge.kind) : true);
+    const outgoingByNodeId = new Map();
+    for (const edge of candidateEdges) {
+        const outgoing = outgoingByNodeId.get(edge.from);
+        if (outgoing) {
+            outgoing.push(edge);
+        }
+        else {
+            outgoingByNodeId.set(edge.from, [edge]);
+        }
+    }
+    const visibleEdges = candidateEdges.filter((edge) => visibleNodeIds.has(edge.from) && visibleNodeIds.has(edge.to));
+    const seenEdgeKeys = new Set(visibleEdges.map((edge) => edgeKey(edge)));
+    for (const node of visibleNodes) {
+        const queue = (outgoingByNodeId.get(node.id) ?? [])
+            .filter((edge) => !visibleNodeIds.has(edge.to))
+            .map((edge) => ({ nodeId: edge.to, path: [edge] }));
+        const visitedHiddenNodes = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visitedHiddenNodes.has(current.nodeId)) {
+                continue;
+            }
+            visitedHiddenNodes.add(current.nodeId);
+            for (const edge of outgoingByNodeId.get(current.nodeId) ?? []) {
+                const nextPath = [...current.path, edge];
+                if (visibleNodeIds.has(edge.to)) {
+                    if (edge.to === node.id) {
+                        continue;
+                    }
+                    const collapsed = collapseEdgePath(node.id, edge.to, nextPath);
+                    const key = edgeKey(collapsed);
+                    if (!seenEdgeKeys.has(key)) {
+                        seenEdgeKeys.add(key);
+                        visibleEdges.push(collapsed);
+                    }
+                    continue;
+                }
+                queue.push({ nodeId: edge.to, path: nextPath });
+            }
+        }
+    }
+    return visibleEdges;
+}
 export function exportFlowGraphToMermaid(graph, options = {}) {
     const direction = options.direction ?? "TD";
     const view = options.view ?? "product";
@@ -49,12 +112,7 @@ export function exportFlowGraphToMermaid(graph, options = {}) {
         return includedKinds ? includedKinds.has(node.kind) : true;
     });
     const nodeIdSet = new Set(nodes.map((node) => node.id));
-    const edges = graph.edges.filter((edge) => {
-        if (!nodeIdSet.has(edge.from) || !nodeIdSet.has(edge.to)) {
-            return false;
-        }
-        return includedEdgeKinds ? includedEdgeKinds.has(edge.kind) : true;
-    });
+    const edges = collectVisibleEdges(graph, nodes, includedEdgeKinds);
     const lines = [`flowchart ${direction}`];
     const mermaidIdByNodeId = new Map();
     for (const node of nodes) {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.244";
+export declare const AGENT_HARNESS_VERSION = "0.0.246";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.244";
+export const AGENT_HARNESS_VERSION = "0.0.246";

package/dist/runtime/harness/run/stream-run.js

@@ -158,6 +158,13 @@ export async function* streamHarnessRun(options) {
             }
         }
         await options.appendAssistantMessage(options.threadId, options.runId, assistantOutput);
+        const completedEvent = await options.setRunStateAndEmit(options.threadId, options.runId, 6, "completed", {
+            previousState: "running",
+        });
+        yield {
+            type: "event",
+            event: completedEvent,
+        };
         yield {
             type: "result",
             result: {
@@ -169,12 +176,6 @@ export async function* streamHarnessRun(options) {
                 finalMessageText: assistantOutput,
             },
         };
-        yield {
-            type: "event",
-            event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, "completed", {
-                previousState: "running",
-            }),
-        };
     }
     catch (error) {
         const shouldRetryAfterStreamingCompatibilityError = streamActivityObserved &&
@@ -251,6 +252,13 @@ export async function* streamHarnessRun(options) {
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
                 yield createContentBlocksItem(options.threadId, options.runId, options.selectedAgentId, actual.contentBlocks);
             }
+            const terminalEvent = await options.setRunStateAndEmit(options.threadId, options.runId, 6, actual.state, {
+                previousState: "running",
+            });
+            yield {
+                type: "event",
+                event: terminalEvent,
+            };
             yield {
                 type: "result",
                 result: {
@@ -264,12 +272,6 @@ export async function* streamHarnessRun(options) {
                     },
                 },
             };
-            yield {
-                type: "event",
-                event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, actual.state, {
-                    previousState: "running",
-                }),
-            };
             return;
         }
         catch (invokeError) {

package/dist/upstream-events.js

@@ -31,8 +31,17 @@ function readEventContext(event) {
 function containsSemanticHint(values, hint) {
     return values.some((value) => hint.test(value));
 }
+function normalizeSemanticHint(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[.:/]+/g, " ")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
 function classifyStepCategory(context) {
-    const hints = [context.name, context.runType, ...context.tags, ...context.ns].map((value) => value.toLowerCase());
+    const hints = [context.name, context.runType, ...context.tags, ...context.ns].map(normalizeSemanticHint);
     if (containsSemanticHint(hints, /\b(skill|skills)\b/)) {
         return "skill";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.245",
+  "version": "0.0.247",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",