llmist 11.0.0 → 11.1.0

package/dist/index.cjs

@@ -756,6 +756,20 @@ var init_execution_tree = __esm({
         });
         return node;
       }
+      /**
+       * Update a gadget's parameters (e.g., after interceptor modifies them).
+       * This is called after the gadget is added to the tree but before execution.
+       */
+      updateGadgetParameters(invocationId, parameters) {
+        const nodeId = this.invocationIdToNodeId.get(invocationId);
+        if (!nodeId) {
+          return;
+        }
+        const node = this.nodes.get(nodeId);
+        if (node?.type === "gadget") {
+          node.parameters = parameters;
+        }
+      }
       /**
        * Mark a gadget as started (running).
        */
@@ -8685,6 +8699,9 @@ var init_stream_processor = __esm({
           parameters = this.hooks.interceptors.interceptGadgetParameters(parameters, context);
         }
         call.parameters = parameters;
+        if (this.tree) {
+          this.tree.updateGadgetParameters(call.invocationId, parameters);
+        }
         let shouldSkip = false;
         let syntheticResult;
         if (this.hooks.controllers?.beforeGadgetExecution) {
@@ -8705,20 +8722,6 @@ var init_stream_processor = __esm({
             });
           }
         }
-        const startObservers = [];
-        if (this.hooks.observers?.onGadgetExecutionStart) {
-          startObservers.push(async () => {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters,
-              logger: this.logger
-            };
-            await this.hooks.observers?.onGadgetExecutionStart?.(context);
-          });
-        }
-        await this.runObserversInParallel(startObservers);
         if (this.tree) {
           const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
           if (gadgetNode) {
@@ -8737,7 +8740,6 @@ var init_stream_processor = __esm({
         } else {
           result = await this.executor.execute(call);
         }
-        const originalResult = result.result;
         if (result.result && this.hooks.interceptors?.interceptGadgetResult) {
           const context = {
             iteration: this.iteration,
@@ -8774,26 +8776,6 @@ var init_stream_processor = __esm({
             };
           }
         }
-        const completeObservers = [];
-        if (this.hooks.observers?.onGadgetExecutionComplete) {
-          completeObservers.push(async () => {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: result.gadgetName,
-              invocationId: result.invocationId,
-              parameters,
-              originalResult,
-              finalResult: result.result,
-              error: result.error,
-              executionTimeMs: result.executionTimeMs,
-              breaksLoop: result.breaksLoop,
-              cost: result.cost,
-              logger: this.logger
-            };
-            await this.hooks.observers?.onGadgetExecutionComplete?.(context);
-          });
-        }
-        await this.runObserversInParallel(completeObservers);
         if (this.tree) {
           const gadgetNode = this.tree.getNodeByInvocationId(result.invocationId);
           if (gadgetNode) {
@@ -8938,18 +8920,6 @@ var init_stream_processor = __esm({
             failedDependencyError: depError
           };
           events.push(skipEvent);
-          if (this.hooks.observers?.onGadgetSkipped) {
-            const observeContext = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: failedDep,
-              failedDependencyError: depError,
-              logger: this.logger
-            };
-            await this.safeObserve(() => this.hooks.observers?.onGadgetSkipped?.(observeContext));
-          }
           this.logger.info("Gadget skipped due to failed dependency", {
             gadgetName: call.gadgetName,
             invocationId: call.invocationId,
@@ -9127,6 +9097,160 @@ var init_stream_processor = __esm({
   }
 });
 
+// src/agent/tree-hook-bridge.ts
+function findParentGadgetInvocationId(tree, nodeId) {
+  let currentId = nodeId;
+  while (currentId) {
+    const node = tree.getNode(currentId);
+    if (!node) break;
+    currentId = node.parentId;
+    if (!currentId) break;
+    const parentNode = tree.getNode(currentId);
+    if (parentNode?.type === "gadget") {
+      return parentNode.invocationId;
+    }
+  }
+  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) {
+    return void 0;
+  }
+  return {
+    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();
+  } catch (error) {
+    logger.warn(`Observer error in ${eventType}:`, error);
+  }
+}
+function bridgeTreeToHooks(tree, hooks, logger) {
+  return tree.onAll((event) => {
+    const subagentContext = buildSubagentContext(tree, event);
+    switch (event.type) {
+      case "gadget_start": {
+        if (hooks.observers?.onGadgetExecutionStart) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNodeByInvocationId(gadgetEvent.invocationId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            logger,
+            subagentContext
+          };
+          safeObserve(
+            () => hooks.observers.onGadgetExecutionStart(context),
+            logger,
+            "onGadgetExecutionStart"
+          );
+        }
+        break;
+      }
+      case "gadget_complete": {
+        if (hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNodeByInvocationId(gadgetEvent.invocationId);
+          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
+          };
+          safeObserve(
+            () => hooks.observers.onGadgetExecutionComplete(context),
+            logger,
+            "onGadgetExecutionComplete"
+          );
+        }
+        break;
+      }
+      case "gadget_error": {
+        if (hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetNode = tree.getNodeByInvocationId(event.invocationId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: event.name,
+            invocationId: event.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            error: event.error,
+            executionTimeMs: event.executionTimeMs,
+            logger,
+            subagentContext
+          };
+          safeObserve(
+            () => hooks.observers.onGadgetExecutionComplete(context),
+            logger,
+            "onGadgetExecutionComplete"
+          );
+        }
+        break;
+      }
+      case "gadget_skipped": {
+        if (hooks.observers?.onGadgetSkipped) {
+          const gadgetNode = tree.getNodeByInvocationId(event.invocationId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: event.name,
+            invocationId: event.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            failedDependency: event.failedDependency ?? "unknown",
+            failedDependencyError: event.failedDependencyError ?? event.error,
+            logger,
+            subagentContext
+          };
+          safeObserve(
+            () => hooks.observers.onGadgetSkipped(context),
+            logger,
+            "onGadgetSkipped"
+          );
+        }
+        break;
+      }
+    }
+  });
+}
+var init_tree_hook_bridge = __esm({
+  "src/agent/tree-hook-bridge.ts"() {
+    "use strict";
+  }
+});
+
 // src/agent/agent.ts
 var import_p_retry, Agent;
 var init_agent = __esm({
@@ -9148,6 +9272,7 @@ var init_agent = __esm({
     init_gadget_output_store();
     init_hook_validators();
     init_stream_processor();
+    init_tree_hook_bridge();
     Agent = class {
       client;
       model;
@@ -9454,6 +9579,14 @@ var init_agent = __esm({
        * Run the agent loop.
        * Clean, simple orchestration - all complexity is in StreamProcessor.
        *
+       * ## Event Architecture
+       *
+       * ExecutionTree is the single source of truth for all agent events.
+       * Gadget observer hooks (`onGadgetExecutionStart`, `onGadgetExecutionComplete`,
+       * `onGadgetSkipped`) are derived from tree events via `tree-hook-bridge.ts`.
+       * This ensures consistent `subagentContext` for nested agents - both the TUI
+       * and user hook observers receive identical event context.
+       *
        * @throws {Error} If no user prompt was provided (when using build() without ask())
        */
       async *run() {
@@ -9462,173 +9595,179 @@ var init_agent = __esm({
             "No user prompt provided. Use .ask(prompt) instead of .build(), or call agent.run() after providing a prompt."
           );
         }
+        const unsubscribeBridge = bridgeTreeToHooks(this.tree, this.hooks, this.logger);
         let currentIteration = 0;
         this.logger.info("Starting agent loop", {
           model: this.model,
           maxIterations: this.maxIterations
         });
-        while (currentIteration < this.maxIterations) {
-          if (await this.checkAbortAndNotify(currentIteration)) {
-            return;
-          }
-          while (this.pendingUserMessages.length > 0) {
-            const msg = this.pendingUserMessages.shift();
-            this.conversation.addUserMessage(msg);
-            this.logger.info("Injected user message into conversation", {
-              iteration: currentIteration,
-              messageLength: msg.length
-            });
-          }
-          this.logger.debug("Starting iteration", { iteration: currentIteration });
-          try {
-            const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
-            if (compactionEvent) {
-              yield compactionEvent;
+        try {
+          while (currentIteration < this.maxIterations) {
+            if (await this.checkAbortAndNotify(currentIteration)) {
+              return;
             }
-            const prepared = await this.prepareLLMCall(currentIteration);
-            const llmOptions = prepared.options;
-            if (prepared.skipWithSynthetic !== void 0) {
-              this.conversation.addAssistantMessage(prepared.skipWithSynthetic);
-              yield { type: "text", content: prepared.skipWithSynthetic };
-              break;
+            while (this.pendingUserMessages.length > 0) {
+              const msg = this.pendingUserMessages.shift();
+              this.conversation.addUserMessage(msg);
+              this.logger.info("Injected user message into conversation", {
+                iteration: currentIteration,
+                messageLength: msg.length
+              });
             }
-            this.logger.info("Calling LLM", { model: this.model });
-            this.logger.silly("LLM request details", {
-              model: llmOptions.model,
-              temperature: llmOptions.temperature,
-              maxTokens: llmOptions.maxTokens,
-              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,
-              registry: this.registry,
-              gadgetStartPrefix: this.gadgetStartPrefix,
-              gadgetEndPrefix: this.gadgetEndPrefix,
-              gadgetArgPrefix: this.gadgetArgPrefix,
-              hooks: this.hooks,
-              logger: this.logger.getSubLogger({ name: "stream-processor" }),
-              requestHumanInput: this.requestHumanInput,
-              defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
-              client: this.client,
-              mediaStore: this.mediaStore,
-              agentConfig: this.agentContextConfig,
-              subagentConfig: this.subagentConfig,
-              // Tree context for execution tracking
-              tree: this.tree,
-              parentNodeId: currentLLMNodeId,
-              // Gadgets are children of this LLM call
-              baseDepth: this.baseDepth,
-              // Cross-iteration dependency tracking
-              priorCompletedInvocations: this.completedInvocationIds,
-              priorFailedInvocations: this.failedInvocationIds
-            });
-            let streamMetadata = null;
-            let gadgetCallCount = 0;
-            const textOutputs = [];
-            const gadgetResults = [];
-            for await (const event of processor.process(stream2)) {
-              if (event.type === "stream_complete") {
-                streamMetadata = event;
-                continue;
+            this.logger.debug("Starting iteration", { iteration: currentIteration });
+            let currentLLMNodeId;
+            let llmOptions;
+            try {
+              const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
+              if (compactionEvent) {
+                yield compactionEvent;
               }
-              if (event.type === "text") {
-                textOutputs.push(event.content);
-              } else if (event.type === "gadget_result") {
-                gadgetCallCount++;
-                gadgetResults.push(event);
+              const prepared = await this.prepareLLMCall(currentIteration);
+              llmOptions = prepared.options;
+              currentLLMNodeId = prepared.llmNodeId;
+              if (prepared.skipWithSynthetic !== void 0) {
+                this.conversation.addAssistantMessage(prepared.skipWithSynthetic);
+                yield { type: "text", content: prepared.skipWithSynthetic };
+                break;
               }
-              yield event;
-            }
-            if (!streamMetadata) {
-              throw new Error("Stream processing completed without metadata event");
-            }
-            for (const id of processor.getCompletedInvocationIds()) {
-              this.completedInvocationIds.add(id);
-            }
-            for (const id of processor.getFailedInvocationIds()) {
-              this.failedInvocationIds.add(id);
-            }
-            const result = streamMetadata;
-            this.logger.info("LLM response completed", {
-              finishReason: result.finishReason,
-              usage: result.usage,
-              didExecuteGadgets: result.didExecuteGadgets
-            });
-            this.logger.silly("LLM response details", {
-              rawResponse: result.rawResponse
-            });
-            await this.safeObserve(async () => {
-              if (this.hooks.observers?.onLLMCallComplete) {
-                const context = {
-                  iteration: currentIteration,
-                  options: llmOptions,
-                  finishReason: result.finishReason,
-                  usage: result.usage,
-                  rawResponse: result.rawResponse,
-                  finalMessage: result.finalMessage,
-                  logger: this.logger
-                };
-                await this.hooks.observers.onLLMCallComplete(context);
+              this.logger.info("Calling LLM", { model: this.model });
+              this.logger.silly("LLM request details", {
+                model: llmOptions.model,
+                temperature: llmOptions.temperature,
+                maxTokens: llmOptions.maxTokens,
+                messageCount: llmOptions.messages.length,
+                messages: llmOptions.messages
+              });
+              const stream2 = await this.createStreamWithRetry(llmOptions, currentIteration);
+              const processor = new StreamProcessor({
+                iteration: currentIteration,
+                registry: this.registry,
+                gadgetStartPrefix: this.gadgetStartPrefix,
+                gadgetEndPrefix: this.gadgetEndPrefix,
+                gadgetArgPrefix: this.gadgetArgPrefix,
+                hooks: this.hooks,
+                logger: this.logger.getSubLogger({ name: "stream-processor" }),
+                requestHumanInput: this.requestHumanInput,
+                defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
+                client: this.client,
+                mediaStore: this.mediaStore,
+                agentConfig: this.agentContextConfig,
+                subagentConfig: this.subagentConfig,
+                // Tree context for execution tracking
+                tree: this.tree,
+                parentNodeId: currentLLMNodeId,
+                // Gadgets are children of this LLM call
+                baseDepth: this.baseDepth,
+                // Cross-iteration dependency tracking
+                priorCompletedInvocations: this.completedInvocationIds,
+                priorFailedInvocations: this.failedInvocationIds
+              });
+              let streamMetadata = null;
+              let gadgetCallCount = 0;
+              const textOutputs = [];
+              const gadgetResults = [];
+              for await (const event of processor.process(stream2)) {
+                if (event.type === "stream_complete") {
+                  streamMetadata = event;
+                  continue;
+                }
+                if (event.type === "text") {
+                  textOutputs.push(event.content);
+                } else if (event.type === "gadget_result") {
+                  gadgetCallCount++;
+                  gadgetResults.push(event);
+                }
+                yield event;
               }
-            });
-            this.completeLLMCallInTree(currentLLMNodeId, result);
-            const finalMessage = await this.processAfterLLMCallController(
-              currentIteration,
-              llmOptions,
-              result,
-              gadgetCallCount
-            );
-            const shouldBreakFromTextOnly = await this.updateConversationWithResults(
-              result.didExecuteGadgets,
-              textOutputs,
-              gadgetResults,
-              finalMessage
-            );
-            if (shouldBreakFromTextOnly) {
-              break;
-            }
-            if (result.shouldBreakLoop) {
-              this.logger.info("Loop terminated by gadget or processor");
-              break;
-            }
-          } catch (error) {
-            const errorHandled = await this.handleLLMError(error, currentIteration);
-            await this.safeObserve(async () => {
-              if (this.hooks.observers?.onLLMCallError) {
-                const context = {
-                  iteration: currentIteration,
-                  options: {
+              if (!streamMetadata) {
+                throw new Error("Stream processing completed without metadata event");
+              }
+              for (const id of processor.getCompletedInvocationIds()) {
+                this.completedInvocationIds.add(id);
+              }
+              for (const id of processor.getFailedInvocationIds()) {
+                this.failedInvocationIds.add(id);
+              }
+              const result = streamMetadata;
+              this.logger.info("LLM response completed", {
+                finishReason: result.finishReason,
+                usage: result.usage,
+                didExecuteGadgets: result.didExecuteGadgets
+              });
+              this.logger.silly("LLM response details", {
+                rawResponse: result.rawResponse
+              });
+              await this.safeObserve(async () => {
+                if (this.hooks.observers?.onLLMCallComplete) {
+                  const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
+                  const context = {
+                    iteration: currentIteration,
+                    options: llmOptions,
+                    finishReason: result.finishReason,
+                    usage: result.usage,
+                    rawResponse: result.rawResponse,
+                    finalMessage: result.finalMessage,
+                    logger: this.logger,
+                    subagentContext
+                  };
+                  await this.hooks.observers.onLLMCallComplete(context);
+                }
+              });
+              this.completeLLMCallInTree(currentLLMNodeId, result);
+              const finalMessage = await this.processAfterLLMCallController(
+                currentIteration,
+                llmOptions,
+                result,
+                gadgetCallCount
+              );
+              const shouldBreakFromTextOnly = await this.updateConversationWithResults(
+                result.didExecuteGadgets,
+                textOutputs,
+                gadgetResults,
+                finalMessage
+              );
+              if (shouldBreakFromTextOnly) {
+                break;
+              }
+              if (result.shouldBreakLoop) {
+                this.logger.info("Loop terminated by gadget or processor");
+                break;
+              }
+            } catch (error) {
+              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
-                  },
-                  error,
-                  recovered: errorHandled,
-                  logger: this.logger
-                };
-                await this.hooks.observers.onLLMCallError(context);
+                  };
+                  const subagentContext = currentLLMNodeId ? getSubagentContextForNode(this.tree, currentLLMNodeId) : void 0;
+                  const context = {
+                    iteration: currentIteration,
+                    options,
+                    error,
+                    recovered: errorHandled,
+                    logger: this.logger,
+                    subagentContext
+                  };
+                  await this.hooks.observers.onLLMCallError(context);
+                }
+              });
+              if (!errorHandled) {
+                throw error;
               }
-            });
-            if (!errorHandled) {
-              throw error;
             }
+            currentIteration++;
           }
-          currentIteration++;
+          this.logger.info("Agent loop completed", {
+            totalIterations: currentIteration,
+            reason: currentIteration >= this.maxIterations ? "max_iterations" : "natural_completion"
+          });
+        } finally {
+          unsubscribeBridge();
         }
-        this.logger.info("Agent loop completed", {
-          totalIterations: currentIteration,
-          reason: currentIteration >= this.maxIterations ? "max_iterations" : "natural_completion"
-        });
       }
       /**
        * Create LLM stream with retry logic.
@@ -9849,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 = {
@@ -9860,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);
           }
@@ -9881,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.