llmist 11.0.1 → 11.1.0

package/dist/index.cjs

@@ -9125,15 +9125,27 @@ function getIterationFromTree(tree, nodeId) {
   return 0;
 }
 function buildSubagentContext(tree, event) {
-  if (event.depth === 0) {
+  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, event.nodeId);
+  if (!parentGadgetInvocationId) {
     return void 0;
   }
-  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, event.nodeId);
   return {
-    parentGadgetInvocationId: parentGadgetInvocationId ?? "unknown",
+    parentGadgetInvocationId,
     depth: event.depth
   };
 }
+function getSubagentContextForNode(tree, nodeId) {
+  const node = tree.getNode(nodeId);
+  if (!node) return void 0;
+  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, nodeId);
+  if (!parentGadgetInvocationId) {
+    return void 0;
+  }
+  return {
+    parentGadgetInvocationId,
+    depth: node.depth
+  };
+}
 async function safeObserve(fn, logger, eventType) {
   try {
     await fn();
@@ -9603,13 +9615,16 @@ var init_agent = __esm({
               });
             }
             this.logger.debug("Starting iteration", { iteration: currentIteration });
+            let currentLLMNodeId;
+            let llmOptions;
             try {
               const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
               if (compactionEvent) {
                 yield compactionEvent;
               }
               const prepared = await this.prepareLLMCall(currentIteration);
-              const llmOptions = prepared.options;
+              llmOptions = prepared.options;
+              currentLLMNodeId = prepared.llmNodeId;
               if (prepared.skipWithSynthetic !== void 0) {
                 this.conversation.addAssistantMessage(prepared.skipWithSynthetic);
                 yield { type: "text", content: prepared.skipWithSynthetic };
@@ -9623,13 +9638,6 @@ var init_agent = __esm({
                 messageCount: llmOptions.messages.length,
                 messages: llmOptions.messages
               });
-              const llmNode = this.tree.addLLMCall({
-                iteration: currentIteration,
-                model: llmOptions.model,
-                parentId: this.parentNodeId,
-                request: llmOptions.messages
-              });
-              const currentLLMNodeId = llmNode.id;
               const stream2 = await this.createStreamWithRetry(llmOptions, currentIteration);
               const processor = new StreamProcessor({
                 iteration: currentIteration,
@@ -9691,6 +9699,7 @@ var init_agent = __esm({
               });
               await this.safeObserve(async () => {
                 if (this.hooks.observers?.onLLMCallComplete) {
+                  const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
                   const context = {
                     iteration: currentIteration,
                     options: llmOptions,
@@ -9698,7 +9707,8 @@ var init_agent = __esm({
                     usage: result.usage,
                     rawResponse: result.rawResponse,
                     finalMessage: result.finalMessage,
-                    logger: this.logger
+                    logger: this.logger,
+                    subagentContext
                   };
                   await this.hooks.observers.onLLMCallComplete(context);
                 }
@@ -9727,17 +9737,20 @@ var init_agent = __esm({
               const errorHandled = await this.handleLLMError(error, currentIteration);
               await this.safeObserve(async () => {
                 if (this.hooks.observers?.onLLMCallError) {
+                  const options = llmOptions ?? {
+                    model: this.model,
+                    messages: this.conversation.getMessages(),
+                    temperature: this.temperature,
+                    maxTokens: this.defaultMaxTokens
+                  };
+                  const subagentContext = currentLLMNodeId ? getSubagentContextForNode(this.tree, currentLLMNodeId) : void 0;
                   const context = {
                     iteration: currentIteration,
-                    options: {
-                      model: this.model,
-                      messages: this.conversation.getMessages(),
-                      temperature: this.temperature,
-                      maxTokens: this.defaultMaxTokens
-                    },
+                    options,
                     error,
                     recovered: errorHandled,
-                    logger: this.logger
+                    logger: this.logger,
+                    subagentContext
                   };
                   await this.hooks.observers.onLLMCallError(context);
                 }
@@ -9975,8 +9988,8 @@ var init_agent = __esm({
         return { type: "compaction", event: compactionEvent };
       }
       /**
-       * Prepare LLM call options and process beforeLLMCall controller.
-       * @returns options and optional skipWithSynthetic response if controller wants to skip
+       * Prepare LLM call options, create tree node, and process beforeLLMCall controller.
+       * @returns options, node ID, and optional skipWithSynthetic response if controller wants to skip
        */
       async prepareLLMCall(iteration) {
         let llmOptions = {
@@ -9986,12 +9999,20 @@ var init_agent = __esm({
           maxTokens: this.defaultMaxTokens,
           signal: this.signal
         };
+        const llmNode = this.tree.addLLMCall({
+          iteration,
+          model: llmOptions.model,
+          parentId: this.parentNodeId,
+          request: llmOptions.messages
+        });
         await this.safeObserve(async () => {
           if (this.hooks.observers?.onLLMCallStart) {
+            const subagentContext = getSubagentContextForNode(this.tree, llmNode.id);
             const context = {
               iteration,
               options: llmOptions,
-              logger: this.logger
+              logger: this.logger,
+              subagentContext
             };
             await this.hooks.observers.onLLMCallStart(context);
           }
@@ -10007,23 +10028,25 @@ var init_agent = __esm({
           validateBeforeLLMCallAction(action);
           if (action.action === "skip") {
             this.logger.info("Controller skipped LLM call, using synthetic response");
-            return { options: llmOptions, skipWithSynthetic: action.syntheticResponse };
+            return { options: llmOptions, llmNodeId: llmNode.id, skipWithSynthetic: action.syntheticResponse };
           } else if (action.action === "proceed" && action.modifiedOptions) {
             llmOptions = { ...llmOptions, ...action.modifiedOptions };
           }
         }
         await this.safeObserve(async () => {
           if (this.hooks.observers?.onLLMCallReady) {
+            const subagentContext = getSubagentContextForNode(this.tree, llmNode.id);
             const context = {
               iteration,
               maxIterations: this.maxIterations,
               options: llmOptions,
-              logger: this.logger
+              logger: this.logger,
+              subagentContext
             };
             await this.hooks.observers.onLLMCallReady(context);
           }
         });
-        return { options: llmOptions };
+        return { options: llmOptions, llmNodeId: llmNode.id };
       }
       /**
        * Calculate cost and complete LLM call in execution tree.