llmist 6.1.0 → 7.0.0

package/dist/{chunk-VAJLPRJ6.js → chunk-SFZIL2VR.js}

@@ -44,6 +44,9 @@ function parseEnvBoolean(value) {
   if (normalized === "false" || normalized === "0") return false;
   return void 0;
 }
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
 function createLogger(options = {}) {
   const envMinLevel = parseLogLevel(process.env.LLMIST_LOG_LEVEL);
   const envLogFile = process.env.LLMIST_LOG_FILE?.trim() ?? "";
@@ -52,36 +55,62 @@ function createLogger(options = {}) {
   const defaultType = options.type ?? "pretty";
   const name = options.name ?? "llmist";
   const logReset = options.logReset ?? envLogReset ?? false;
-  let logFileStream;
-  let finalType = defaultType;
-  if (envLogFile) {
+  if (envLogFile && (!logFileInitialized || sharedLogFilePath !== envLogFile)) {
     try {
+      if (sharedLogFileStream) {
+        sharedLogFileStream.end();
+        sharedLogFileStream = void 0;
+      }
       mkdirSync(dirname(envLogFile), { recursive: true });
       const flags = logReset ? "w" : "a";
-      logFileStream = createWriteStream(envLogFile, { flags });
-      finalType = "hidden";
+      sharedLogFileStream = createWriteStream(envLogFile, { flags });
+      sharedLogFilePath = envLogFile;
+      logFileInitialized = true;
+      writeErrorCount = 0;
+      writeErrorReported = false;
+      sharedLogFileStream.on("error", (error) => {
+        writeErrorCount++;
+        if (!writeErrorReported) {
+          console.error(`[llmist] Log file write error: ${error.message}`);
+          writeErrorReported = true;
+        }
+        if (writeErrorCount >= MAX_WRITE_ERRORS_BEFORE_DISABLE) {
+          console.error(
+            `[llmist] Too many log file errors (${writeErrorCount}), disabling file logging`
+          );
+          sharedLogFileStream?.end();
+          sharedLogFileStream = void 0;
+        }
+      });
     } catch (error) {
       console.error("Failed to initialize LLMIST_LOG_FILE output:", error);
     }
   }
+  const useFileLogging = Boolean(sharedLogFileStream);
   const logger = new Logger({
     name,
     minLevel,
-    type: finalType,
-    // Optimize for production
-    hideLogPositionForProduction: finalType !== "pretty",
-    // Pretty output settings
-    prettyLogTemplate: finalType === "pretty" ? "{{yyyy}}-{{mm}}-{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}} {{logLevelName}} [{{name}}] " : void 0
+    type: useFileLogging ? "pretty" : defaultType,
+    // Hide log position for file logging and non-pretty types
+    hideLogPositionForProduction: useFileLogging || defaultType !== "pretty",
+    prettyLogTemplate: LOG_TEMPLATE,
+    // Use overwrite to redirect tslog's formatted output to file instead of console
+    overwrite: useFileLogging ? {
+      transportFormatted: (logMetaMarkup, logArgs, _logErrors) => {
+        if (!sharedLogFileStream) return;
+        const meta = stripAnsi(logMetaMarkup);
+        const args = logArgs.map(
+          (arg) => typeof arg === "string" ? stripAnsi(arg) : JSON.stringify(arg)
+        );
+        const line = `${meta}${args.join(" ")}
+`;
+        sharedLogFileStream.write(line);
+      }
+    } : void 0
   });
-  if (logFileStream) {
-    logger.attachTransport((logObj) => {
-      logFileStream?.write(`${JSON.stringify(logObj)}
-`);
-    });
-  }
   return logger;
 }
-var LEVEL_NAME_TO_ID, defaultLogger;
+var LEVEL_NAME_TO_ID, sharedLogFilePath, sharedLogFileStream, logFileInitialized, writeErrorCount, writeErrorReported, MAX_WRITE_ERRORS_BEFORE_DISABLE, LOG_TEMPLATE, defaultLogger;
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
@@ -94,6 +123,11 @@ var init_logger = __esm({
       error: 5,
       fatal: 6
     };
+    logFileInitialized = false;
+    writeErrorCount = 0;
+    writeErrorReported = false;
+    MAX_WRITE_ERRORS_BEFORE_DISABLE = 5;
+    LOG_TEMPLATE = "{{yyyy}}-{{mm}}-{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}	{{logLevelName}}	[{{name}}]	";
     defaultLogger = createLogger();
   }
 });
@@ -3859,9 +3893,8 @@ var init_cost_reporting_client = __esm({
        */
       reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens = 0, cacheCreationInputTokens = 0) {
         if (inputTokens === 0 && outputTokens === 0) return;
-        const modelName = model.includes(":") ? model.split(":")[1] : model;
         const estimate = this.client.modelRegistry.estimateCost(
-          modelName,
+          model,
           inputTokens,
           outputTokens,
           cachedInputTokens,
@@ -4144,18 +4177,64 @@ 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 equal from "fast-deep-equal";
+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, tree, parentNodeId, baseDepth) {
         this.registry = registry;
@@ -4253,7 +4332,7 @@ var init_executor = __esm({
             try {
               const cleanedRaw = stripMarkdownFences(call.parametersRaw);
               const initialParse = parseBlockParams(cleanedRaw, { argPrefix: this.argPrefix });
-              const parametersWereModified = !this.deepEquals(rawParameters, initialParse);
+              const parametersWereModified = !equal(rawParameters, initialParse);
               if (parametersWereModified) {
                 this.logger.debug("Parameters modified by interceptor, skipping re-parse", {
                   gadgetName: call.gadgetName
@@ -4328,7 +4407,11 @@ var init_executor = __esm({
             // Tree context for subagent support - use gadget's own node ID
             tree: this.tree,
             nodeId: gadgetNodeId,
-            depth: gadgetDepth
+            depth: gadgetDepth,
+            // Host exports for external gadgets to use host's llmist classes
+            hostExports: getHostExportsInternal(),
+            // Logger for structured logging (respects CLI's log level/file config)
+            logger: this.logger
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -4498,27 +4581,6 @@ var init_executor = __esm({
       async executeAll(calls) {
         return Promise.all(calls.map((call) => this.execute(call)));
       }
-      /**
-       * Deep equality check for objects/arrays.
-       * Used to detect if parameters were modified by an interceptor.
-       */
-      deepEquals(a, b) {
-        if (a === b) return true;
-        if (a === null || b === null) return a === b;
-        if (typeof a !== typeof b) return false;
-        if (typeof a !== "object") return a === b;
-        if (Array.isArray(a) !== Array.isArray(b)) return false;
-        if (Array.isArray(a) && Array.isArray(b)) {
-          if (a.length !== b.length) return false;
-          return a.every((val, i) => this.deepEquals(val, b[i]));
-        }
-        const aObj = a;
-        const bObj = b;
-        const aKeys = Object.keys(aObj);
-        const bKeys = Object.keys(bObj);
-        if (aKeys.length !== bKeys.length) return false;
-        return aKeys.every((key) => this.deepEquals(aObj[key], bObj[key]));
-      }
     };
   }
 });
@@ -4556,6 +4618,11 @@ var init_stream_processor = __esm({
       inFlightExecutions = /* @__PURE__ */ new Map();
       /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
       completedResultsQueue = [];
+      // Cross-iteration dependency tracking
+      /** Invocation IDs completed in previous iterations (read-only reference from Agent) */
+      priorCompletedInvocations;
+      /** Invocation IDs that failed in previous iterations (read-only reference from Agent) */
+      priorFailedInvocations;
       constructor(options) {
         this.iteration = options.iteration;
         this.registry = options.registry;
@@ -4564,6 +4631,8 @@ var init_stream_processor = __esm({
         this.tree = options.tree;
         this.parentNodeId = options.parentNodeId ?? null;
         this.baseDepth = options.baseDepth ?? 0;
+        this.priorCompletedInvocations = options.priorCompletedInvocations ?? /* @__PURE__ */ new Set();
+        this.priorFailedInvocations = options.priorFailedInvocations ?? /* @__PURE__ */ new Set();
         this.parser = new GadgetCallParser({
           startPrefix: options.gadgetStartPrefix,
           endPrefix: options.gadgetEndPrefix,
@@ -4762,62 +4831,11 @@ var init_stream_processor = __esm({
         }
         return [{ type: "text", content }];
       }
-      /**
-       * Process a gadget call through the full lifecycle, handling dependencies.
-       *
-       * Gadgets without dependencies (or with all dependencies satisfied) execute immediately.
-       * Gadgets with unsatisfied dependencies are queued for later execution.
-       * After each execution, pending gadgets are checked to see if they can now run.
-       */
-      async processGadgetCall(call) {
-        const events = [];
-        events.push({ 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)`
-            };
-            events.push(skipEvent);
-            return events;
-          }
-          const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
-          if (failedDep) {
-            const skipEvents = await this.handleFailedDependency(call, failedDep);
-            events.push(...skipEvents);
-            return events;
-          }
-          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 events;
-          }
-        }
-        const executeEvents = await this.executeGadgetWithHooks(call);
-        events.push(...executeEvents);
-        const triggeredEvents = await this.processPendingGadgets();
-        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.
+       * Yields gadget_call event IMMEDIATELY when parsed (before execution),
+       * enabling real-time UI feedback.
        */
       async *processGadgetCallGenerator(call) {
         yield { type: "gadget_call", call };
@@ -4848,7 +4866,9 @@ var init_stream_processor = __esm({
             yield skipEvent;
             return;
           }
-          const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+          const failedDep = call.dependencies.find(
+            (dep) => this.failedInvocations.has(dep) || this.priorFailedInvocations.has(dep)
+          );
           if (failedDep) {
             const skipEvents = await this.handleFailedDependency(call, failedDep);
             for (const evt of skipEvents) {
@@ -4856,7 +4876,9 @@ var init_stream_processor = __esm({
             }
             return;
           }
-          const unsatisfied = call.dependencies.filter((dep) => !this.completedResults.has(dep));
+          const unsatisfied = call.dependencies.filter(
+            (dep) => !this.completedResults.has(dep) && !this.priorCompletedInvocations.has(dep)
+          );
           if (unsatisfied.length > 0) {
             this.logger.debug("Queueing gadget for later - waiting on dependencies", {
               gadgetName: call.gadgetName,
@@ -4878,143 +4900,9 @@ var init_stream_processor = __esm({
         this.inFlightExecutions.set(call.invocationId, executionPromise);
       }
       /**
-       * 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 = [];
-        if (call.parseError) {
-          this.logger.warn("Gadget has parse error", {
-            gadgetName: call.gadgetName,
-            error: call.parseError,
-            rawParameters: call.parametersRaw
-          });
-        }
-        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);
-        }
-        events.push({ type: "gadget_result", result });
-        return events;
-      }
-      /**
-       * Execute a gadget and yield the result event.
-       * Generator version that yields gadget_result immediately when execution completes.
+       * Execute a gadget through the full hook lifecycle and yield events.
+       * Handles parameter interception, before/after controllers, observers,
+       * execution, result interception, and tree tracking.
        */
       async *executeGadgetGenerator(call) {
         if (call.parseError) {
@@ -5280,8 +5168,9 @@ var init_stream_processor = __esm({
             invocationId: call.invocationId,
             failedDependency: failedDep
           });
-          const executeEvents = await this.executeGadgetWithHooks(call);
-          events.push(...executeEvents);
+          for await (const evt of this.executeGadgetGenerator(call)) {
+            events.push(evt);
+          }
         } else if (action.action === "use_fallback") {
           const fallbackResult = {
             gadgetName: call.gadgetName,
@@ -5302,90 +5191,9 @@ var init_stream_processor = __esm({
       }
       /**
        * Process pending gadgets whose dependencies are now satisfied.
-       * Executes ready gadgets in parallel and continues until no more can be triggered.
-       */
-      async processPendingGadgets() {
-        const events = [];
-        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);
-            events.push(...skipEvents);
-            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 executePromises = readyToExecute.map((call) => this.executeGadgetWithHooks(call));
-            const results = await Promise.all(executePromises);
-            for (const executeEvents of results) {
-              events.push(...executeEvents);
-            }
-            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
-            };
-            events.push(skipEvent);
-          }
-          this.gadgetsAwaitingDependencies.clear();
-        }
-        return events;
-      }
-      /**
-       * Process pending gadgets, yielding events in real-time.
-       * Generator version that yields events as gadgets complete.
+       * Yields events in real-time as gadgets complete.
        *
-       * Note: Gadgets are still executed in parallel for efficiency,
+       * Gadgets are executed in parallel for efficiency,
        * but results are yielded as they become available.
        */
       async *processPendingGadgetsGenerator() {
@@ -5395,12 +5203,16 @@ var init_stream_processor = __esm({
           const readyToExecute = [];
           const readyToSkip = [];
           for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
-            const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+            const failedDep = call.dependencies.find(
+              (dep) => this.failedInvocations.has(dep) || this.priorFailedInvocations.has(dep)
+            );
             if (failedDep) {
               readyToSkip.push({ call, failedDep });
               continue;
             }
-            const allSatisfied = call.dependencies.every((dep) => this.completedResults.has(dep));
+            const allSatisfied = call.dependencies.every(
+              (dep) => this.completedResults.has(dep) || this.priorCompletedInvocations.has(dep)
+            );
             if (allSatisfied) {
               readyToExecute.push(call);
             }
@@ -5441,7 +5253,9 @@ var init_stream_processor = __esm({
         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 missingDeps = call.dependencies.filter(
+              (dep) => !this.completedResults.has(dep) && !this.priorCompletedInvocations.has(dep)
+            );
             const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
             const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
             let errorMessage;
@@ -5495,10 +5309,27 @@ var init_stream_processor = __esm({
        */
       async runObserversInParallel(observers) {
         if (observers.length === 0) return;
-        const results = await Promise.allSettled(
+        await Promise.allSettled(
           observers.map((observer) => this.safeObserve(observer))
         );
       }
+      // ==========================================================================
+      // Public accessors for cross-iteration dependency tracking
+      // ==========================================================================
+      /**
+       * Get all invocation IDs that completed successfully in this iteration.
+       * Used by Agent to accumulate completed IDs across iterations.
+       */
+      getCompletedInvocationIds() {
+        return new Set(this.completedResults.keys());
+      }
+      /**
+       * Get all invocation IDs that failed in this iteration.
+       * Used by Agent to accumulate failed IDs across iterations.
+       */
+      getFailedInvocationIds() {
+        return new Set(this.failedInvocations);
+      }
     };
   }
 });
@@ -5561,6 +5392,9 @@ var init_agent = __esm({
       onSubagentEvent;
       // Counter for generating synthetic invocation IDs for wrapped text content
       syntheticInvocationCounter = 0;
+      // Cross-iteration dependency tracking - allows gadgets to depend on results from prior iterations
+      completedInvocationIds = /* @__PURE__ */ new Set();
+      failedInvocationIds = /* @__PURE__ */ new Set();
       // Execution Tree - first-class model for nested subagent support
       tree;
       parentNodeId;
@@ -5870,96 +5704,22 @@ var init_agent = __esm({
           maxIterations: this.maxIterations
         });
         while (currentIteration < this.maxIterations) {
-          if (this.signal?.aborted) {
-            this.logger.info("Agent loop terminated by abort signal", {
-              iteration: currentIteration,
-              reason: this.signal.reason
-            });
-            await this.safeObserve(async () => {
-              if (this.hooks.observers?.onAbort) {
-                const context = {
-                  iteration: currentIteration,
-                  reason: this.signal?.reason,
-                  logger: this.logger
-                };
-                await this.hooks.observers.onAbort(context);
-              }
-            });
+          if (await this.checkAbortAndNotify(currentIteration)) {
             return;
           }
           this.logger.debug("Starting iteration", { iteration: currentIteration });
           try {
-            if (this.compactionManager) {
-              const compactionEvent = await this.compactionManager.checkAndCompact(
-                this.conversation,
-                currentIteration
-              );
-              if (compactionEvent) {
-                this.logger.info("Context compacted", {
-                  strategy: compactionEvent.strategy,
-                  tokensBefore: compactionEvent.tokensBefore,
-                  tokensAfter: compactionEvent.tokensAfter
-                });
-                yield { type: "compaction", event: compactionEvent };
-                await this.safeObserve(async () => {
-                  if (this.hooks.observers?.onCompaction) {
-                    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
-                    });
-                  }
-                });
-              }
+            const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
+            if (compactionEvent) {
+              yield compactionEvent;
             }
-            let llmOptions = {
-              model: this.model,
-              messages: this.conversation.getMessages(),
-              temperature: this.temperature,
-              maxTokens: this.defaultMaxTokens,
-              signal: this.signal
-            };
-            await this.safeObserve(async () => {
-              if (this.hooks.observers?.onLLMCallStart) {
-                const context = {
-                  iteration: currentIteration,
-                  options: llmOptions,
-                  logger: this.logger
-                };
-                await this.hooks.observers.onLLMCallStart(context);
-              }
-            });
-            if (this.hooks.controllers?.beforeLLMCall) {
-              const context = {
-                iteration: currentIteration,
-                maxIterations: this.maxIterations,
-                options: llmOptions,
-                logger: this.logger
-              };
-              const action = await this.hooks.controllers.beforeLLMCall(context);
-              validateBeforeLLMCallAction(action);
-              if (action.action === "skip") {
-                this.logger.info("Controller skipped LLM call, using synthetic response");
-                this.conversation.addAssistantMessage(action.syntheticResponse);
-                yield { type: "text", content: action.syntheticResponse };
-                break;
-              } else if (action.action === "proceed" && action.modifiedOptions) {
-                llmOptions = { ...llmOptions, ...action.modifiedOptions };
-              }
+            const prepared = await this.prepareLLMCall(currentIteration);
+            const llmOptions = prepared.options;
+            if (prepared.skipWithSynthetic !== void 0) {
+              this.conversation.addAssistantMessage(prepared.skipWithSynthetic);
+              yield { type: "text", content: prepared.skipWithSynthetic };
+              break;
             }
-            await this.safeObserve(async () => {
-              if (this.hooks.observers?.onLLMCallReady) {
-                const context = {
-                  iteration: currentIteration,
-                  maxIterations: this.maxIterations,
-                  options: llmOptions,
-                  logger: this.logger
-                };
-                await this.hooks.observers.onLLMCallReady(context);
-              }
-            });
             this.logger.info("Calling LLM", { model: this.model });
             this.logger.silly("LLM request details", {
               model: llmOptions.model,
@@ -5995,7 +5755,10 @@ var init_agent = __esm({
               tree: this.tree,
               parentNodeId: currentLLMNodeId,
               // Gadgets are children of this LLM call
-              baseDepth: this.baseDepth
+              baseDepth: this.baseDepth,
+              // Cross-iteration dependency tracking
+              priorCompletedInvocations: this.completedInvocationIds,
+              priorFailedInvocations: this.failedInvocationIds
             });
             let streamMetadata = null;
             let gadgetCallCount = 0;
@@ -6018,6 +5781,12 @@ var init_agent = __esm({
             if (!streamMetadata) {
               throw new Error("Stream processing completed without metadata event");
             }
+            for (const id of processor.getCompletedInvocationIds()) {
+              this.completedInvocationIds.add(id);
+            }
+            for (const id of processor.getFailedInvocationIds()) {
+              this.failedInvocationIds.add(id);
+            }
             const result = streamMetadata;
             this.logger.info("LLM response completed", {
               finishReason: result.finishReason,
@@ -6041,81 +5810,21 @@ 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 = {
-                iteration: currentIteration,
-                maxIterations: this.maxIterations,
-                options: llmOptions,
-                finishReason: result.finishReason,
-                usage: result.usage,
-                finalMessage: result.finalMessage,
-                gadgetCallCount,
-                logger: this.logger
-              };
-              const action = await this.hooks.controllers.afterLLMCall(context);
-              validateAfterLLMCallAction(action);
-              if (action.action === "modify_and_continue" || action.action === "append_and_modify") {
-                finalMessage = action.modifiedMessage;
-              }
-              if (action.action === "append_messages" || action.action === "append_and_modify") {
-                for (const msg of action.messages) {
-                  if (msg.role === "user") {
-                    this.conversation.addUserMessage(msg.content);
-                  } else if (msg.role === "assistant") {
-                    this.conversation.addAssistantMessage(extractMessageText(msg.content));
-                  } else if (msg.role === "system") {
-                    this.conversation.addUserMessage(`[System] ${extractMessageText(msg.content)}`);
-                  }
-                }
-              }
-            }
-            if (result.didExecuteGadgets) {
-              if (this.textWithGadgetsHandler) {
-                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,
-                    syntheticId
-                  );
-                }
-              }
-              for (const output of gadgetResults) {
-                if (output.type === "gadget_result") {
-                  const gadgetResult = output.result;
-                  this.conversation.addGadgetCallResult(
-                    gadgetResult.gadgetName,
-                    gadgetResult.parameters,
-                    gadgetResult.error ?? gadgetResult.result ?? "",
-                    gadgetResult.invocationId,
-                    gadgetResult.media,
-                    gadgetResult.mediaIds
-                  );
-                }
-              }
-            } else {
-              if (finalMessage.trim()) {
-                const syntheticId = `gc_tell_${++this.syntheticInvocationCounter}`;
-                this.conversation.addGadgetCallResult(
-                  "TellUser",
-                  { message: finalMessage, done: false, type: "info" },
-                  `\u2139\uFE0F  ${finalMessage}`,
-                  syntheticId
-                );
-              }
-              const shouldBreak = await this.handleTextOnlyResponse(finalMessage);
-              if (shouldBreak) {
-                break;
-              }
+            this.completeLLMCallInTree(currentLLMNodeId, result);
+            const finalMessage = await this.processAfterLLMCallController(
+              currentIteration,
+              llmOptions,
+              result,
+              gadgetCallCount
+            );
+            const shouldBreakFromTextOnly = await this.updateConversationWithResults(
+              result.didExecuteGadgets,
+              textOutputs,
+              gadgetResults,
+              finalMessage
+            );
+            if (shouldBreakFromTextOnly) {
+              break;
             }
             if (result.shouldBreakLoop) {
               this.logger.info("Loop terminated by gadget or processor");
@@ -6268,6 +5977,210 @@ var init_agent = __esm({
           }
         };
       }
+      // ==========================================================================
+      // Agent Loop Helper Methods (extracted from run() for readability)
+      // ==========================================================================
+      /**
+       * Check abort signal and notify observers if aborted.
+       * @returns true if agent should terminate
+       */
+      async checkAbortAndNotify(iteration) {
+        if (!this.signal?.aborted) return false;
+        this.logger.info("Agent loop terminated by abort signal", {
+          iteration,
+          reason: this.signal.reason
+        });
+        await this.safeObserve(async () => {
+          if (this.hooks.observers?.onAbort) {
+            const context = {
+              iteration,
+              reason: this.signal?.reason,
+              logger: this.logger
+            };
+            await this.hooks.observers.onAbort(context);
+          }
+        });
+        return true;
+      }
+      /**
+       * Check and perform context compaction if needed.
+       * @returns compaction stream event if compaction occurred, null otherwise
+       */
+      async checkAndPerformCompaction(iteration) {
+        if (!this.compactionManager) return null;
+        const compactionEvent = await this.compactionManager.checkAndCompact(
+          this.conversation,
+          iteration
+        );
+        if (!compactionEvent) return null;
+        this.logger.info("Context compacted", {
+          strategy: compactionEvent.strategy,
+          tokensBefore: compactionEvent.tokensBefore,
+          tokensAfter: compactionEvent.tokensAfter
+        });
+        await this.safeObserve(async () => {
+          if (this.hooks.observers?.onCompaction) {
+            await this.hooks.observers.onCompaction({
+              iteration,
+              event: compactionEvent,
+              // biome-ignore lint/style/noNonNullAssertion: compactionManager exists if compactionEvent is truthy
+              stats: this.compactionManager.getStats(),
+              logger: this.logger
+            });
+          }
+        });
+        return { type: "compaction", event: compactionEvent };
+      }
+      /**
+       * Prepare LLM call options and process beforeLLMCall controller.
+       * @returns options and optional skipWithSynthetic response if controller wants to skip
+       */
+      async prepareLLMCall(iteration) {
+        let llmOptions = {
+          model: this.model,
+          messages: this.conversation.getMessages(),
+          temperature: this.temperature,
+          maxTokens: this.defaultMaxTokens,
+          signal: this.signal
+        };
+        await this.safeObserve(async () => {
+          if (this.hooks.observers?.onLLMCallStart) {
+            const context = {
+              iteration,
+              options: llmOptions,
+              logger: this.logger
+            };
+            await this.hooks.observers.onLLMCallStart(context);
+          }
+        });
+        if (this.hooks.controllers?.beforeLLMCall) {
+          const context = {
+            iteration,
+            maxIterations: this.maxIterations,
+            options: llmOptions,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.beforeLLMCall(context);
+          validateBeforeLLMCallAction(action);
+          if (action.action === "skip") {
+            this.logger.info("Controller skipped LLM call, using synthetic response");
+            return { options: llmOptions, skipWithSynthetic: action.syntheticResponse };
+          } else if (action.action === "proceed" && action.modifiedOptions) {
+            llmOptions = { ...llmOptions, ...action.modifiedOptions };
+          }
+        }
+        await this.safeObserve(async () => {
+          if (this.hooks.observers?.onLLMCallReady) {
+            const context = {
+              iteration,
+              maxIterations: this.maxIterations,
+              options: llmOptions,
+              logger: this.logger
+            };
+            await this.hooks.observers.onLLMCallReady(context);
+          }
+        });
+        return { options: llmOptions };
+      }
+      /**
+       * Calculate cost and complete LLM call in execution tree.
+       */
+      completeLLMCallInTree(nodeId, result) {
+        const llmCost = this.client.modelRegistry?.estimateCost?.(
+          this.model,
+          result.usage?.inputTokens ?? 0,
+          result.usage?.outputTokens ?? 0,
+          result.usage?.cachedInputTokens ?? 0,
+          result.usage?.cacheCreationInputTokens ?? 0
+        )?.totalCost;
+        this.tree.completeLLMCall(nodeId, {
+          response: result.rawResponse,
+          usage: result.usage,
+          finishReason: result.finishReason,
+          cost: llmCost
+        });
+      }
+      /**
+       * Process afterLLMCall controller and return modified final message.
+       */
+      async processAfterLLMCallController(iteration, llmOptions, result, gadgetCallCount) {
+        let finalMessage = result.finalMessage;
+        if (!this.hooks.controllers?.afterLLMCall) {
+          return finalMessage;
+        }
+        const context = {
+          iteration,
+          maxIterations: this.maxIterations,
+          options: llmOptions,
+          finishReason: result.finishReason,
+          usage: result.usage,
+          finalMessage: result.finalMessage,
+          gadgetCallCount,
+          logger: this.logger
+        };
+        const action = await this.hooks.controllers.afterLLMCall(context);
+        validateAfterLLMCallAction(action);
+        if (action.action === "modify_and_continue" || action.action === "append_and_modify") {
+          finalMessage = action.modifiedMessage;
+        }
+        if (action.action === "append_messages" || action.action === "append_and_modify") {
+          for (const msg of action.messages) {
+            if (msg.role === "user") {
+              this.conversation.addUserMessage(msg.content);
+            } else if (msg.role === "assistant") {
+              this.conversation.addAssistantMessage(extractMessageText(msg.content));
+            } else if (msg.role === "system") {
+              this.conversation.addUserMessage(`[System] ${extractMessageText(msg.content)}`);
+            }
+          }
+        }
+        return finalMessage;
+      }
+      /**
+       * Update conversation history with gadget results or text-only response.
+       * @returns true if loop should break (text-only handler requested termination)
+       */
+      async updateConversationWithResults(didExecuteGadgets, textOutputs, gadgetResults, finalMessage) {
+        if (didExecuteGadgets) {
+          if (this.textWithGadgetsHandler) {
+            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,
+                syntheticId
+              );
+            }
+          }
+          for (const output of gadgetResults) {
+            if (output.type === "gadget_result") {
+              const gadgetResult = output.result;
+              this.conversation.addGadgetCallResult(
+                gadgetResult.gadgetName,
+                gadgetResult.parameters,
+                gadgetResult.error ?? gadgetResult.result ?? "",
+                gadgetResult.invocationId,
+                gadgetResult.media,
+                gadgetResult.mediaIds
+              );
+            }
+          }
+          return false;
+        }
+        if (finalMessage.trim()) {
+          const syntheticId = `gc_tell_${++this.syntheticInvocationCounter}`;
+          this.conversation.addGadgetCallResult(
+            "TellUser",
+            { message: finalMessage, done: false, type: "info" },
+            `\u2139\uFE0F  ${finalMessage}`,
+            syntheticId
+          );
+        }
+        return await this.handleTextOnlyResponse(finalMessage);
+      }
       /**
        * Run agent with named event handlers (syntactic sugar).
        *
@@ -9800,11 +9713,13 @@ var init_model_registry = __esm({
       }
       /**
        * Get model specification by model ID
-       * @param modelId - Full model identifier (e.g., 'gpt-5', 'claude-sonnet-4-5-20250929')
+       * @param modelId - Full model identifier, optionally with provider prefix
+       *                  (e.g., 'gpt-5', 'claude-sonnet-4-5-20250929', 'anthropic:claude-sonnet-4-5')
        * @returns ModelSpec if found, undefined otherwise
        */
       getModelSpec(modelId) {
-        return this.modelSpecs.find((model) => model.modelId === modelId);
+        const normalizedId = modelId.includes(":") ? modelId.split(":")[1] : modelId;
+        return this.modelSpecs.find((model) => model.modelId === normalizedId);
       }
       /**
        * List all models, optionally filtered by provider
@@ -12222,12 +12137,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,
@@ -12250,6 +12159,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,
@@ -12294,4 +12211,4 @@ export {
   createEmptyStream,
   createErrorStream
 };
-//# sourceMappingURL=chunk-VAJLPRJ6.js.map
+//# sourceMappingURL=chunk-SFZIL2VR.js.map