llmist 3.0.0 → 3.1.0

package/dist/cli.cjs

@@ -3496,7 +3496,7 @@ var init_executor = __esm({
     init_exceptions();
     init_parser();
     GadgetExecutor = class {
-      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig) {
+      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig, onNestedEvent) {
         this.registry = registry;
         this.requestHumanInput = requestHumanInput;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
@@ -3504,6 +3504,7 @@ var init_executor = __esm({
         this.mediaStore = mediaStore;
         this.agentConfig = agentConfig;
         this.subagentConfig = subagentConfig;
+        this.onNestedEvent = onNestedEvent;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
         this.errorFormatter = new GadgetExecutionErrorFormatter(errorFormatterOptions);
         this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
@@ -3649,7 +3650,9 @@ var init_executor = __esm({
             llmist: this.client ? new CostReportingLLMistWrapper(this.client, reportCost) : void 0,
             signal: abortController.signal,
             agentConfig: this.agentConfig,
-            subagentConfig: this.subagentConfig
+            subagentConfig: this.subagentConfig,
+            invocationId: call.invocationId,
+            onNestedEvent: this.onNestedEvent
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -3888,14 +3891,21 @@ var init_stream_processor = __esm({
           options.client,
           options.mediaStore,
           options.agentConfig,
-          options.subagentConfig
+          options.subagentConfig,
+          options.onNestedEvent
         );
       }
       /**
-       * Process an LLM stream and return structured results.
+       * Process an LLM stream and yield events in real-time.
+       *
+       * This is an async generator that yields events immediately as they occur:
+       * - Text events are yielded as text is streamed from the LLM
+       * - gadget_call events are yielded immediately when a gadget call is parsed
+       * - gadget_result events are yielded when gadget execution completes
+       *
+       * The final event is always a StreamCompletionEvent containing metadata.
        */
-      async process(stream2) {
-        const outputs = [];
+      async *process(stream2) {
         let finishReason = null;
         let usage;
         let didExecuteGadgets = false;
@@ -3941,14 +3951,13 @@ var init_stream_processor = __esm({
             continue;
           }
           for (const event of this.parser.feed(processedChunk)) {
-            const processedEvents = await this.processEvent(event);
-            outputs.push(...processedEvents);
-            if (processedEvents.some((e) => e.type === "gadget_result")) {
-              didExecuteGadgets = true;
-            }
-            for (const evt of processedEvents) {
-              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-                shouldBreakLoop = true;
+            for await (const processedEvent of this.processEventGenerator(event)) {
+              yield processedEvent;
+              if (processedEvent.type === "gadget_result") {
+                didExecuteGadgets = true;
+                if (processedEvent.result.breaksLoop) {
+                  shouldBreakLoop = true;
+                }
               }
             }
           }
@@ -3959,25 +3968,23 @@ var init_stream_processor = __esm({
         }
         if (!this.executionHalted) {
           for (const event of this.parser.finalize()) {
-            const processedEvents = await this.processEvent(event);
-            outputs.push(...processedEvents);
-            if (processedEvents.some((e) => e.type === "gadget_result")) {
-              didExecuteGadgets = true;
-            }
-            for (const evt of processedEvents) {
-              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-                shouldBreakLoop = true;
+            for await (const processedEvent of this.processEventGenerator(event)) {
+              yield processedEvent;
+              if (processedEvent.type === "gadget_result") {
+                didExecuteGadgets = true;
+                if (processedEvent.result.breaksLoop) {
+                  shouldBreakLoop = true;
+                }
               }
             }
           }
-          const finalPendingEvents = await this.processPendingGadgets();
-          outputs.push(...finalPendingEvents);
-          if (finalPendingEvents.some((e) => e.type === "gadget_result")) {
-            didExecuteGadgets = true;
-          }
-          for (const evt of finalPendingEvents) {
-            if (evt.type === "gadget_result" && evt.result.breaksLoop) {
-              shouldBreakLoop = true;
+          for await (const evt of this.processPendingGadgetsGenerator()) {
+            yield evt;
+            if (evt.type === "gadget_result") {
+              didExecuteGadgets = true;
+              if (evt.result.breaksLoop) {
+                shouldBreakLoop = true;
+              }
             }
           }
         }
@@ -3990,8 +3997,8 @@ var init_stream_processor = __esm({
           };
           finalMessage = this.hooks.interceptors.interceptAssistantMessage(finalMessage, context);
         }
-        return {
-          outputs,
+        const completionEvent = {
+          type: "stream_complete",
           shouldBreakLoop,
           didExecuteGadgets,
           finishReason,
@@ -3999,9 +4006,11 @@ var init_stream_processor = __esm({
           rawResponse: this.responseText,
           finalMessage
         };
+        yield completionEvent;
       }
       /**
        * Process a single parsed event (text or gadget call).
+       * @deprecated Use processEventGenerator for real-time streaming
        */
       async processEvent(event) {
         if (event.type === "text") {
@@ -4011,6 +4020,23 @@ var init_stream_processor = __esm({
         }
         return [event];
       }
+      /**
+       * Process a single parsed event, yielding events in real-time.
+       * Generator version of processEvent for streaming support.
+       */
+      async *processEventGenerator(event) {
+        if (event.type === "text") {
+          for (const e of await this.processTextEvent(event)) {
+            yield e;
+          }
+        } else if (event.type === "gadget_call") {
+          for await (const e of this.processGadgetCallGenerator(event.call)) {
+            yield e;
+          }
+        } else {
+          yield event;
+        }
+      }
       /**
        * Process a text event through interceptors.
        */
@@ -4087,9 +4113,68 @@ var init_stream_processor = __esm({
         events.push(...triggeredEvents);
         return events;
       }
+      /**
+       * Process a gadget call, yielding events in real-time.
+       *
+       * Key difference from processGadgetCall: yields gadget_call event IMMEDIATELY
+       * when parsed (before execution), enabling real-time UI feedback.
+       */
+      async *processGadgetCallGenerator(call) {
+        if (this.executionHalted) {
+          this.logger.debug("Skipping gadget execution due to previous error", {
+            gadgetName: call.gadgetName
+          });
+          return;
+        }
+        yield { type: "gadget_call", call };
+        if (call.dependencies.length > 0) {
+          if (call.dependencies.includes(call.invocationId)) {
+            this.logger.warn("Gadget has self-referential dependency (depends on itself)", {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId
+            });
+            this.failedInvocations.add(call.invocationId);
+            const skipEvent = {
+              type: "gadget_skipped",
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: call.invocationId,
+              failedDependencyError: `Gadget "${call.invocationId}" cannot depend on itself (self-referential dependency)`
+            };
+            yield skipEvent;
+            return;
+          }
+          const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+          if (failedDep) {
+            const skipEvents = await this.handleFailedDependency(call, failedDep);
+            for (const evt of skipEvents) {
+              yield evt;
+            }
+            return;
+          }
+          const unsatisfied = call.dependencies.filter((dep) => !this.completedResults.has(dep));
+          if (unsatisfied.length > 0) {
+            this.logger.debug("Queueing gadget for later - waiting on dependencies", {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              waitingOn: unsatisfied
+            });
+            this.gadgetsAwaitingDependencies.set(call.invocationId, call);
+            return;
+          }
+        }
+        for await (const evt of this.executeGadgetGenerator(call)) {
+          yield evt;
+        }
+        for await (const evt of this.processPendingGadgetsGenerator()) {
+          yield evt;
+        }
+      }
       /**
        * Execute a gadget through the full hook lifecycle.
        * This is the core execution logic, extracted from processGadgetCall.
+       * @deprecated Use executeGadgetGenerator for real-time streaming
        */
       async executeGadgetWithHooks(call) {
         const events = [];
@@ -4242,6 +4327,159 @@ var init_stream_processor = __esm({
         }
         return events;
       }
+      /**
+       * Execute a gadget and yield the result event.
+       * Generator version that yields gadget_result immediately when execution completes.
+       */
+      async *executeGadgetGenerator(call) {
+        if (call.parseError) {
+          this.logger.warn("Gadget has parse error", {
+            gadgetName: call.gadgetName,
+            error: call.parseError,
+            rawParameters: call.parametersRaw
+          });
+          const shouldContinue = await this.checkCanRecoverFromError(
+            call.parseError,
+            call.gadgetName,
+            "parse",
+            call.parameters
+          );
+          if (!shouldContinue) {
+            this.executionHalted = true;
+          }
+        }
+        let parameters = call.parameters ?? {};
+        if (this.hooks.interceptors?.interceptGadgetParameters) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            logger: this.logger
+          };
+          parameters = this.hooks.interceptors.interceptGadgetParameters(parameters, context);
+        }
+        call.parameters = parameters;
+        let shouldSkip = false;
+        let syntheticResult;
+        if (this.hooks.controllers?.beforeGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.beforeGadgetExecution(context);
+          validateBeforeGadgetExecutionAction(action);
+          if (action.action === "skip") {
+            shouldSkip = true;
+            syntheticResult = action.syntheticResult;
+            this.logger.info("Controller skipped gadget execution", {
+              gadgetName: call.gadgetName
+            });
+          }
+        }
+        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);
+        let result;
+        if (shouldSkip) {
+          result = {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            result: syntheticResult ?? "Execution skipped",
+            executionTimeMs: 0
+          };
+        } else {
+          result = await this.executor.execute(call);
+        }
+        const originalResult = result.result;
+        if (result.result && this.hooks.interceptors?.interceptGadgetResult) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          result.result = this.hooks.interceptors.interceptGadgetResult(result.result, context);
+        }
+        if (this.hooks.controllers?.afterGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            result: result.result,
+            error: result.error,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.afterGadgetExecution(context);
+          validateAfterGadgetExecutionAction(action);
+          if (action.action === "recover" && result.error) {
+            this.logger.info("Controller recovered from gadget error", {
+              gadgetName: result.gadgetName,
+              originalError: result.error
+            });
+            result = {
+              ...result,
+              error: void 0,
+              result: action.fallbackResult
+            };
+          }
+        }
+        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);
+        this.completedResults.set(result.invocationId, result);
+        if (result.error) {
+          this.failedInvocations.add(result.invocationId);
+        }
+        yield { type: "gadget_result", result };
+        if (result.error) {
+          const errorType = this.determineErrorType(call, result);
+          const shouldContinue = await this.checkCanRecoverFromError(
+            result.error,
+            result.gadgetName,
+            errorType,
+            result.parameters
+          );
+          if (!shouldContinue) {
+            this.executionHalted = true;
+          }
+        }
+      }
       /**
        * Handle a gadget that cannot execute because a dependency failed.
        * Calls the onDependencySkipped controller to allow customization.
@@ -4398,6 +4636,99 @@ var init_stream_processor = __esm({
         }
         return events;
       }
+      /**
+       * Process pending gadgets, yielding events in real-time.
+       * Generator version that yields events as gadgets complete.
+       *
+       * Note: Gadgets are still executed in parallel for efficiency,
+       * but results are yielded as they become available.
+       */
+      async *processPendingGadgetsGenerator() {
+        let progress = true;
+        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
+          progress = false;
+          const readyToExecute = [];
+          const readyToSkip = [];
+          for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
+            const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+            if (failedDep) {
+              readyToSkip.push({ call, failedDep });
+              continue;
+            }
+            const allSatisfied = call.dependencies.every((dep) => this.completedResults.has(dep));
+            if (allSatisfied) {
+              readyToExecute.push(call);
+            }
+          }
+          for (const { call, failedDep } of readyToSkip) {
+            this.gadgetsAwaitingDependencies.delete(call.invocationId);
+            const skipEvents = await this.handleFailedDependency(call, failedDep);
+            for (const evt of skipEvents) {
+              yield evt;
+            }
+            progress = true;
+          }
+          if (readyToExecute.length > 0) {
+            this.logger.debug("Executing ready gadgets in parallel", {
+              count: readyToExecute.length,
+              invocationIds: readyToExecute.map((c) => c.invocationId)
+            });
+            for (const call of readyToExecute) {
+              this.gadgetsAwaitingDependencies.delete(call.invocationId);
+            }
+            const eventSets = await Promise.all(
+              readyToExecute.map(async (call) => {
+                const events = [];
+                for await (const evt of this.executeGadgetGenerator(call)) {
+                  events.push(evt);
+                }
+                return events;
+              })
+            );
+            for (const events of eventSets) {
+              for (const evt of events) {
+                yield evt;
+              }
+            }
+            progress = true;
+          }
+        }
+        if (this.gadgetsAwaitingDependencies.size > 0) {
+          const pendingIds = new Set(this.gadgetsAwaitingDependencies.keys());
+          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
+            const missingDeps = call.dependencies.filter((dep) => !this.completedResults.has(dep));
+            const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
+            const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
+            let errorMessage;
+            let logLevel = "warn";
+            if (circularDeps.length > 0 && trulyMissingDeps.length > 0) {
+              errorMessage = `Dependencies unresolvable: circular=[${circularDeps.join(", ")}], missing=[${trulyMissingDeps.join(", ")}]`;
+              logLevel = "error";
+            } else if (circularDeps.length > 0) {
+              errorMessage = `Circular dependency detected: "${invocationId}" depends on "${circularDeps[0]}" which also depends on "${invocationId}" (directly or indirectly)`;
+            } else {
+              errorMessage = `Dependency "${missingDeps[0]}" was never executed - check that the invocation ID exists and is spelled correctly`;
+            }
+            this.logger[logLevel]("Gadget has unresolvable dependencies", {
+              gadgetName: call.gadgetName,
+              invocationId,
+              circularDependencies: circularDeps,
+              missingDependencies: trulyMissingDeps
+            });
+            this.failedInvocations.add(invocationId);
+            const skipEvent = {
+              type: "gadget_skipped",
+              gadgetName: call.gadgetName,
+              invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: missingDeps[0],
+              failedDependencyError: errorMessage
+            };
+            yield skipEvent;
+          }
+          this.gadgetsAwaitingDependencies.clear();
+        }
+      }
       /**
        * Safely execute an observer, catching and logging any errors.
        * Observers are non-critical, so errors are logged but don't crash the system.
@@ -4520,6 +4851,8 @@ var init_agent = __esm({
       // Subagent configuration
       agentContextConfig;
       subagentConfig;
+      // Nested event callback for subagent gadgets
+      onNestedEvent;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -4597,6 +4930,7 @@ var init_agent = __esm({
           temperature: this.temperature
         };
         this.subagentConfig = options.subagentConfig;
+        this.onNestedEvent = options.onNestedEvent;
       }
       /**
        * Get the gadget registry for this agent.
@@ -4827,12 +5161,30 @@ var init_agent = __esm({
               client: this.client,
               mediaStore: this.mediaStore,
               agentConfig: this.agentContextConfig,
-              subagentConfig: this.subagentConfig
+              subagentConfig: this.subagentConfig,
+              onNestedEvent: this.onNestedEvent
             });
-            const result = await processor.process(stream2);
-            for (const output of result.outputs) {
-              yield output;
+            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;
+            }
+            if (!streamMetadata) {
+              throw new Error("Stream processing completed without metadata event");
             }
+            const result = streamMetadata;
             this.logger.info("LLM response completed", {
               finishReason: result.finishReason,
               usage: result.usage,
@@ -4857,9 +5209,6 @@ var init_agent = __esm({
             });
             let finalMessage = result.finalMessage;
             if (this.hooks.controllers?.afterLLMCall) {
-              const gadgetCallCount = result.outputs.filter(
-                (output) => output.type === "gadget_result"
-              ).length;
               const context = {
                 iteration: currentIteration,
                 maxIterations: this.maxIterations,
@@ -4889,9 +5238,7 @@ var init_agent = __esm({
             }
             if (result.didExecuteGadgets) {
               if (this.textWithGadgetsHandler) {
-                const textContent = result.outputs.filter(
-                  (output) => output.type === "text"
-                ).map((output) => output.content).join("");
+                const textContent = textOutputs.join("");
                 if (textContent.trim()) {
                   const { gadgetName, parameterMapping, resultMapping } = this.textWithGadgetsHandler;
                   this.conversation.addGadgetCallResult(
@@ -4901,7 +5248,7 @@ var init_agent = __esm({
                   );
                 }
               }
-              for (const output of result.outputs) {
+              for (const output of gadgetResults) {
                 if (output.type === "gadget_result") {
                   const gadgetResult = output.result;
                   this.conversation.addGadgetCallResult(
@@ -8409,6 +8756,8 @@ var init_builder = __esm({
       signal;
       trailingMessage;
       subagentConfig;
+      nestedEventCallback;
+      parentContext;
       constructor(client) {
         this.client = client;
       }
@@ -8905,6 +9254,74 @@ var init_builder = __esm({
         this.subagentConfig = config;
         return this;
       }
+      /**
+       * Set the callback for nested subagent events.
+       *
+       * Subagent gadgets (like BrowseWeb) can use ExecutionContext.onNestedEvent
+       * to report their internal LLM calls and gadget executions in real-time.
+       * This callback receives those events, enabling hierarchical progress display.
+       *
+       * @param callback - Function to handle nested agent events
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withNestedEventCallback((event) => {
+       *   if (event.type === "llm_call_start") {
+       *     console.log(`  Nested LLM #${event.event.iteration} starting...`);
+       *   } else if (event.type === "gadget_call") {
+       *     console.log(`    ⏵ ${event.event.call.gadgetName}...`);
+       *   }
+       * })
+       * ```
+       */
+      withNestedEventCallback(callback) {
+        this.nestedEventCallback = callback;
+        return this;
+      }
+      /**
+       * Enable automatic nested event forwarding to parent agent.
+       *
+       * When building a subagent inside a gadget, call this method to automatically
+       * forward all LLM calls and gadget events to the parent agent. This enables
+       * hierarchical progress display without any manual event handling.
+       *
+       * The method extracts `invocationId` and `onNestedEvent` from the execution
+       * context and sets up automatic forwarding via hooks and event wrapping.
+       *
+       * @param ctx - ExecutionContext passed to the gadget's execute() method
+       * @param depth - Nesting depth (default: 1 for direct child)
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // In a subagent gadget like BrowseWeb - ONE LINE enables auto-forwarding:
+       * execute: async (params, ctx) => {
+       *   const agent = new AgentBuilder(client)
+       *     .withModel(model)
+       *     .withGadgets(Navigate, Click, Screenshot)
+       *     .withParentContext(ctx)  // <-- This is all you need!
+       *     .ask(params.task);
+       *
+       *   for await (const event of agent.run()) {
+       *     // Events automatically forwarded - just process normally
+       *     if (event.type === "text") {
+       *       result = event.content;
+       *     }
+       *   }
+       * }
+       * ```
+       */
+      withParentContext(ctx, depth = 1) {
+        if (ctx.onNestedEvent && ctx.invocationId) {
+          this.parentContext = {
+            invocationId: ctx.invocationId,
+            onNestedEvent: ctx.onNestedEvent,
+            depth
+          };
+        }
+        return this;
+      }
       /**
        * Add an ephemeral trailing message that appears at the end of each LLM request.
        *
@@ -8972,14 +9389,58 @@ ${endPrefix}`
         return this;
       }
       /**
-       * Compose the final hooks, including trailing message if configured.
+       * Compose the final hooks, including:
+       * - Trailing message injection (if configured)
+       * - Nested event forwarding for LLM calls (if parentContext is set)
        */
       composeHooks() {
+        let hooks = this.hooks;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent, depth } = this.parentContext;
+          const existingOnLLMCallStart = hooks?.observers?.onLLMCallStart;
+          const existingOnLLMCallComplete = hooks?.observers?.onLLMCallComplete;
+          hooks = {
+            ...hooks,
+            observers: {
+              ...hooks?.observers,
+              onLLMCallStart: async (context) => {
+                onNestedEvent({
+                  type: "llm_call_start",
+                  gadgetInvocationId: invocationId,
+                  depth,
+                  event: {
+                    iteration: context.iteration,
+                    model: context.options.model
+                  }
+                });
+                if (existingOnLLMCallStart) {
+                  await existingOnLLMCallStart(context);
+                }
+              },
+              onLLMCallComplete: async (context) => {
+                onNestedEvent({
+                  type: "llm_call_end",
+                  gadgetInvocationId: invocationId,
+                  depth,
+                  event: {
+                    iteration: context.iteration,
+                    model: context.options.model,
+                    outputTokens: context.usage?.outputTokens,
+                    finishReason: context.finishReason
+                  }
+                });
+                if (existingOnLLMCallComplete) {
+                  await existingOnLLMCallComplete(context);
+                }
+              }
+            }
+          };
+        }
         if (!this.trailingMessage) {
-          return this.hooks;
+          return hooks;
         }
         const trailingMsg = this.trailingMessage;
-        const existingBeforeLLMCall = this.hooks?.controllers?.beforeLLMCall;
+        const existingBeforeLLMCall = hooks?.controllers?.beforeLLMCall;
         const trailingMessageController = async (ctx) => {
           const result = existingBeforeLLMCall ? await existingBeforeLLMCall(ctx) : { action: "proceed" };
           if (result.action === "skip") {
@@ -8994,9 +9455,9 @@ ${endPrefix}`
           };
         };
         return {
-          ...this.hooks,
+          ...hooks,
           controllers: {
-            ...this.hooks?.controllers,
+            ...hooks?.controllers,
             beforeLLMCall: trailingMessageController
           }
         };
@@ -9057,6 +9518,19 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
+        let onNestedEvent = this.nestedEventCallback;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent: parentCallback, depth } = this.parentContext;
+          const existingCallback = this.nestedEventCallback;
+          onNestedEvent = (event) => {
+            parentCallback({
+              ...event,
+              gadgetInvocationId: invocationId,
+              depth: event.depth + depth
+            });
+            existingCallback?.(event);
+          };
+        }
         return {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -9082,7 +9556,8 @@ ${endPrefix}`
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           signal: this.signal,
-          subagentConfig: this.subagentConfig
+          subagentConfig: this.subagentConfig,
+          onNestedEvent
         };
       }
       ask(userPrompt) {
@@ -9239,6 +9714,19 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
+        let onNestedEvent = this.nestedEventCallback;
+        if (this.parentContext) {
+          const { invocationId, onNestedEvent: parentCallback, depth } = this.parentContext;
+          const existingCallback = this.nestedEventCallback;
+          onNestedEvent = (event) => {
+            parentCallback({
+              ...event,
+              gadgetInvocationId: invocationId,
+              depth: event.depth + depth
+            });
+            existingCallback?.(event);
+          };
+        }
         const options = {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -9264,7 +9752,8 @@ ${endPrefix}`
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           signal: this.signal,
-          subagentConfig: this.subagentConfig
+          subagentConfig: this.subagentConfig,
+          onNestedEvent
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -12420,7 +12909,9 @@ function formatMediaLine(media) {
 }
 function formatGadgetSummary2(result) {
   const gadgetLabel = import_chalk3.default.magenta.bold(result.gadgetName);
-  const timeLabel = import_chalk3.default.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const timeLabel = import_chalk3.default.dim(
+    result.executionTimeMs >= 1e3 ? `${(result.executionTimeMs / 1e3).toFixed(1)}s` : `${Math.round(result.executionTimeMs)}ms`
+  );
   const paramsStr = formatParametersInline(result.parameters);
   const paramsLabel = paramsStr ? `${import_chalk3.default.dim("(")}${paramsStr}${import_chalk3.default.dim(")")}` : "";
   if (result.error) {
@@ -12588,6 +13079,8 @@ var StreamProgress = class {
   delayTimeout = null;
   isRunning = false;
   hasRendered = false;
+  lastRenderLineCount = 0;
+  // Track lines rendered for multi-line clearing
   // Current call stats (streaming mode)
   mode = "cumulative";
   model = "";
@@ -12607,6 +13100,99 @@ var StreamProgress = class {
   totalCost = 0;
   iterations = 0;
   currentIteration = 0;
+  // In-flight gadget tracking for concurrent status display
+  inFlightGadgets = /* @__PURE__ */ new Map();
+  // Nested agent tracking for hierarchical subagent display
+  nestedAgents = /* @__PURE__ */ new Map();
+  // Nested gadget tracking for hierarchical subagent display
+  nestedGadgets = /* @__PURE__ */ new Map();
+  /**
+   * Add a gadget to the in-flight tracking (called when gadget_call event received).
+   * Triggers re-render to show the gadget in the status display.
+   */
+  addGadget(invocationId, name, params) {
+    this.inFlightGadgets.set(invocationId, { name, params, startTime: Date.now() });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Remove a gadget from in-flight tracking (called when gadget_result event received).
+   * Triggers re-render to update the status display.
+   */
+  removeGadget(invocationId) {
+    this.inFlightGadgets.delete(invocationId);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Check if there are any gadgets currently in flight.
+   */
+  hasInFlightGadgets() {
+    return this.inFlightGadgets.size > 0;
+  }
+  /**
+   * Add a nested agent LLM call (called when nested llm_call_start event received).
+   * Used to display hierarchical progress for subagent gadgets.
+   */
+  addNestedAgent(id, parentInvocationId, depth, model, iteration, inputTokens) {
+    this.nestedAgents.set(id, {
+      parentInvocationId,
+      depth,
+      model,
+      iteration,
+      startTime: Date.now(),
+      inputTokens
+    });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Update a nested agent with completion info (called when nested llm_call_end event received).
+   */
+  updateNestedAgent(id, outputTokens) {
+    const agent = this.nestedAgents.get(id);
+    if (agent) {
+      agent.outputTokens = outputTokens;
+      if (this.isRunning && this.isTTY) {
+        this.render();
+      }
+    }
+  }
+  /**
+   * Remove a nested agent (called when the nested LLM call completes).
+   */
+  removeNestedAgent(id) {
+    this.nestedAgents.delete(id);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Add a nested gadget call (called when nested gadget_call event received).
+   */
+  addNestedGadget(id, depth, parentInvocationId, name) {
+    this.nestedGadgets.set(id, {
+      depth,
+      parentInvocationId,
+      name,
+      startTime: Date.now()
+    });
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
+  /**
+   * Remove a nested gadget (called when nested gadget_result event received).
+   */
+  removeNestedGadget(id) {
+    this.nestedGadgets.delete(id);
+    if (this.isRunning && this.isTTY) {
+      this.render();
+    }
+  }
   /**
    * Starts a new LLM call. Switches to streaming mode.
    * @param model - Model name being used
@@ -12733,15 +13319,57 @@ var StreamProgress = class {
     this.isStreaming = true;
   }
   render() {
+    this.clearRenderedLines();
     const spinner = SPINNER_FRAMES[this.frameIndex++ % SPINNER_FRAMES.length];
+    const lines = [];
     if (this.mode === "streaming") {
-      this.renderStreamingMode(spinner);
+      lines.push(this.formatStreamingLine(spinner));
     } else {
-      this.renderCumulativeMode(spinner);
-    }
+      lines.push(this.formatCumulativeLine(spinner));
+    }
+    if (this.isTTY) {
+      for (const [gadgetId, gadget] of this.inFlightGadgets) {
+        const elapsed = ((Date.now() - gadget.startTime) / 1e3).toFixed(1);
+        const gadgetLine = `  ${import_chalk4.default.blue("\u23F5")} ${import_chalk4.default.magenta.bold(gadget.name)}${import_chalk4.default.dim("(...)")} ${import_chalk4.default.dim(elapsed + "s")}`;
+        lines.push(gadgetLine);
+        for (const [_agentId, nested] of this.nestedAgents) {
+          if (nested.parentInvocationId !== gadgetId) continue;
+          const indent = "  ".repeat(nested.depth + 1);
+          const nestedElapsed = ((Date.now() - nested.startTime) / 1e3).toFixed(1);
+          const tokens = nested.inputTokens ? ` ${import_chalk4.default.dim("\u2191")}${import_chalk4.default.yellow(formatTokens(nested.inputTokens))}` : "";
+          const outTokens = nested.outputTokens ? ` ${import_chalk4.default.dim("\u2193")}${import_chalk4.default.green(formatTokens(nested.outputTokens))}` : "";
+          const nestedLine = `${indent}${import_chalk4.default.cyan(`#${nested.iteration}`)} ${import_chalk4.default.dim(nested.model)}${tokens}${outTokens} ${import_chalk4.default.dim(nestedElapsed + "s")} ${import_chalk4.default.cyan(spinner)}`;
+          lines.push(nestedLine);
+        }
+        for (const [_nestedId, nestedGadget] of this.nestedGadgets) {
+          if (nestedGadget.parentInvocationId === gadgetId) {
+            const indent = "  ".repeat(nestedGadget.depth + 1);
+            const nestedElapsed = ((Date.now() - nestedGadget.startTime) / 1e3).toFixed(1);
+            const nestedGadgetLine = `${indent}${import_chalk4.default.blue("\u23F5")} ${import_chalk4.default.dim(nestedGadget.name + "(...)")} ${import_chalk4.default.dim(nestedElapsed + "s")}`;
+            lines.push(nestedGadgetLine);
+          }
+        }
+      }
+    }
+    this.lastRenderLineCount = lines.length;
+    this.target.write("\r" + lines.join("\n"));
     this.hasRendered = true;
   }
-  renderStreamingMode(spinner) {
+  /**
+   * Clears the previously rendered lines (for multi-line status display).
+   */
+  clearRenderedLines() {
+    if (!this.hasRendered || this.lastRenderLineCount === 0) return;
+    this.target.write("\r\x1B[K");
+    for (let i = 1; i < this.lastRenderLineCount; i++) {
+      this.target.write("\x1B[1A\x1B[K");
+    }
+    this.target.write("\r");
+  }
+  /**
+   * Format the streaming mode progress line (returns string, doesn't write).
+   */
+  formatStreamingLine(spinner) {
     const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
     const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
     const parts = [];
@@ -12775,7 +13403,7 @@ var StreamProgress = class {
     if (callCost > 0) {
       parts.push(import_chalk4.default.cyan(`$${formatCost(callCost)}`));
     }
-    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
+    return `${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`;
   }
   /**
    * Calculates live cost estimate for the current streaming call.
@@ -12812,7 +13440,10 @@ var StreamProgress = class {
     }
     return this.callInputTokens / limits.contextWindow * 100;
   }
-  renderCumulativeMode(spinner) {
+  /**
+   * Format the cumulative mode progress line (returns string, doesn't write).
+   */
+  formatCumulativeLine(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
     if (this.model) {
@@ -12828,10 +13459,10 @@ var StreamProgress = class {
       parts.push(import_chalk4.default.dim("cost:") + import_chalk4.default.cyan(` $${formatCost(this.totalCost)}`));
     }
     parts.push(import_chalk4.default.dim(`${elapsed}s`));
-    this.target.write(`\r${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`);
+    return `${parts.join(import_chalk4.default.dim(" | "))} ${import_chalk4.default.cyan(spinner)}`;
   }
   /**
-   * Pauses the progress indicator and clears the line.
+   * Pauses the progress indicator and clears all rendered lines.
    * Can be resumed with start().
    */
   pause() {
@@ -12845,10 +13476,9 @@ var StreamProgress = class {
       this.interval = null;
     }
     this.isRunning = false;
-    if (this.hasRendered) {
-      this.target.write("\r\x1B[K\x1B[0G");
-      this.hasRendered = false;
-    }
+    this.clearRenderedLines();
+    this.hasRendered = false;
+    this.lastRenderLineCount = 0;
   }
   /**
    * Completes the progress indicator and clears the line.
@@ -13425,6 +14055,38 @@ Denied: ${result.reason ?? "by user"}`
       "Maximize efficiency by batching independent operations in a single response."
     ].join(" ")
   );
+  if (!options.quiet) {
+    builder.withNestedEventCallback((event) => {
+      if (event.type === "llm_call_start") {
+        const info = event.event;
+        const nestedId = `${event.gadgetInvocationId}:${info.iteration}`;
+        progress.addNestedAgent(
+          nestedId,
+          event.gadgetInvocationId,
+          event.depth,
+          info.model,
+          info.iteration,
+          info.inputTokens
+        );
+      } else if (event.type === "llm_call_end") {
+        const info = event.event;
+        const nestedId = `${event.gadgetInvocationId}:${info.iteration}`;
+        progress.updateNestedAgent(nestedId, info.outputTokens);
+        setTimeout(() => progress.removeNestedAgent(nestedId), 100);
+      } else if (event.type === "gadget_call") {
+        const gadgetEvent = event.event;
+        progress.addNestedGadget(
+          gadgetEvent.call.invocationId,
+          event.depth,
+          event.gadgetInvocationId,
+          gadgetEvent.call.gadgetName
+        );
+      } else if (event.type === "gadget_result") {
+        const resultEvent = event.event;
+        progress.removeNestedGadget(resultEvent.result.invocationId);
+      }
+    });
+  }
   let agent;
   if (options.image || options.audio) {
     const parts = [text(prompt)];
@@ -13449,10 +14111,22 @@ Denied: ${result.reason ?? "by user"}`
   try {
     for await (const event of agent.run()) {
       if (event.type === "text") {
-        progress.pause();
         textBuffer += event.content;
+      } else if (event.type === "gadget_call") {
+        flushTextBuffer();
+        if (!options.quiet) {
+          progress.addGadget(
+            event.call.invocationId,
+            event.call.gadgetName,
+            event.call.parameters
+          );
+          progress.start();
+        }
       } else if (event.type === "gadget_result") {
         flushTextBuffer();
+        if (!options.quiet) {
+          progress.removeGadget(event.result.invocationId);
+        }
         progress.pause();
         if (options.quiet) {
           if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
@@ -13467,6 +14141,9 @@ Denied: ${result.reason ?? "by user"}`
 `
           );
         }
+        if (progress.hasInFlightGadgets()) {
+          progress.start();
+        }
       }
     }
   } catch (error) {