llmist 12.3.2 → 12.3.4

package/dist/index.cjs

@@ -10362,6 +10362,18 @@ function findParentGadgetInvocationId(tree, nodeId) {
   }
   return void 0;
 }
+function getIterationFromTree(tree, nodeId) {
+  let currentId = nodeId;
+  while (currentId) {
+    const node = tree.getNode(currentId);
+    if (!node) break;
+    if (node.type === "llm_call") {
+      return node.iteration;
+    }
+    currentId = node.parentId;
+  }
+  return 0;
+}
 function buildSubagentContext(tree, event) {
   const parentGadgetInvocationId = findParentGadgetInvocationId(tree, event.nodeId);
   if (!parentGadgetInvocationId) {
@@ -10391,16 +10403,135 @@ async function safeObserve(fn, logger, eventType) {
     logger.warn(`Observer error in ${eventType}:`, error);
   }
 }
+function chainObserverCall(chainMap, key, fn, logger, eventType, cleanup = false) {
+  const previousPromise = chainMap.get(key) ?? Promise.resolve();
+  const newPromise = previousPromise.then(() => safeObserve(fn, logger, eventType));
+  chainMap.set(key, newPromise);
+  if (cleanup) {
+    newPromise.finally(() => chainMap.delete(key));
+  }
+}
 function bridgeTreeToHooks(tree, hooks, logger) {
+  const gadgetPromiseChains = /* @__PURE__ */ new Map();
+  const llmPromiseChains = /* @__PURE__ */ new Map();
   return tree.onAll((event) => {
     const subagentContext = buildSubagentContext(tree, event);
     switch (event.type) {
-      // NOTE: gadget_start, gadget_complete, gadget_error, gadget_skipped are NOT
-      // handled here. They are called directly in stream-processor.ts with await
-      // to ensure proper ordering of observer commands.
-      // LLM events - bridged for subagent visibility
-      // When a subagent makes LLM calls, these events propagate through the shared tree
-      // to the parent's hooks, enabling unified monitoring of all LLM activity
+      // =================================================================
+      // GADGET EVENTS - Bridged for subagent visibility
+      // =================================================================
+      // When a subagent executes gadgets, these events propagate through
+      // the shared tree to the parent's hooks.
+      // Only bridged for subagent events (depth > 0) to avoid double-calling
+      // root agent events which are handled directly in stream-processor.ts
+      case "gadget_start": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionStart) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            logger,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetExecutionStart?.(context),
+            logger,
+            "onGadgetExecutionStart",
+            false
+            // Don't cleanup - wait for completion event
+          );
+        }
+        break;
+      }
+      case "gadget_complete": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            finalResult: gadgetEvent.result,
+            executionTimeMs: gadgetEvent.executionTimeMs,
+            cost: gadgetEvent.cost,
+            logger,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetExecutionComplete?.(context),
+            logger,
+            "onGadgetExecutionComplete",
+            true
+            // Cleanup after completion
+          );
+        }
+        break;
+      }
+      case "gadget_error": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            error: gadgetEvent.error,
+            executionTimeMs: gadgetEvent.executionTimeMs,
+            logger,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetExecutionComplete?.(context),
+            logger,
+            "onGadgetExecutionComplete",
+            true
+            // Cleanup after error
+          );
+        }
+        break;
+      }
+      case "gadget_skipped": {
+        if (subagentContext && hooks.observers?.onGadgetSkipped) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            failedDependency: gadgetEvent.failedDependency ?? "",
+            failedDependencyError: gadgetEvent.failedDependencyError ?? gadgetEvent.error,
+            logger,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetSkipped?.(context),
+            logger,
+            "onGadgetSkipped",
+            true
+            // Cleanup after skipped
+          );
+        }
+        break;
+      }
+      // =================================================================
+      // LLM EVENTS - Bridged for subagent visibility
+      // =================================================================
+      // When a subagent makes LLM calls, these events propagate through
+      // the shared tree to the parent's hooks.
       case "llm_call_start": {
         if (subagentContext && hooks.observers?.onLLMCallStart) {
           const llmEvent = event;
@@ -10416,7 +10547,15 @@ function bridgeTreeToHooks(tree, hooks, logger) {
             logger,
             subagentContext
           };
-          safeObserve(() => hooks.observers.onLLMCallStart(context), logger, "onLLMCallStart");
+          chainObserverCall(
+            llmPromiseChains,
+            event.nodeId,
+            () => hooks.observers?.onLLMCallStart?.(context),
+            logger,
+            "onLLMCallStart",
+            false
+            // Don't cleanup - wait for completion event
+          );
         }
         break;
       }
@@ -10440,10 +10579,14 @@ function bridgeTreeToHooks(tree, hooks, logger) {
             logger,
             subagentContext
           };
-          safeObserve(
-            () => hooks.observers.onLLMCallComplete(context),
+          chainObserverCall(
+            llmPromiseChains,
+            event.nodeId,
+            () => hooks.observers?.onLLMCallComplete?.(context),
             logger,
-            "onLLMCallComplete"
+            "onLLMCallComplete",
+            true
+            // Cleanup after completion
           );
         }
         break;
@@ -10465,7 +10608,15 @@ function bridgeTreeToHooks(tree, hooks, logger) {
             logger,
             subagentContext
           };
-          safeObserve(() => hooks.observers.onLLMCallError(context), logger, "onLLMCallError");
+          chainObserverCall(
+            llmPromiseChains,
+            event.nodeId,
+            () => hooks.observers?.onLLMCallError?.(context),
+            logger,
+            "onLLMCallError",
+            true
+            // Cleanup after error
+          );
         }
         break;
       }