llmist 6.0.0 → 6.2.0

package/dist/{chunk-EIE5VRSI.js → chunk-36YSBSGB.js}

@@ -690,23 +690,26 @@ Produces: { "items": ["first", "second"] }`);
        * Record a gadget execution result in the message history.
        * Creates an assistant message with the gadget invocation and a user message with the result.
        *
+       * The invocationId is shown to the LLM so it can reference previous calls when building dependencies.
+       *
        * @param gadget - Name of the gadget that was executed
        * @param parameters - Parameters that were passed to the gadget
        * @param result - Text result from the gadget execution
+       * @param invocationId - Invocation ID (shown to LLM so it can reference for dependencies)
        * @param media - Optional media outputs from the gadget
        * @param mediaIds - Optional IDs for the media outputs
        */
-      addGadgetCallResult(gadget, parameters, result, media, mediaIds) {
+      addGadgetCallResult(gadget, parameters, result, invocationId, media, mediaIds) {
         const paramStr = this.formatBlockParameters(parameters, "");
         this.messages.push({
           role: "assistant",
-          content: `${this.startPrefix}${gadget}
+          content: `${this.startPrefix}${gadget}:${invocationId}
 ${paramStr}
 ${this.endPrefix}`
         });
         if (media && media.length > 0 && mediaIds && mediaIds.length > 0) {
           const idRefs = media.map((m, i) => `[Media: ${mediaIds[i]} (${m.kind})]`).join("\n");
-          const textWithIds = `Result: ${result}
+          const textWithIds = `Result (${invocationId}): ${result}
 ${idRefs}`;
           const parts = [text(textWithIds)];
           for (const item of media) {
@@ -720,7 +723,7 @@ ${idRefs}`;
         } else {
           this.messages.push({
             role: "user",
-            content: `Result: ${result}`
+            content: `Result (${invocationId}): ${result}`
           });
         }
         return this;
@@ -1072,6 +1075,611 @@ var init_registry = __esm({
   }
 });
 
+// src/core/execution-tree.ts
+var ExecutionTree;
+var init_execution_tree = __esm({
+  "src/core/execution-tree.ts"() {
+    "use strict";
+    ExecutionTree = class {
+      nodes = /* @__PURE__ */ new Map();
+      rootIds = [];
+      eventListeners = /* @__PURE__ */ new Map();
+      eventIdCounter = 0;
+      invocationIdToNodeId = /* @__PURE__ */ new Map();
+      // For async event streaming
+      eventQueue = [];
+      eventWaiters = [];
+      isCompleted = false;
+      /**
+       * Base depth for all nodes in this tree.
+       * Used when this tree is a subagent's view into a parent tree.
+       */
+      baseDepth;
+      /**
+       * Parent node ID for subagent trees.
+       * All root nodes in this tree will have this as their parentId.
+       */
+      parentNodeId;
+      constructor(options) {
+        this.baseDepth = options?.baseDepth ?? 0;
+        this.parentNodeId = options?.parentNodeId ?? null;
+      }
+      // ===========================================================================
+      // Node ID Generation
+      // ===========================================================================
+      generateLLMCallId(iteration, parentId) {
+        if (parentId) {
+          return `llm_${parentId}_${iteration}`;
+        }
+        return `llm_${iteration}`;
+      }
+      gadgetIdCounter = 0;
+      generateGadgetId(invocationId) {
+        return `gadget_${invocationId}_${++this.gadgetIdCounter}`;
+      }
+      // ===========================================================================
+      // Event Emission
+      // ===========================================================================
+      emit(event) {
+        const listeners = this.eventListeners.get(event.type);
+        if (listeners) {
+          for (const listener of listeners) {
+            try {
+              listener(event);
+            } catch (error) {
+              console.error(`Error in event listener for ${event.type}:`, error);
+            }
+          }
+        }
+        const allListeners = this.eventListeners.get("*");
+        if (allListeners) {
+          for (const listener of allListeners) {
+            try {
+              listener(event);
+            } catch (error) {
+              console.error("Error in wildcard event listener:", error);
+            }
+          }
+        }
+        if (this.eventWaiters.length > 0) {
+          const waiter = this.eventWaiters.shift();
+          if (waiter) waiter(event);
+        } else {
+          this.eventQueue.push(event);
+        }
+      }
+      createBaseEventProps(node) {
+        return {
+          eventId: ++this.eventIdCounter,
+          timestamp: Date.now(),
+          nodeId: node.id,
+          parentId: node.parentId,
+          depth: node.depth,
+          path: node.path
+        };
+      }
+      // ===========================================================================
+      // Node Creation
+      // ===========================================================================
+      /**
+       * Add a new LLM call node to the tree.
+       */
+      addLLMCall(params) {
+        const parentId = params.parentId ?? this.parentNodeId;
+        const parent = parentId ? this.nodes.get(parentId) : null;
+        const depth = parent ? parent.depth + 1 : this.baseDepth;
+        const path = parent ? [...parent.path] : [];
+        const id = this.generateLLMCallId(params.iteration, parentId);
+        path.push(id);
+        const node = {
+          id,
+          type: "llm_call",
+          parentId,
+          depth,
+          path,
+          createdAt: Date.now(),
+          completedAt: null,
+          iteration: params.iteration,
+          model: params.model,
+          request: params.request,
+          response: "",
+          children: []
+        };
+        this.nodes.set(id, node);
+        if (!parentId) {
+          this.rootIds.push(id);
+        } else if (parent) {
+          parent.children.push(id);
+        }
+        this.emit({
+          type: "llm_call_start",
+          ...this.createBaseEventProps(node),
+          iteration: node.iteration,
+          model: node.model,
+          request: node.request
+        });
+        return node;
+      }
+      /**
+       * Add text to an LLM call's response (for streaming).
+       */
+      appendLLMResponse(nodeId, chunk) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "llm_call") {
+          throw new Error(`LLM call node not found: ${nodeId}`);
+        }
+        node.response += chunk;
+        this.emit({
+          type: "llm_call_stream",
+          ...this.createBaseEventProps(node),
+          chunk
+        });
+      }
+      /**
+       * Complete an LLM call node.
+       */
+      completeLLMCall(nodeId, params) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "llm_call") {
+          throw new Error(`LLM call node not found: ${nodeId}`);
+        }
+        const llmNode = node;
+        llmNode.completedAt = Date.now();
+        if (params.response !== void 0) llmNode.response = params.response;
+        if (params.usage) llmNode.usage = params.usage;
+        if (params.finishReason !== void 0) llmNode.finishReason = params.finishReason;
+        if (params.cost !== void 0) llmNode.cost = params.cost;
+        this.emit({
+          type: "llm_call_complete",
+          ...this.createBaseEventProps(node),
+          response: llmNode.response,
+          usage: llmNode.usage,
+          finishReason: llmNode.finishReason,
+          cost: llmNode.cost
+        });
+      }
+      /**
+       * Mark an LLM call as failed.
+       */
+      failLLMCall(nodeId, error, recovered) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "llm_call") {
+          throw new Error(`LLM call node not found: ${nodeId}`);
+        }
+        const llmNode = node;
+        llmNode.completedAt = Date.now();
+        this.emit({
+          type: "llm_call_error",
+          ...this.createBaseEventProps(node),
+          error,
+          recovered
+        });
+      }
+      /**
+       * Add a new gadget node to the tree.
+       */
+      addGadget(params) {
+        const parentId = params.parentId ?? this.getCurrentLLMCallId() ?? this.parentNodeId;
+        const parent = parentId ? this.nodes.get(parentId) : null;
+        const depth = parent ? parent.depth + 1 : this.baseDepth;
+        const path = parent ? [...parent.path] : [];
+        const id = this.generateGadgetId(params.invocationId);
+        path.push(id);
+        const node = {
+          id,
+          type: "gadget",
+          parentId,
+          depth,
+          path,
+          createdAt: Date.now(),
+          completedAt: null,
+          invocationId: params.invocationId,
+          name: params.name,
+          parameters: params.parameters,
+          dependencies: params.dependencies ?? [],
+          state: "pending",
+          children: [],
+          isSubagent: false
+        };
+        this.nodes.set(id, node);
+        this.invocationIdToNodeId.set(params.invocationId, id);
+        if (parent) {
+          parent.children.push(id);
+        }
+        this.emit({
+          type: "gadget_call",
+          ...this.createBaseEventProps(node),
+          invocationId: node.invocationId,
+          name: node.name,
+          parameters: node.parameters,
+          dependencies: node.dependencies
+        });
+        return node;
+      }
+      /**
+       * Mark a gadget as started (running).
+       */
+      startGadget(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "gadget") {
+          throw new Error(`Gadget node not found: ${nodeId}`);
+        }
+        const gadgetNode = node;
+        gadgetNode.state = "running";
+        this.emit({
+          type: "gadget_start",
+          ...this.createBaseEventProps(node),
+          invocationId: gadgetNode.invocationId,
+          name: gadgetNode.name
+        });
+      }
+      /**
+       * Complete a gadget node successfully.
+       */
+      completeGadget(nodeId, params) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "gadget") {
+          throw new Error(`Gadget node not found: ${nodeId}`);
+        }
+        const gadgetNode = node;
+        gadgetNode.completedAt = Date.now();
+        gadgetNode.state = params.error ? "failed" : "completed";
+        if (params.result !== void 0) gadgetNode.result = params.result;
+        if (params.error) gadgetNode.error = params.error;
+        if (params.executionTimeMs !== void 0) gadgetNode.executionTimeMs = params.executionTimeMs;
+        if (params.cost !== void 0) gadgetNode.cost = params.cost;
+        if (params.media) gadgetNode.media = params.media;
+        gadgetNode.isSubagent = gadgetNode.children.some((childId) => {
+          const child = this.nodes.get(childId);
+          return child?.type === "llm_call";
+        });
+        if (params.error) {
+          this.emit({
+            type: "gadget_error",
+            ...this.createBaseEventProps(node),
+            invocationId: gadgetNode.invocationId,
+            name: gadgetNode.name,
+            error: params.error,
+            executionTimeMs: params.executionTimeMs ?? 0
+          });
+        } else {
+          this.emit({
+            type: "gadget_complete",
+            ...this.createBaseEventProps(node),
+            invocationId: gadgetNode.invocationId,
+            name: gadgetNode.name,
+            result: params.result ?? "",
+            executionTimeMs: params.executionTimeMs ?? 0,
+            cost: params.cost,
+            media: params.media
+          });
+        }
+      }
+      /**
+       * Mark a gadget as skipped due to dependency failure.
+       */
+      skipGadget(nodeId, failedDependency, failedDependencyError, reason) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "gadget") {
+          throw new Error(`Gadget node not found: ${nodeId}`);
+        }
+        const gadgetNode = node;
+        gadgetNode.completedAt = Date.now();
+        gadgetNode.state = "skipped";
+        gadgetNode.failedDependency = failedDependency;
+        gadgetNode.error = failedDependencyError;
+        const error = reason === "controller_skip" ? "Skipped by controller" : `Dependency ${failedDependency} failed: ${failedDependencyError}`;
+        this.emit({
+          type: "gadget_skipped",
+          ...this.createBaseEventProps(node),
+          invocationId: gadgetNode.invocationId,
+          name: gadgetNode.name,
+          reason,
+          error,
+          failedDependency,
+          failedDependencyError
+        });
+      }
+      // ===========================================================================
+      // Text Events (pure notifications, not tree nodes)
+      // ===========================================================================
+      /**
+       * Emit a text event (notification only, not stored in tree).
+       */
+      emitText(content, llmCallNodeId) {
+        const node = this.nodes.get(llmCallNodeId);
+        if (!node) {
+          throw new Error(`Node not found: ${llmCallNodeId}`);
+        }
+        this.emit({
+          type: "text",
+          ...this.createBaseEventProps(node),
+          content
+        });
+      }
+      // ===========================================================================
+      // Query Methods
+      // ===========================================================================
+      /**
+       * Get a node by ID.
+       */
+      getNode(id) {
+        return this.nodes.get(id);
+      }
+      /**
+       * Get a gadget node by invocation ID.
+       */
+      getNodeByInvocationId(invocationId) {
+        const nodeId = this.invocationIdToNodeId.get(invocationId);
+        if (!nodeId) return void 0;
+        const node = this.nodes.get(nodeId);
+        return node?.type === "gadget" ? node : void 0;
+      }
+      /**
+       * Get all root nodes (depth 0 for this tree).
+       */
+      getRoots() {
+        return this.rootIds.map((id) => this.nodes.get(id)).filter((node) => node !== void 0);
+      }
+      /**
+       * Get children of a node.
+       */
+      getChildren(id) {
+        const node = this.nodes.get(id);
+        if (!node) return [];
+        return node.children.map((childId) => this.nodes.get(childId)).filter((child) => child !== void 0);
+      }
+      /**
+       * Get ancestors of a node (from root to parent).
+       */
+      getAncestors(id) {
+        const node = this.nodes.get(id);
+        if (!node) return [];
+        const ancestors = [];
+        let currentId = node.parentId;
+        while (currentId) {
+          const ancestor = this.nodes.get(currentId);
+          if (ancestor) {
+            ancestors.unshift(ancestor);
+            currentId = ancestor.parentId;
+          } else {
+            break;
+          }
+        }
+        return ancestors;
+      }
+      /**
+       * Get all descendants of a node.
+       */
+      getDescendants(id, type) {
+        const node = this.nodes.get(id);
+        if (!node) return [];
+        const descendants = [];
+        const stack = [...node.children];
+        while (stack.length > 0) {
+          const childId = stack.pop();
+          const child = this.nodes.get(childId);
+          if (child) {
+            if (!type || child.type === type) {
+              descendants.push(child);
+            }
+            stack.push(...child.children);
+          }
+        }
+        return descendants;
+      }
+      /**
+       * Get the current (most recent incomplete) LLM call node.
+       */
+      getCurrentLLMCallId() {
+        for (let i = this.rootIds.length - 1; i >= 0; i--) {
+          const node = this.nodes.get(this.rootIds[i]);
+          if (node?.type === "llm_call" && !node.completedAt) {
+            return node.id;
+          }
+        }
+        return void 0;
+      }
+      // ===========================================================================
+      // Aggregation Methods (for subagent support)
+      // ===========================================================================
+      /**
+       * Get total cost for entire tree.
+       */
+      getTotalCost() {
+        let total = 0;
+        for (const node of this.nodes.values()) {
+          if (node.type === "llm_call" && node.cost) {
+            total += node.cost;
+          } else if (node.type === "gadget" && node.cost) {
+            total += node.cost;
+          }
+        }
+        return total;
+      }
+      /**
+       * Get total cost for a subtree (node and all descendants).
+       */
+      getSubtreeCost(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return 0;
+        let total = 0;
+        if (node.type === "llm_call" && node.cost) {
+          total += node.cost;
+        } else if (node.type === "gadget" && node.cost) {
+          total += node.cost;
+        }
+        for (const descendant of this.getDescendants(nodeId)) {
+          if (descendant.type === "llm_call" && descendant.cost) {
+            total += descendant.cost;
+          } else if (descendant.type === "gadget" && descendant.cost) {
+            total += descendant.cost;
+          }
+        }
+        return total;
+      }
+      /**
+       * Get token usage for entire tree.
+       */
+      getTotalTokens() {
+        let input = 0;
+        let output = 0;
+        let cached = 0;
+        for (const node of this.nodes.values()) {
+          if (node.type === "llm_call") {
+            const llmNode = node;
+            if (llmNode.usage) {
+              input += llmNode.usage.inputTokens;
+              output += llmNode.usage.outputTokens;
+              cached += llmNode.usage.cachedInputTokens ?? 0;
+            }
+          }
+        }
+        return { input, output, cached };
+      }
+      /**
+       * Get token usage for a subtree.
+       */
+      getSubtreeTokens(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return { input: 0, output: 0, cached: 0 };
+        let input = 0;
+        let output = 0;
+        let cached = 0;
+        const nodesToProcess = [node, ...this.getDescendants(nodeId)];
+        for (const n of nodesToProcess) {
+          if (n.type === "llm_call") {
+            const llmNode = n;
+            if (llmNode.usage) {
+              input += llmNode.usage.inputTokens;
+              output += llmNode.usage.outputTokens;
+              cached += llmNode.usage.cachedInputTokens ?? 0;
+            }
+          }
+        }
+        return { input, output, cached };
+      }
+      /**
+       * Collect all media from a subtree.
+       */
+      getSubtreeMedia(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return [];
+        const media = [];
+        const nodesToProcess = node.type === "gadget" ? [node] : [];
+        nodesToProcess.push(...this.getDescendants(nodeId, "gadget"));
+        for (const n of nodesToProcess) {
+          if (n.type === "gadget") {
+            const gadgetNode = n;
+            if (gadgetNode.media) {
+              media.push(...gadgetNode.media);
+            }
+          }
+        }
+        return media;
+      }
+      /**
+       * Check if a subtree is complete (all nodes finished).
+       */
+      isSubtreeComplete(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return true;
+        if (!node.completedAt) return false;
+        for (const descendant of this.getDescendants(nodeId)) {
+          if (!descendant.completedAt) return false;
+        }
+        return true;
+      }
+      /**
+       * Get node counts.
+       */
+      getNodeCount() {
+        let llmCalls = 0;
+        let gadgets = 0;
+        for (const node of this.nodes.values()) {
+          if (node.type === "llm_call") llmCalls++;
+          else if (node.type === "gadget") gadgets++;
+        }
+        return { llmCalls, gadgets };
+      }
+      // ===========================================================================
+      // Event Subscription
+      // ===========================================================================
+      /**
+       * Subscribe to events of a specific type.
+       * Returns unsubscribe function.
+       *
+       * @param type - Event type to subscribe to (use "*" for all events)
+       * @param listener - Callback function that receives matching events
+       * @returns Unsubscribe function
+       *
+       * @example
+       * ```typescript
+       * const unsubscribe = tree.on("gadget_complete", (event) => {
+       *   if (event.type === "gadget_complete") {
+       *     console.log(`Gadget ${event.name} completed`);
+       *   }
+       * });
+       * ```
+       */
+      on(type, listener) {
+        if (!this.eventListeners.has(type)) {
+          this.eventListeners.set(type, /* @__PURE__ */ new Set());
+        }
+        const listeners = this.eventListeners.get(type);
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      }
+      /**
+       * Subscribe to all events.
+       */
+      onAll(listener) {
+        return this.on("*", listener);
+      }
+      /**
+       * Get async iterable of all events.
+       * Events are yielded as they occur.
+       */
+      async *events() {
+        while (!this.isCompleted) {
+          while (this.eventQueue.length > 0) {
+            yield this.eventQueue.shift();
+          }
+          if (this.isCompleted) break;
+          const event = await new Promise((resolve) => {
+            if (this.eventQueue.length > 0) {
+              resolve(this.eventQueue.shift());
+            } else {
+              this.eventWaiters.push(resolve);
+            }
+          });
+          yield event;
+        }
+        while (this.eventQueue.length > 0) {
+          yield this.eventQueue.shift();
+        }
+      }
+      /**
+       * Mark the tree as complete (no more events will be emitted).
+       */
+      complete() {
+        this.isCompleted = true;
+        for (const waiter of this.eventWaiters) {
+        }
+        this.eventWaiters = [];
+      }
+      /**
+       * Check if the tree is complete.
+       */
+      isComplete() {
+        return this.isCompleted;
+      }
+    };
+  }
+});
+
 // src/gadgets/media-store.ts
 import { randomBytes } from "node:crypto";
 import { mkdir, rm, writeFile } from "node:fs/promises";
@@ -2367,8 +2975,8 @@ var init_conversation_manager = __esm({
       addAssistantMessage(content) {
         this.historyBuilder.addAssistant(content);
       }
-      addGadgetCallResult(gadgetName, parameters, result, media, mediaIds) {
-        this.historyBuilder.addGadgetCallResult(gadgetName, parameters, result, media, mediaIds);
+      addGadgetCallResult(gadgetName, parameters, result, invocationId, media, mediaIds) {
+        this.historyBuilder.addGadgetCallResult(gadgetName, parameters, result, invocationId, media, mediaIds);
       }
       getMessages() {
         return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
@@ -3536,20 +4144,65 @@ var init_parser = __esm({
   }
 });
 
+// src/gadgets/typed-gadget.ts
+function Gadget(config) {
+  class GadgetBase extends AbstractGadget {
+    description = config.description;
+    parameterSchema = config.schema;
+    name = config.name;
+    timeoutMs = config.timeoutMs;
+    examples = config.examples;
+    /**
+     * Type helper property for accessing inferred parameter type.
+     * This is used in the execute method signature: `execute(params: this['params'])`
+     *
+     * Note: This is just for type inference - the actual params in execute()
+     * will be Record<string, unknown> which you can safely cast to this['params']
+     */
+    params;
+  }
+  return GadgetBase;
+}
+var init_typed_gadget = __esm({
+  "src/gadgets/typed-gadget.ts"() {
+    "use strict";
+    init_gadget();
+  }
+});
+
 // src/gadgets/executor.ts
-var GadgetExecutor;
+import { z as z4 } from "zod";
+function getHostExportsInternal() {
+  if (!cachedHostExports) {
+    cachedHostExports = {
+      AgentBuilder,
+      Gadget,
+      createGadget,
+      ExecutionTree,
+      LLMist,
+      z: z4
+    };
+  }
+  return cachedHostExports;
+}
+var cachedHostExports, GadgetExecutor;
 var init_executor = __esm({
   "src/gadgets/executor.ts"() {
     "use strict";
+    init_builder();
+    init_client();
     init_constants();
+    init_execution_tree();
     init_logger();
     init_block_params();
     init_cost_reporting_client();
+    init_create_gadget();
     init_error_formatter();
     init_exceptions();
     init_parser();
+    init_typed_gadget();
     GadgetExecutor = class {
-      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig, onSubagentEvent) {
+      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig, onSubagentEvent, tree, parentNodeId, baseDepth) {
         this.registry = registry;
         this.requestHumanInput = requestHumanInput;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
@@ -3558,6 +4211,9 @@ var init_executor = __esm({
         this.agentConfig = agentConfig;
         this.subagentConfig = subagentConfig;
         this.onSubagentEvent = onSubagentEvent;
+        this.tree = tree;
+        this.parentNodeId = parentNodeId;
+        this.baseDepth = baseDepth;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
         this.errorFormatter = new GadgetExecutionErrorFormatter(errorFormatterOptions);
         this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
@@ -3568,15 +4224,21 @@ var init_executor = __esm({
       /**
        * Creates a promise that rejects with a TimeoutException after the specified timeout.
        * Aborts the provided AbortController before rejecting, allowing gadgets to clean up.
+       * Returns both the promise and a cancel function to clear the timeout when no longer needed.
        */
       createTimeoutPromise(gadgetName, timeoutMs, abortController) {
-        return new Promise((_, reject) => {
-          setTimeout(() => {
+        let timeoutId;
+        const promise = new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
             const timeoutError = new TimeoutException(gadgetName, timeoutMs);
             abortController.abort(timeoutError.message);
             reject(timeoutError);
           }, timeoutMs);
         });
+        return {
+          promise,
+          cancel: () => clearTimeout(timeoutId)
+        };
       }
       /**
        * Unify gadget execute result to consistent internal format.
@@ -3698,6 +4360,8 @@ var init_executor = __esm({
               });
             }
           };
+          const gadgetNodeId = this.tree?.getNodeByInvocationId(call.invocationId)?.id;
+          const gadgetDepth = gadgetNodeId ? this.tree?.getNode(gadgetNodeId)?.depth ?? this.baseDepth : this.baseDepth;
           const ctx = {
             reportCost,
             llmist: this.client ? new CostReportingLLMistWrapper(this.client, reportCost) : void 0,
@@ -3705,7 +4369,13 @@ var init_executor = __esm({
             agentConfig: this.agentConfig,
             subagentConfig: this.subagentConfig,
             invocationId: call.invocationId,
-            onSubagentEvent: this.onSubagentEvent
+            onSubagentEvent: this.onSubagentEvent,
+            // Tree context for subagent support - use gadget's own node ID
+            tree: this.tree,
+            nodeId: gadgetNodeId,
+            depth: gadgetDepth,
+            // Host exports for external gadgets to use host's llmist classes
+            hostExports: getHostExportsInternal()
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -3713,10 +4383,15 @@ var init_executor = __esm({
               gadgetName: call.gadgetName,
               timeoutMs
             });
-            rawResult = await Promise.race([
-              Promise.resolve(gadget.execute(validatedParameters, ctx)),
-              this.createTimeoutPromise(call.gadgetName, timeoutMs, abortController)
-            ]);
+            const timeout = this.createTimeoutPromise(call.gadgetName, timeoutMs, abortController);
+            try {
+              rawResult = await Promise.race([
+                Promise.resolve(gadget.execute(validatedParameters, ctx)),
+                timeout.promise
+              ]);
+            } finally {
+              timeout.cancel();
+            }
           } else {
             rawResult = await Promise.resolve(gadget.execute(validatedParameters, ctx));
           }
@@ -3911,10 +4586,11 @@ var init_stream_processor = __esm({
       logger;
       parser;
       executor;
-      stopOnGadgetError;
-      canRecoverFromGadgetError;
+      // Execution Tree context
+      tree;
+      parentNodeId;
+      baseDepth;
       responseText = "";
-      executionHalted = false;
       observerFailureCount = 0;
       // Dependency tracking for gadget execution DAG
       /** Gadgets waiting for their dependencies to complete */
@@ -3925,18 +4601,28 @@ var init_stream_processor = __esm({
       failedInvocations = /* @__PURE__ */ new Set();
       /** Promises for independent gadgets currently executing (fire-and-forget) */
       inFlightExecutions = /* @__PURE__ */ new Map();
+      /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
+      completedResultsQueue = [];
       constructor(options) {
         this.iteration = options.iteration;
         this.registry = options.registry;
         this.hooks = options.hooks ?? {};
         this.logger = options.logger ?? createLogger({ name: "llmist:stream-processor" });
-        this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
+        this.tree = options.tree;
+        this.parentNodeId = options.parentNodeId ?? null;
+        this.baseDepth = options.baseDepth ?? 0;
         this.parser = new GadgetCallParser({
           startPrefix: options.gadgetStartPrefix,
           endPrefix: options.gadgetEndPrefix,
           argPrefix: options.gadgetArgPrefix
         });
+        const wrappedOnSubagentEvent = options.onSubagentEvent ? (event) => {
+          this.completedResultsQueue.push({
+            type: "subagent_event",
+            subagentEvent: event
+          });
+          options.onSubagentEvent?.(event);
+        } : void 0;
         this.executor = new GadgetExecutor(
           options.registry,
           options.requestHumanInput,
@@ -3947,7 +4633,11 @@ var init_stream_processor = __esm({
           options.mediaStore,
           options.agentConfig,
           options.subagentConfig,
-          options.onSubagentEvent
+          wrappedOnSubagentEvent,
+          // Tree context for gadget execution
+          options.tree,
+          options.parentNodeId,
+          options.baseDepth
         );
       }
       /**
@@ -3998,7 +4688,7 @@ var init_stream_processor = __esm({
                 usage,
                 logger: this.logger
               };
-              await this.hooks.observers.onStreamChunk(context);
+              await this.hooks.observers?.onStreamChunk?.(context);
             });
             await this.runObserversInParallel(chunkObservers);
           }
@@ -4016,25 +4706,7 @@ var init_stream_processor = __esm({
               }
             }
           }
-          if (this.executionHalted) {
-            this.logger.info("Breaking from LLM stream due to gadget error");
-            break;
-          }
-        }
-        if (!this.executionHalted) {
-          for (const event of this.parser.finalize()) {
-            for await (const processedEvent of this.processEventGenerator(event)) {
-              yield processedEvent;
-              if (processedEvent.type === "gadget_result") {
-                didExecuteGadgets = true;
-                if (processedEvent.result.breaksLoop) {
-                  shouldBreakLoop = true;
-                }
-              }
-            }
-          }
-          const inFlightResults = await this.collectInFlightResults();
-          for (const evt of inFlightResults) {
+          for (const evt of this.drainCompletedResults()) {
             yield evt;
             if (evt.type === "gadget_result") {
               didExecuteGadgets = true;
@@ -4043,16 +4715,45 @@ var init_stream_processor = __esm({
               }
             }
           }
-          for await (const evt of this.processPendingGadgetsGenerator()) {
-            yield evt;
-            if (evt.type === "gadget_result") {
+        }
+        for (const event of this.parser.finalize()) {
+          for await (const processedEvent of this.processEventGenerator(event)) {
+            yield processedEvent;
+            if (processedEvent.type === "gadget_result") {
               didExecuteGadgets = true;
-              if (evt.result.breaksLoop) {
+              if (processedEvent.result.breaksLoop) {
                 shouldBreakLoop = true;
               }
             }
           }
         }
+        for await (const evt of this.waitForInFlightExecutions()) {
+          yield evt;
+          if (evt.type === "gadget_result") {
+            didExecuteGadgets = true;
+            if (evt.result.breaksLoop) {
+              shouldBreakLoop = true;
+            }
+          }
+        }
+        for (const evt of this.drainCompletedResults()) {
+          yield evt;
+          if (evt.type === "gadget_result") {
+            didExecuteGadgets = true;
+            if (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;
+            }
+          }
+        }
         let finalMessage = this.responseText;
         if (this.hooks.interceptors?.interceptAssistantMessage) {
           const context = {
@@ -4073,21 +4774,8 @@ var init_stream_processor = __esm({
         };
         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") {
-          return this.processTextEvent(event);
-        } else if (event.type === "gadget_call") {
-          return this.processGadgetCall(event.call);
-        }
-        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") {
@@ -4129,12 +4817,6 @@ var init_stream_processor = __esm({
        * After each execution, pending gadgets are checked to see if they can now run.
        */
       async processGadgetCall(call) {
-        if (this.executionHalted) {
-          this.logger.debug("Skipping gadget execution due to previous error", {
-            gadgetName: call.gadgetName
-          });
-          return [];
-        }
         const events = [];
         events.push({ type: "gadget_call", call });
         if (call.dependencies.length > 0) {
@@ -4185,13 +4867,16 @@ var init_stream_processor = __esm({
        * 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
+        yield { type: "gadget_call", call };
+        if (this.tree) {
+          this.tree.addGadget({
+            invocationId: call.invocationId,
+            name: call.gadgetName,
+            parameters: call.parameters ?? {},
+            dependencies: call.dependencies,
+            parentId: this.parentNodeId
           });
-          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)", {
@@ -4236,17 +4921,8 @@ var init_stream_processor = __esm({
           }
           return;
         }
-        if (this.stopOnGadgetError) {
-          for await (const evt of this.executeGadgetGenerator(call)) {
-            yield evt;
-          }
-          for await (const evt of this.processPendingGadgetsGenerator()) {
-            yield evt;
-          }
-        } else {
-          const executionPromise = this.executeGadgetAndCollect(call);
-          this.inFlightExecutions.set(call.invocationId, executionPromise);
-        }
+        const executionPromise = this.executeGadgetAndCollect(call);
+        this.inFlightExecutions.set(call.invocationId, executionPromise);
       }
       /**
        * Execute a gadget through the full hook lifecycle.
@@ -4261,15 +4937,6 @@ var init_stream_processor = __esm({
             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) {
@@ -4312,7 +4979,7 @@ var init_stream_processor = __esm({
               parameters,
               logger: this.logger
             };
-            await this.hooks.observers.onGadgetExecutionStart(context);
+            await this.hooks.observers?.onGadgetExecutionStart?.(context);
           });
         }
         await this.runObserversInParallel(startObservers);
@@ -4381,7 +5048,7 @@ var init_stream_processor = __esm({
               cost: result.cost,
               logger: this.logger
             };
-            await this.hooks.observers.onGadgetExecutionComplete(context);
+            await this.hooks.observers?.onGadgetExecutionComplete?.(context);
           });
         }
         await this.runObserversInParallel(completeObservers);
@@ -4390,18 +5057,6 @@ var init_stream_processor = __esm({
           this.failedInvocations.add(result.invocationId);
         }
         events.push({ 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;
-          }
-        }
         return events;
       }
       /**
@@ -4415,15 +5070,6 @@ var init_stream_processor = __esm({
             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) {
@@ -4466,10 +5112,16 @@ var init_stream_processor = __esm({
               parameters,
               logger: this.logger
             };
-            await this.hooks.observers.onGadgetExecutionStart(context);
+            await this.hooks.observers?.onGadgetExecutionStart?.(context);
           });
         }
         await this.runObserversInParallel(startObservers);
+        if (this.tree) {
+          const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
+          if (gadgetNode) {
+            this.tree.startGadget(gadgetNode.id);
+          }
+        }
         let result;
         if (shouldSkip) {
           result = {
@@ -4535,57 +5187,84 @@ var init_stream_processor = __esm({
               cost: result.cost,
               logger: this.logger
             };
-            await this.hooks.observers.onGadgetExecutionComplete(context);
+            await this.hooks.observers?.onGadgetExecutionComplete?.(context);
           });
         }
         await this.runObserversInParallel(completeObservers);
+        if (this.tree) {
+          const gadgetNode = this.tree.getNodeByInvocationId(result.invocationId);
+          if (gadgetNode) {
+            if (result.error) {
+              this.tree.completeGadget(gadgetNode.id, {
+                error: result.error,
+                executionTimeMs: result.executionTimeMs,
+                cost: result.cost
+              });
+            } else {
+              this.tree.completeGadget(gadgetNode.id, {
+                result: result.result,
+                executionTimeMs: result.executionTimeMs,
+                cost: result.cost,
+                media: result.media
+              });
+            }
+          }
+        }
         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;
-          }
-        }
       }
       /**
-       * Execute a gadget and collect all events into an array (non-blocking).
+       * Execute a gadget and push events to the completed results queue (non-blocking).
        * Used for fire-and-forget parallel execution of independent gadgets.
+       * Results are pushed to completedResultsQueue for real-time streaming to the caller.
        */
       async executeGadgetAndCollect(call) {
-        const events = [];
         for await (const evt of this.executeGadgetGenerator(call)) {
-          events.push(evt);
+          this.completedResultsQueue.push(evt);
+        }
+      }
+      /**
+       * Drain all completed results from the queue.
+       * Used to yield results as they complete during stream processing.
+       * @returns Generator that yields all events currently in the queue
+       */
+      *drainCompletedResults() {
+        while (this.completedResultsQueue.length > 0) {
+          yield this.completedResultsQueue.shift();
         }
-        return events;
       }
       /**
-       * Collect results from all fire-and-forget (in-flight) gadget executions.
-       * Called at stream end to await parallel independent gadgets.
-       * Clears the inFlightExecutions map after collection.
-       * @returns Array of all events from completed gadgets
+       * Wait for all in-flight gadget executions to complete, yielding events in real-time.
+       * Called at stream end to ensure all parallel executions finish.
+       * Results and subagent events are pushed to completedResultsQueue during execution.
+       * This generator yields queued events while polling, enabling real-time display
+       * of subagent activity (LLM calls, nested gadgets) during long-running gadgets.
+       * Clears the inFlightExecutions map after all gadgets complete.
        */
-      async collectInFlightResults() {
+      async *waitForInFlightExecutions() {
         if (this.inFlightExecutions.size === 0) {
-          return [];
+          return;
         }
-        this.logger.debug("Collecting in-flight gadget results", {
+        this.logger.debug("Waiting for in-flight gadget executions", {
           count: this.inFlightExecutions.size,
           invocationIds: Array.from(this.inFlightExecutions.keys())
         });
-        const promises = Array.from(this.inFlightExecutions.values());
-        const results = await Promise.all(promises);
+        const allDone = Promise.all(this.inFlightExecutions.values()).then(() => "done");
+        const POLL_INTERVAL_MS = 100;
+        while (true) {
+          const result = await Promise.race([
+            allDone,
+            new Promise((resolve) => setTimeout(() => resolve("poll"), POLL_INTERVAL_MS))
+          ]);
+          yield* this.drainCompletedResults();
+          if (result === "done") {
+            break;
+          }
+        }
         this.inFlightExecutions.clear();
-        return results.flat();
       }
       /**
        * Handle a gadget that cannot execute because a dependency failed.
@@ -4610,6 +5289,12 @@ var init_stream_processor = __esm({
         }
         if (action.action === "skip") {
           this.failedInvocations.add(call.invocationId);
+          if (this.tree) {
+            const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
+            if (gadgetNode) {
+              this.tree.skipGadget(gadgetNode.id, failedDep, depError, "dependency_failed");
+            }
+          }
           const skipEvent = {
             type: "gadget_skipped",
             gadgetName: call.gadgetName,
@@ -4629,7 +5314,7 @@ var init_stream_processor = __esm({
               failedDependencyError: depError,
               logger: this.logger
             };
-            await this.safeObserve(() => this.hooks.observers.onGadgetSkipped(observeContext));
+            await this.safeObserve(() => this.hooks.observers?.onGadgetSkipped?.(observeContext));
           }
           this.logger.info("Gadget skipped due to failed dependency", {
             gadgetName: call.gadgetName,
@@ -4861,48 +5546,6 @@ var init_stream_processor = __esm({
           observers.map((observer) => this.safeObserve(observer))
         );
       }
-      /**
-       * Check if execution can recover from an error.
-       *
-       * Returns true if we should continue processing subsequent gadgets, false if we should stop.
-       *
-       * Logic:
-       * - If custom canRecoverFromGadgetError is provided, use it
-       * - Otherwise, use stopOnGadgetError config:
-       *   - stopOnGadgetError=true → return false (stop execution)
-       *   - stopOnGadgetError=false → return true (continue execution)
-       */
-      async checkCanRecoverFromError(error, gadgetName, errorType, parameters) {
-        if (this.canRecoverFromGadgetError) {
-          return await this.canRecoverFromGadgetError({
-            error,
-            gadgetName,
-            errorType,
-            parameters
-          });
-        }
-        const shouldContinue = !this.stopOnGadgetError;
-        this.logger.debug("Checking if should continue after error", {
-          error,
-          gadgetName,
-          errorType,
-          stopOnGadgetError: this.stopOnGadgetError,
-          shouldContinue
-        });
-        return shouldContinue;
-      }
-      /**
-       * Determine the type of error from a gadget execution.
-       */
-      determineErrorType(call, result) {
-        if (call.parseError) {
-          return "parse";
-        }
-        if (result.error?.includes("Invalid parameters:")) {
-          return "validation";
-        }
-        return "execution";
-      }
     };
   }
 });
@@ -4913,6 +5556,7 @@ var init_agent = __esm({
   "src/agent/agent.ts"() {
     "use strict";
     init_constants();
+    init_execution_tree();
     init_messages();
     init_model_shortcuts();
     init_media_store();
@@ -4940,8 +5584,6 @@ var init_agent = __esm({
       requestHumanInput;
       textOnlyHandler;
       textWithGadgetsHandler;
-      stopOnGadgetError;
-      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       defaultMaxTokens;
       hasUserPrompt;
@@ -4964,6 +5606,12 @@ var init_agent = __esm({
       pendingSubagentEvents = [];
       // Combined callback that queues events AND calls user callback
       onSubagentEvent;
+      // Counter for generating synthetic invocation IDs for wrapped text content
+      syntheticInvocationCounter = 0;
+      // Execution Tree - first-class model for nested subagent support
+      tree;
+      parentNodeId;
+      baseDepth;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -4986,8 +5634,6 @@ var init_agent = __esm({
         this.requestHumanInput = options.requestHumanInput;
         this.textOnlyHandler = options.textOnlyHandler ?? "terminate";
         this.textWithGadgetsHandler = options.textWithGadgetsHandler;
-        this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
         this.defaultGadgetTimeoutMs = options.defaultGadgetTimeoutMs;
         this.defaultMaxTokens = this.resolveMaxTokensFromCatalog(options.model);
         this.outputLimitEnabled = options.gadgetOutputLimit ?? DEFAULT_GADGET_OUTPUT_LIMIT;
@@ -5041,6 +5687,9 @@ var init_agent = __esm({
           temperature: this.temperature
         };
         this.subagentConfig = options.subagentConfig;
+        this.tree = options.parentTree ?? new ExecutionTree();
+        this.parentNodeId = options.parentNodeId ?? null;
+        this.baseDepth = options.baseDepth ?? 0;
         this.userSubagentEventCallback = options.onSubagentEvent;
         this.onSubagentEvent = (event) => {
           this.pendingSubagentEvents.push(event);
@@ -5105,7 +5754,9 @@ var init_agent = __esm({
       *flushPendingSubagentEvents() {
         while (this.pendingSubagentEvents.length > 0) {
           const event = this.pendingSubagentEvents.shift();
-          yield { type: "subagent_event", subagentEvent: event };
+          if (event) {
+            yield { type: "subagent_event", subagentEvent: event };
+          }
         }
       }
       /**
@@ -5159,6 +5810,48 @@ var init_agent = __esm({
       getMediaStore() {
         return this.mediaStore;
       }
+      /**
+       * Get the execution tree for this agent.
+       *
+       * The execution tree provides a first-class model of all LLM calls and gadget executions,
+       * including nested subagent activity. Use this to:
+       * - Query execution state: `tree.getNode(id)`
+       * - Get total cost: `tree.getTotalCost()`
+       * - Get subtree cost/media/tokens: `tree.getSubtreeCost(nodeId)`
+       * - Subscribe to events: `tree.on("llm_call_complete", handler)`
+       * - Stream all events: `for await (const event of tree.events())`
+       *
+       * For subagents (created with `withParentContext`), the tree is shared with the parent,
+       * enabling unified tracking and real-time visibility across all nesting levels.
+       *
+       * @returns The ExecutionTree instance
+       *
+       * @example
+       * ```typescript
+       * const agent = LLMist.createAgent()
+       *   .withModel("sonnet")
+       *   .withGadgets(BrowseWeb)
+       *   .ask("Research topic X");
+       *
+       * for await (const event of agent.run()) {
+       *   // Process events...
+       * }
+       *
+       * // After execution, query the tree
+       * const tree = agent.getTree();
+       * console.log(`Total cost: $${tree.getTotalCost().toFixed(4)}`);
+       *
+       * // Inspect all LLM calls
+       * for (const node of tree.getAllNodes()) {
+       *   if (node.type === "llm_call") {
+       *     console.log(`LLM #${node.iteration}: ${node.model}`);
+       *   }
+       * }
+       * ```
+       */
+      getTree() {
+        return this.tree;
+      }
       /**
        * Manually trigger context compaction.
        *
@@ -5260,6 +5953,7 @@ var init_agent = __esm({
                     await this.hooks.observers.onCompaction({
                       iteration: currentIteration,
                       event: compactionEvent,
+                      // biome-ignore lint/style/noNonNullAssertion: compactionManager exists if compactionEvent is truthy
                       stats: this.compactionManager.getStats(),
                       logger: this.logger
                     });
@@ -5321,6 +6015,13 @@ 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 = this.client.stream(llmOptions);
             const processor = new StreamProcessor({
               iteration: currentIteration,
@@ -5331,14 +6032,17 @@ var init_agent = __esm({
               hooks: this.hooks,
               logger: this.logger.getSubLogger({ name: "stream-processor" }),
               requestHumanInput: this.requestHumanInput,
-              stopOnGadgetError: this.stopOnGadgetError,
-              canRecoverFromGadgetError: this.canRecoverFromGadgetError,
               defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
               client: this.client,
               mediaStore: this.mediaStore,
               agentConfig: this.agentContextConfig,
               subagentConfig: this.subagentConfig,
-              onSubagentEvent: this.onSubagentEvent
+              onSubagentEvent: this.onSubagentEvent,
+              // Tree context for execution tracking
+              tree: this.tree,
+              parentNodeId: currentLLMNodeId,
+              // Gadgets are children of this LLM call
+              baseDepth: this.baseDepth
             });
             let streamMetadata = null;
             let gadgetCallCount = 0;
@@ -5384,6 +6088,11 @@ var init_agent = __esm({
                 await this.hooks.observers.onLLMCallComplete(context);
               }
             });
+            this.tree.completeLLMCall(currentLLMNodeId, {
+              response: result.rawResponse,
+              usage: result.usage,
+              finishReason: result.finishReason
+            });
             let finalMessage = result.finalMessage;
             if (this.hooks.controllers?.afterLLMCall) {
               const context = {
@@ -5418,10 +6127,12 @@ var init_agent = __esm({
                 const textContent = textOutputs.join("");
                 if (textContent.trim()) {
                   const { gadgetName, parameterMapping, resultMapping } = this.textWithGadgetsHandler;
+                  const syntheticId = `gc_text_${++this.syntheticInvocationCounter}`;
                   this.conversation.addGadgetCallResult(
                     gadgetName,
                     parameterMapping(textContent),
-                    resultMapping ? resultMapping(textContent) : textContent
+                    resultMapping ? resultMapping(textContent) : textContent,
+                    syntheticId
                   );
                 }
               }
@@ -5432,6 +6143,7 @@ var init_agent = __esm({
                     gadgetResult.gadgetName,
                     gadgetResult.parameters,
                     gadgetResult.error ?? gadgetResult.result ?? "",
+                    gadgetResult.invocationId,
                     gadgetResult.media,
                     gadgetResult.mediaIds
                   );
@@ -5439,10 +6151,12 @@ var init_agent = __esm({
               }
             } else {
               if (finalMessage.trim()) {
+                const syntheticId = `gc_tell_${++this.syntheticInvocationCounter}`;
                 this.conversation.addGadgetCallResult(
                   "TellUser",
                   { message: finalMessage, done: false, type: "info" },
-                  `\u2139\uFE0F  ${finalMessage}`
+                  `\u2139\uFE0F  ${finalMessage}`,
+                  syntheticId
                 );
               }
               const shouldBreak = await this.handleTextOnlyResponse(finalMessage);
@@ -5653,8 +6367,6 @@ var init_builder = __esm({
       gadgetArgPrefix;
       textOnlyHandler;
       textWithGadgetsHandler;
-      stopOnGadgetError;
-      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
@@ -5663,6 +6375,8 @@ var init_builder = __esm({
       trailingMessage;
       subagentConfig;
       subagentEventCallback;
+      // Tree context for subagent support - enables shared tree model
+      // When a gadget calls withParentContext(ctx), it shares the parent's tree
       parentContext;
       constructor(client) {
         this.client = client;
@@ -5945,62 +6659,6 @@ var init_builder = __esm({
         this.textWithGadgetsHandler = handler;
         return this;
       }
-      /**
-       * Set whether to stop gadget execution on first error.
-       *
-       * When true (default), if a gadget fails:
-       * - Subsequent gadgets in the same response are skipped
-       * - LLM stream is cancelled to save costs
-       * - Agent loop continues with error in context
-       *
-       * When false:
-       * - All gadgets in the response still execute
-       * - LLM stream continues to completion
-       *
-       * @param stop - Whether to stop on gadget error
-       * @returns This builder for chaining
-       *
-       * @example
-       * ```typescript
-       * .withStopOnGadgetError(false)
-       * ```
-       */
-      withStopOnGadgetError(stop) {
-        this.stopOnGadgetError = stop;
-        return this;
-      }
-      /**
-       * Set custom error handling logic.
-       *
-       * Provides fine-grained control over whether to continue after different types of errors.
-       * Overrides `stopOnGadgetError` when provided.
-       *
-       * **Note:** This builder method configures the underlying `canRecoverFromGadgetError` option
-       * in `AgentOptions`. The method is named `withErrorHandler` for better developer experience,
-       * but maps to the `canRecoverFromGadgetError` property internally.
-       *
-       * @param handler - Function that decides whether to continue after an error.
-       *                  Return `true` to continue execution, `false` to stop.
-       * @returns This builder for chaining
-       *
-       * @example
-       * ```typescript
-       * .withErrorHandler((context) => {
-       *   // Stop on parse errors, continue on validation/execution errors
-       *   if (context.errorType === "parse") {
-       *     return false;
-       *   }
-       *   if (context.error.includes("CRITICAL")) {
-       *     return false;
-       *   }
-       *   return true;
-       * })
-       * ```
-       */
-      withErrorHandler(handler) {
-        this.canRecoverFromGadgetError = handler;
-        return this;
-      }
       /**
        * Set default timeout for gadget execution.
        *
@@ -6195,6 +6853,15 @@ var init_builder = __esm({
        * The method extracts `invocationId` and `onSubagentEvent` from the execution
        * context and sets up automatic forwarding via hooks and event wrapping.
        *
+       * **NEW: Shared Tree Model** - When the parent provides an ExecutionTree via context,
+       * the subagent shares that tree instead of creating its own. This enables:
+       * - Unified cost tracking across all nesting levels
+       * - Automatic media aggregation via `tree.getSubtreeMedia(nodeId)`
+       * - Real-time visibility of nested execution in the parent
+       *
+       * **Signal Forwarding** - When parent context includes a signal, it's automatically
+       * forwarded to the subagent for proper cancellation propagation.
+       *
        * @param ctx - ExecutionContext passed to the gadget's execute() method
        * @param depth - Nesting depth (default: 1 for direct child)
        * @returns This builder for chaining
@@ -6215,17 +6882,25 @@ var init_builder = __esm({
        *       result = event.content;
        *     }
        *   }
+       *
+       *   // After subagent completes, costs are automatically aggregated
+       *   // No manual tracking needed - use tree methods:
+       *   const totalCost = ctx.tree?.getSubtreeCost(ctx.nodeId!);
+       *   const allMedia = ctx.tree?.getSubtreeMedia(ctx.nodeId!);
        * }
        * ```
        */
       withParentContext(ctx, depth = 1) {
-        if (ctx.onSubagentEvent && ctx.invocationId) {
+        if (ctx.tree) {
           this.parentContext = {
-            invocationId: ctx.invocationId,
-            onSubagentEvent: ctx.onSubagentEvent,
+            tree: ctx.tree,
+            nodeId: ctx.nodeId,
             depth
           };
         }
+        if (ctx.signal && !this.signal) {
+          this.signal = ctx.signal;
+        }
         return this;
       }
       /**
@@ -6258,11 +6933,13 @@ var init_builder = __esm({
        *
        * This is useful for in-context learning - showing the LLM what "past self"
        * did correctly so it mimics the pattern. The call is formatted with proper
-       * markers and parameter format.
+       * markers and parameter format, including the invocation ID so the LLM can
+       * reference previous calls when building dependencies.
        *
        * @param gadgetName - Name of the gadget
        * @param parameters - Parameters passed to the gadget
        * @param result - Result returned by the gadget
+       * @param invocationId - Invocation ID (shown to LLM so it can reference for dependencies)
        * @returns This builder for chaining
        *
        * @example
@@ -6274,124 +6951,36 @@ var init_builder = __esm({
        *     done: false,
        *     type: 'info'
        *   },
-       *   'ℹ️  👋 Hello!\n\nHere\'s what I can do:\n- Analyze code\n- Run commands'
+       *   'ℹ️  👋 Hello!\n\nHere\'s what I can do:\n- Analyze code\n- Run commands',
+       *   'gc_1'
        * )
        * ```
        */
-      withSyntheticGadgetCall(gadgetName, parameters, result) {
+      withSyntheticGadgetCall(gadgetName, parameters, result, invocationId) {
         const startPrefix = this.gadgetStartPrefix ?? GADGET_START_PREFIX;
         const endPrefix = this.gadgetEndPrefix ?? GADGET_END_PREFIX;
         const paramStr = this.formatBlockParameters(parameters, "");
         this.initialMessages.push({
           role: "assistant",
-          content: `${startPrefix}${gadgetName}
+          content: `${startPrefix}${gadgetName}:${invocationId}
 ${paramStr}
 ${endPrefix}`
         });
         this.initialMessages.push({
           role: "user",
-          content: `Result: ${result}`
+          content: `Result (${invocationId}): ${result}`
         });
         return this;
       }
       /**
-       * Compose the final hooks, including:
-       * - Trailing message injection (if configured)
-       * - Subagent event forwarding for LLM calls (if parentContext is set)
+       * Compose the final hooks, including trailing message injection if configured.
+       *
+       * Note: Subagent event visibility is now handled entirely by the ExecutionTree.
+       * When a subagent uses withParentContext(ctx), it shares the parent's tree,
+       * and all events are automatically visible to tree subscribers (like the TUI).
        */
       composeHooks() {
-        let hooks = this.hooks;
-        if (this.parentContext) {
-          const { invocationId, onSubagentEvent, depth } = this.parentContext;
-          const existingOnLLMCallStart = hooks?.observers?.onLLMCallStart;
-          const existingOnLLMCallComplete = hooks?.observers?.onLLMCallComplete;
-          const existingOnGadgetExecutionStart = hooks?.observers?.onGadgetExecutionStart;
-          const existingOnGadgetExecutionComplete = hooks?.observers?.onGadgetExecutionComplete;
-          hooks = {
-            ...hooks,
-            observers: {
-              ...hooks?.observers,
-              onLLMCallStart: async (context) => {
-                let inputTokens;
-                try {
-                  if (this.client) {
-                    inputTokens = await this.client.countTokens(
-                      context.options.model,
-                      context.options.messages
-                    );
-                  }
-                } catch {
-                }
-                onSubagentEvent({
-                  type: "llm_call_start",
-                  gadgetInvocationId: invocationId,
-                  depth,
-                  event: {
-                    iteration: context.iteration,
-                    model: context.options.model,
-                    inputTokens
-                  }
-                });
-                if (existingOnLLMCallStart) {
-                  await existingOnLLMCallStart(context);
-                }
-              },
-              onLLMCallComplete: async (context) => {
-                onSubagentEvent({
-                  type: "llm_call_end",
-                  gadgetInvocationId: invocationId,
-                  depth,
-                  event: {
-                    iteration: context.iteration,
-                    model: context.options.model,
-                    // Backward compat fields
-                    inputTokens: context.usage?.inputTokens,
-                    outputTokens: context.usage?.outputTokens,
-                    finishReason: context.finishReason ?? void 0,
-                    // Full usage object with cache details (for first-class display)
-                    usage: context.usage
-                    // Cost will be calculated by parent if it has model registry
-                  }
-                });
-                if (existingOnLLMCallComplete) {
-                  await existingOnLLMCallComplete(context);
-                }
-              },
-              onGadgetExecutionStart: async (context) => {
-                onSubagentEvent({
-                  type: "gadget_call",
-                  gadgetInvocationId: invocationId,
-                  depth,
-                  event: {
-                    call: {
-                      invocationId: context.invocationId,
-                      gadgetName: context.gadgetName,
-                      parameters: context.parameters
-                    }
-                  }
-                });
-                if (existingOnGadgetExecutionStart) {
-                  await existingOnGadgetExecutionStart(context);
-                }
-              },
-              onGadgetExecutionComplete: async (context) => {
-                onSubagentEvent({
-                  type: "gadget_result",
-                  gadgetInvocationId: invocationId,
-                  depth,
-                  event: {
-                    result: {
-                      invocationId: context.invocationId
-                    }
-                  }
-                });
-                if (existingOnGadgetExecutionComplete) {
-                  await existingOnGadgetExecutionComplete(context);
-                }
-              }
-            }
-          };
-        }
+        const hooks = this.hooks;
         if (!this.trailingMessage) {
           return hooks;
         }
@@ -6474,19 +7063,6 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
-        let onSubagentEvent = this.subagentEventCallback;
-        if (this.parentContext) {
-          const { invocationId, onSubagentEvent: parentCallback, depth } = this.parentContext;
-          const existingCallback = this.subagentEventCallback;
-          onSubagentEvent = (event) => {
-            parentCallback({
-              ...event,
-              gadgetInvocationId: invocationId,
-              depth: event.depth + depth
-            });
-            existingCallback?.(event);
-          };
-        }
         return {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -6505,15 +7081,17 @@ ${endPrefix}`
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
-          stopOnGadgetError: this.stopOnGadgetError,
-          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
-          onSubagentEvent
+          onSubagentEvent: this.subagentEventCallback,
+          // Tree context for shared tree model (subagents share parent's tree)
+          parentTree: this.parentContext?.tree,
+          parentNodeId: this.parentContext?.nodeId,
+          baseDepth: this.parentContext ? (this.parentContext.depth ?? 0) + 1 : 0
         };
       }
       ask(userPrompt) {
@@ -6670,19 +7248,6 @@ ${endPrefix}`
           this.client = new LLMistClass();
         }
         const registry = GadgetRegistry.from(this.gadgets);
-        let onSubagentEvent = this.subagentEventCallback;
-        if (this.parentContext) {
-          const { invocationId, onSubagentEvent: parentCallback, depth } = this.parentContext;
-          const existingCallback = this.subagentEventCallback;
-          onSubagentEvent = (event) => {
-            parentCallback({
-              ...event,
-              gadgetInvocationId: invocationId,
-              depth: event.depth + depth
-            });
-            existingCallback?.(event);
-          };
-        }
         const options = {
           client: this.client,
           model: this.model ?? "openai:gpt-5-nano",
@@ -6701,15 +7266,17 @@ ${endPrefix}`
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
-          stopOnGadgetError: this.stopOnGadgetError,
-          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
-          onSubagentEvent
+          onSubagentEvent: this.subagentEventCallback,
+          // Tree context for shared tree model (subagents share parent's tree)
+          parentTree: this.parentContext?.tree,
+          parentNodeId: this.parentContext?.nodeId,
+          baseDepth: this.parentContext ? (this.parentContext.depth ?? 0) + 1 : 0
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -11297,16 +11864,16 @@ var MockConversationManager = class {
     this.history.push(msg);
     this.addedMessages.push(msg);
   }
-  addGadgetCallResult(gadgetName, parameters, result) {
+  addGadgetCallResult(gadgetName, parameters, result, invocationId) {
     const assistantMsg = {
       role: "assistant",
-      content: `!!!GADGET_START:${gadgetName}
+      content: `!!!GADGET_START:${gadgetName}:${invocationId}
 ${JSON.stringify(parameters)}
 !!!GADGET_END`
     };
     const resultMsg = {
       role: "user",
-      content: `Result: ${result}`
+      content: `Result (${invocationId}): ${result}`
     };
     this.history.push(assistantMsg);
     this.history.push(resultMsg);
@@ -11654,6 +12221,8 @@ export {
   init_schema_validator,
   GadgetRegistry,
   init_registry,
+  ExecutionTree,
+  init_execution_tree,
   DEFAULT_HINTS,
   DEFAULT_PROMPTS,
   resolvePromptTemplate,
@@ -11700,12 +12269,6 @@ export {
   init_event_handlers,
   GadgetOutputStore,
   init_gadget_output_store,
-  GadgetCallParser,
-  init_parser,
-  GadgetExecutor,
-  init_executor,
-  StreamProcessor,
-  init_stream_processor,
   FALLBACK_CHARS_PER_TOKEN,
   init_constants2 as init_constants,
   AnthropicMessagesProvider,
@@ -11728,6 +12291,14 @@ export {
   init_options,
   LLMist,
   init_client,
+  GadgetCallParser,
+  init_parser,
+  Gadget,
+  init_typed_gadget,
+  GadgetExecutor,
+  init_executor,
+  StreamProcessor,
+  init_stream_processor,
   AgentBuilder,
   init_builder,
   validateAndApplyDefaults,
@@ -11772,4 +12343,4 @@ export {
   createEmptyStream,
   createErrorStream
 };
-//# sourceMappingURL=chunk-EIE5VRSI.js.map
+//# sourceMappingURL=chunk-36YSBSGB.js.map