llmist 6.2.0 → 8.0.0

package/dist/index.cjs

@@ -45,6 +45,19 @@ var init_constants = __esm({
   }
 });
 
+// src/providers/constants.ts
+var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS, FALLBACK_CHARS_PER_TOKEN, OPENAI_MESSAGE_OVERHEAD_TOKENS, OPENAI_REPLY_PRIMING_TOKENS, OPENAI_NAME_FIELD_OVERHEAD_TOKENS;
+var init_constants2 = __esm({
+  "src/providers/constants.ts"() {
+    "use strict";
+    ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+    FALLBACK_CHARS_PER_TOKEN = 4;
+    OPENAI_MESSAGE_OVERHEAD_TOKENS = 4;
+    OPENAI_REPLY_PRIMING_TOKENS = 2;
+    OPENAI_NAME_FIELD_OVERHEAD_TOKENS = 1;
+  }
+});
+
 // src/core/input-content.ts
 function isTextPart(part) {
   return part.type === "text";
@@ -1877,6 +1890,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() ?? "";
@@ -1885,36 +1901,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;
+      }
       (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(envLogFile), { recursive: true });
       const flags = logReset ? "w" : "a";
-      logFileStream = (0, import_node_fs.createWriteStream)(envLogFile, { flags });
-      finalType = "hidden";
+      sharedLogFileStream = (0, import_node_fs.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 import_tslog.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 import_node_fs, import_node_path2, import_tslog, LEVEL_NAME_TO_ID, defaultLogger;
+var import_node_fs, import_node_path2, import_tslog, 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";
@@ -1930,6 +1972,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();
   }
 });
@@ -2543,7 +2590,138 @@ var AGENT_INTERNAL_KEY;
 var init_agent_internal_key = __esm({
   "src/agent/agent-internal-key.ts"() {
     "use strict";
-    AGENT_INTERNAL_KEY = Symbol("AGENT_INTERNAL_KEY");
+    AGENT_INTERNAL_KEY = /* @__PURE__ */ Symbol("AGENT_INTERNAL_KEY");
+  }
+});
+
+// src/core/retry.ts
+function resolveRetryConfig(config) {
+  if (!config) {
+    return { ...DEFAULT_RETRY_CONFIG };
+  }
+  return {
+    enabled: config.enabled ?? DEFAULT_RETRY_CONFIG.enabled,
+    retries: config.retries ?? DEFAULT_RETRY_CONFIG.retries,
+    minTimeout: config.minTimeout ?? DEFAULT_RETRY_CONFIG.minTimeout,
+    maxTimeout: config.maxTimeout ?? DEFAULT_RETRY_CONFIG.maxTimeout,
+    factor: config.factor ?? DEFAULT_RETRY_CONFIG.factor,
+    randomize: config.randomize ?? DEFAULT_RETRY_CONFIG.randomize,
+    onRetry: config.onRetry,
+    onRetriesExhausted: config.onRetriesExhausted,
+    shouldRetry: config.shouldRetry
+  };
+}
+function isRetryableError(error) {
+  const message = error.message.toLowerCase();
+  const name = error.name;
+  if (message.includes("429") || message.includes("rate limit") || message.includes("rate_limit")) {
+    return true;
+  }
+  if (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504") || message.includes("internal server error") || message.includes("bad gateway") || message.includes("service unavailable") || message.includes("gateway timeout")) {
+    return true;
+  }
+  if (message.includes("timeout") || message.includes("etimedout") || message.includes("timed out")) {
+    return true;
+  }
+  if (message.includes("econnreset") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("connection") || message.includes("network")) {
+    return true;
+  }
+  if (name === "APIConnectionError" || name === "RateLimitError" || name === "InternalServerError" || name === "ServiceUnavailableError" || name === "APITimeoutError") {
+    return true;
+  }
+  if (message.includes("overloaded") || message.includes("capacity")) {
+    return true;
+  }
+  if (message.includes("401") || message.includes("403") || message.includes("400") || message.includes("404") || message.includes("authentication") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("invalid") || message.includes("content policy") || name === "AuthenticationError" || name === "BadRequestError" || name === "NotFoundError" || name === "PermissionDeniedError") {
+    return false;
+  }
+  return false;
+}
+function formatLLMError(error) {
+  const message = error.message;
+  const name = error.name;
+  if (message.includes("RESOURCE_EXHAUSTED") || message.includes("429")) {
+    return "Rate limit exceeded (429) - retry after a few seconds";
+  }
+  if (message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("rate_limit")) {
+    return "Rate limit exceeded - retry after a few seconds";
+  }
+  if (message.toLowerCase().includes("overloaded") || message.toLowerCase().includes("capacity")) {
+    return "API overloaded - retry later";
+  }
+  if (message.includes("500") || message.toLowerCase().includes("internal server error")) {
+    return "Internal server error (500) - the API is experiencing issues";
+  }
+  if (message.includes("502") || message.toLowerCase().includes("bad gateway")) {
+    return "Bad gateway (502) - the API is temporarily unavailable";
+  }
+  if (message.includes("503") || message.toLowerCase().includes("service unavailable")) {
+    return "Service unavailable (503) - the API is temporarily down";
+  }
+  if (message.includes("504") || message.toLowerCase().includes("gateway timeout")) {
+    return "Gateway timeout (504) - the request took too long";
+  }
+  if (message.toLowerCase().includes("timeout") || message.toLowerCase().includes("timed out")) {
+    return "Request timed out - the API took too long to respond";
+  }
+  if (message.toLowerCase().includes("econnrefused")) {
+    return "Connection refused - unable to reach the API";
+  }
+  if (message.toLowerCase().includes("econnreset")) {
+    return "Connection reset - the API closed the connection";
+  }
+  if (message.toLowerCase().includes("enotfound")) {
+    return "DNS error - unable to resolve API hostname";
+  }
+  if (message.includes("401") || message.toLowerCase().includes("unauthorized") || name === "AuthenticationError") {
+    return "Authentication failed - check your API key";
+  }
+  if (message.includes("403") || message.toLowerCase().includes("forbidden") || name === "PermissionDeniedError") {
+    return "Permission denied - your API key lacks required permissions";
+  }
+  if (message.includes("400") || name === "BadRequestError") {
+    const match = message.match(/message['":\s]+['"]?([^'"}\]]+)/i);
+    if (match) {
+      return `Bad request: ${match[1].trim()}`;
+    }
+    return "Bad request - check your input parameters";
+  }
+  if (message.toLowerCase().includes("content policy") || message.toLowerCase().includes("safety")) {
+    return "Content policy violation - the request was blocked";
+  }
+  try {
+    const parsed = JSON.parse(message);
+    const extractedMessage = parsed?.error?.message || parsed?.message;
+    if (typeof extractedMessage === "string" && extractedMessage.length > 0) {
+      return extractedMessage.trim();
+    }
+  } catch {
+  }
+  const jsonMatch = message.match(/["']?message["']?\s*[:=]\s*["']([^"']+)["']/i);
+  if (jsonMatch) {
+    return jsonMatch[1].trim();
+  }
+  if (message.length > 200) {
+    const firstPart = message.split(/[.!?\n]/)[0];
+    if (firstPart && firstPart.length > 10 && firstPart.length < 150) {
+      return firstPart.trim();
+    }
+    return message.slice(0, 150).trim() + "...";
+  }
+  return message;
+}
+var DEFAULT_RETRY_CONFIG;
+var init_retry = __esm({
+  "src/core/retry.ts"() {
+    "use strict";
+    DEFAULT_RETRY_CONFIG = {
+      enabled: true,
+      retries: 3,
+      minTimeout: 1e3,
+      maxTimeout: 3e4,
+      factor: 2,
+      randomize: true
+    };
   }
 });
 
@@ -3013,6 +3191,9 @@ var init_conversation_manager = __esm({
           }
         }
       }
+      getConversationHistory() {
+        return [...this.initialMessages, ...this.historyBuilder.build()];
+      }
     };
   }
 });
@@ -3655,19 +3836,6 @@ var init_base_provider = __esm({
   }
 });
 
-// src/providers/constants.ts
-var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS, FALLBACK_CHARS_PER_TOKEN, OPENAI_MESSAGE_OVERHEAD_TOKENS, OPENAI_REPLY_PRIMING_TOKENS, OPENAI_NAME_FIELD_OVERHEAD_TOKENS;
-var init_constants2 = __esm({
-  "src/providers/constants.ts"() {
-    "use strict";
-    ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
-    FALLBACK_CHARS_PER_TOKEN = 4;
-    OPENAI_MESSAGE_OVERHEAD_TOKENS = 4;
-    OPENAI_REPLY_PRIMING_TOKENS = 2;
-    OPENAI_NAME_FIELD_OVERHEAD_TOKENS = 1;
-  }
-});
-
 // src/providers/utils.ts
 function readEnvVar(key) {
   if (typeof process === "undefined" || typeof process.env === "undefined") {
@@ -5900,11 +6068,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
@@ -7146,9 +7316,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,
@@ -7471,10 +7640,11 @@ function getHostExportsInternal() {
   }
   return cachedHostExports;
 }
-var import_zod2, cachedHostExports, GadgetExecutor;
+var import_fast_deep_equal, import_zod2, cachedHostExports, GadgetExecutor;
 var init_executor = __esm({
   "src/gadgets/executor.ts"() {
     "use strict";
+    import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
     import_zod2 = require("zod");
     init_builder();
     init_client();
@@ -7585,7 +7755,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 = !(0, import_fast_deep_equal.default)(rawParameters, initialParse);
               if (parametersWereModified) {
                 this.logger.debug("Parameters modified by interceptor, skipping re-parse", {
                   gadgetName: call.gadgetName
@@ -7662,7 +7832,9 @@ var init_executor = __esm({
             nodeId: gadgetNodeId,
             depth: gadgetDepth,
             // Host exports for external gadgets to use host's llmist classes
-            hostExports: getHostExportsInternal()
+            hostExports: getHostExportsInternal(),
+            // Logger for structured logging (respects CLI's log level/file config)
+            logger: this.logger
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -7769,14 +7941,16 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
-          if (error instanceof HumanInputRequiredException) {
+          const isHumanInputError = error instanceof Error && error.name === "HumanInputRequiredException" && "question" in error;
+          if (isHumanInputError) {
+            const question = error.question;
             this.logger.info("Gadget requested human input", {
               gadgetName: call.gadgetName,
-              question: error.question
+              question
             });
             if (this.requestHumanInput) {
               try {
-                const answer = await this.requestHumanInput(error.question);
+                const answer = await this.requestHumanInput(question);
                 this.logger.debug("Human input received", {
                   gadgetName: call.gadgetName,
                   answerLength: answer.length
@@ -7832,27 +8006,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]));
-      }
     };
   }
 });
@@ -7890,6 +8043,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;
@@ -7898,6 +8056,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,
@@ -8096,62 +8256,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 };
@@ -8182,7 +8291,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) {
@@ -8190,7 +8301,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,
@@ -8212,12 +8325,11 @@ 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
+       * 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 executeGadgetWithHooks(call) {
-        const events = [];
+      async *executeGadgetGenerator(call) {
         if (call.parseError) {
           this.logger.warn("Gadget has parse error", {
             gadgetName: call.gadgetName,
@@ -8270,6 +8382,12 @@ var init_stream_processor = __esm({
           });
         }
         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 = {
@@ -8339,256 +8457,117 @@ var init_stream_processor = __esm({
           });
         }
         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);
         }
-        events.push({ type: "gadget_result", result });
-        return events;
+        yield { type: "gadget_result", result };
+      }
+      /**
+       * 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) {
+        for await (const evt of this.executeGadgetGenerator(call)) {
+          this.completedResultsQueue.push(evt);
+        }
       }
       /**
-       * Execute a gadget and yield the result event.
-       * Generator version that yields gadget_result immediately when execution completes.
+       * 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
        */
-      async *executeGadgetGenerator(call) {
-        if (call.parseError) {
-          this.logger.warn("Gadget has parse error", {
-            gadgetName: call.gadgetName,
-            error: call.parseError,
-            rawParameters: call.parametersRaw
-          });
+      *drainCompletedResults() {
+        while (this.completedResultsQueue.length > 0) {
+          yield this.completedResultsQueue.shift();
         }
-        let parameters = call.parameters ?? {};
-        if (this.hooks.interceptors?.interceptGadgetParameters) {
+      }
+      /**
+       * 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 *waitForInFlightExecutions() {
+        if (this.inFlightExecutions.size === 0) {
+          return;
+        }
+        this.logger.debug("Waiting for in-flight gadget executions", {
+          count: this.inFlightExecutions.size,
+          invocationIds: Array.from(this.inFlightExecutions.keys())
+        });
+        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();
+      }
+      /**
+       * Handle a gadget that cannot execute because a dependency failed.
+       * Calls the onDependencySkipped controller to allow customization.
+       */
+      async handleFailedDependency(call, failedDep) {
+        const events = [];
+        const depResult = this.completedResults.get(failedDep);
+        const depError = depResult?.error ?? "Dependency failed";
+        let action = { action: "skip" };
+        if (this.hooks.controllers?.onDependencySkipped) {
           const context = {
             iteration: this.iteration,
             gadgetName: call.gadgetName,
             invocationId: call.invocationId,
+            parameters: call.parameters ?? {},
+            failedDependency: failedDep,
+            failedDependencyError: depError,
             logger: this.logger
           };
-          parameters = this.hooks.interceptors.interceptGadgetParameters(parameters, context);
+          action = await this.hooks.controllers.onDependencySkipped(context);
         }
-        call.parameters = parameters;
-        let shouldSkip = false;
-        let syntheticResult;
-        if (this.hooks.controllers?.beforeGadgetExecution) {
-          const context = {
-            iteration: this.iteration,
+        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,
             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);
-        if (this.tree) {
-          const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
-          if (gadgetNode) {
-            this.tree.startGadget(gadgetNode.id);
-          }
-        }
-        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);
-        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 };
-      }
-      /**
-       * 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) {
-        for await (const evt of this.executeGadgetGenerator(call)) {
-          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();
-        }
-      }
-      /**
-       * 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 *waitForInFlightExecutions() {
-        if (this.inFlightExecutions.size === 0) {
-          return;
-        }
-        this.logger.debug("Waiting for in-flight gadget executions", {
-          count: this.inFlightExecutions.size,
-          invocationIds: Array.from(this.inFlightExecutions.keys())
-        });
-        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();
-      }
-      /**
-       * Handle a gadget that cannot execute because a dependency failed.
-       * Calls the onDependencySkipped controller to allow customization.
-       */
-      async handleFailedDependency(call, failedDep) {
-        const events = [];
-        const depResult = this.completedResults.get(failedDep);
-        const depError = depResult?.error ?? "Dependency failed";
-        let action = { action: "skip" };
-        if (this.hooks.controllers?.onDependencySkipped) {
-          const context = {
-            iteration: this.iteration,
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: call.parameters ?? {},
-            failedDependency: failedDep,
-            failedDependencyError: depError,
-            logger: this.logger
-          };
-          action = await this.hooks.controllers.onDependencySkipped(context);
-        }
-        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,
-            invocationId: call.invocationId,
-            parameters: call.parameters ?? {},
-            failedDependency: failedDep,
-            failedDependencyError: depError
+            parameters: call.parameters ?? {},
+            failedDependency: failedDep,
+            failedDependencyError: depError
           };
           events.push(skipEvent);
           if (this.hooks.observers?.onGadgetSkipped) {
@@ -8614,8 +8593,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,
@@ -8636,22 +8616,28 @@ 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.
+       * Yields events in real-time as gadgets complete.
+       *
+       * Gadgets are executed in parallel for efficiency,
+       * but results are yielded as they become available.
        */
-      async processPendingGadgets() {
-        const events = [];
+      async *processPendingGadgetsGenerator() {
         let progress = true;
         while (progress && this.gadgetsAwaitingDependencies.size > 0) {
           progress = false;
           const readyToExecute = [];
           const readyToSkip = [];
-          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
-            const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
+          for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
+            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);
             }
@@ -8659,7 +8645,9 @@ var init_stream_processor = __esm({
           for (const { call, failedDep } of readyToSkip) {
             this.gadgetsAwaitingDependencies.delete(call.invocationId);
             const skipEvents = await this.handleFailedDependency(call, failedDep);
-            events.push(...skipEvents);
+            for (const evt of skipEvents) {
+              yield evt;
+            }
             progress = true;
           }
           if (readyToExecute.length > 0) {
@@ -8670,10 +8658,19 @@ var init_stream_processor = __esm({
             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);
+            const eventSets = await Promise.all(
+              readyToExecute.map(async (call) => {
+                const events = [];
+                for await (const evt of this.executeGadgetGenerator(call)) {
+                  events.push(evt);
+                }
+                return events;
+              })
+            );
+            for (const events of eventSets) {
+              for (const evt of events) {
+                yield evt;
+              }
             }
             progress = true;
           }
@@ -8681,7 +8678,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;
@@ -8709,108 +8708,14 @@ var init_stream_processor = __esm({
               failedDependency: missingDeps[0],
               failedDependencyError: errorMessage
             };
-            events.push(skipEvent);
+            yield skipEvent;
           }
           this.gadgetsAwaitingDependencies.clear();
         }
-        return events;
       }
       /**
-       * Process pending gadgets, yielding events in real-time.
-       * Generator version that yields events as gadgets complete.
-       *
-       * Note: Gadgets are still executed in parallel for efficiency,
-       * but results are yielded as they become available.
-       */
-      async *processPendingGadgetsGenerator() {
-        let progress = true;
-        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
-          progress = false;
-          const readyToExecute = [];
-          const readyToSkip = [];
-          for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
-            const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
-            if (failedDep) {
-              readyToSkip.push({ call, failedDep });
-              continue;
-            }
-            const allSatisfied = call.dependencies.every((dep) => this.completedResults.has(dep));
-            if (allSatisfied) {
-              readyToExecute.push(call);
-            }
-          }
-          for (const { call, failedDep } of readyToSkip) {
-            this.gadgetsAwaitingDependencies.delete(call.invocationId);
-            const skipEvents = await this.handleFailedDependency(call, failedDep);
-            for (const evt of skipEvents) {
-              yield evt;
-            }
-            progress = true;
-          }
-          if (readyToExecute.length > 0) {
-            this.logger.debug("Executing ready gadgets in parallel", {
-              count: readyToExecute.length,
-              invocationIds: readyToExecute.map((c) => c.invocationId)
-            });
-            for (const call of readyToExecute) {
-              this.gadgetsAwaitingDependencies.delete(call.invocationId);
-            }
-            const eventSets = await Promise.all(
-              readyToExecute.map(async (call) => {
-                const events = [];
-                for await (const evt of this.executeGadgetGenerator(call)) {
-                  events.push(evt);
-                }
-                return events;
-              })
-            );
-            for (const events of eventSets) {
-              for (const evt of events) {
-                yield evt;
-              }
-            }
-            progress = true;
-          }
-        }
-        if (this.gadgetsAwaitingDependencies.size > 0) {
-          const pendingIds = new Set(this.gadgetsAwaitingDependencies.keys());
-          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
-            const missingDeps = call.dependencies.filter((dep) => !this.completedResults.has(dep));
-            const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
-            const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
-            let errorMessage;
-            let logLevel = "warn";
-            if (circularDeps.length > 0 && trulyMissingDeps.length > 0) {
-              errorMessage = `Dependencies unresolvable: circular=[${circularDeps.join(", ")}], missing=[${trulyMissingDeps.join(", ")}]`;
-              logLevel = "error";
-            } else if (circularDeps.length > 0) {
-              errorMessage = `Circular dependency detected: "${invocationId}" depends on "${circularDeps[0]}" which also depends on "${invocationId}" (directly or indirectly)`;
-            } else {
-              errorMessage = `Dependency "${missingDeps[0]}" was never executed - check that the invocation ID exists and is spelled correctly`;
-            }
-            this.logger[logLevel]("Gadget has unresolvable dependencies", {
-              gadgetName: call.gadgetName,
-              invocationId,
-              circularDependencies: circularDeps,
-              missingDependencies: trulyMissingDeps
-            });
-            this.failedInvocations.add(invocationId);
-            const skipEvent = {
-              type: "gadget_skipped",
-              gadgetName: call.gadgetName,
-              invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: missingDeps[0],
-              failedDependencyError: errorMessage
-            };
-            yield skipEvent;
-          }
-          this.gadgetsAwaitingDependencies.clear();
-        }
-      }
-      /**
-       * Safely execute an observer, catching and logging any errors.
-       * Observers are non-critical, so errors are logged but don't crash the system.
+       * Safely execute an observer, catching and logging any errors.
+       * Observers are non-critical, so errors are logged but don't crash the system.
        */
       async safeObserve(fn) {
         try {
@@ -8829,16 +8734,33 @@ 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);
+      }
     };
   }
 });
 
 // src/agent/agent.ts
-var Agent;
+var import_p_retry, Agent;
 var init_agent = __esm({
   "src/agent/agent.ts"() {
     "use strict";
@@ -8850,6 +8772,8 @@ var init_agent = __esm({
     init_output_viewer();
     init_logger();
     init_agent_internal_key();
+    init_retry();
+    import_p_retry = __toESM(require("p-retry"), 1);
     init_manager();
     init_conversation_manager();
     init_event_handlers();
@@ -8884,6 +8808,8 @@ var init_agent = __esm({
       mediaStore;
       // Cancellation
       signal;
+      // Retry configuration
+      retryConfig;
       // Subagent configuration
       agentContextConfig;
       subagentConfig;
@@ -8895,6 +8821,11 @@ 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();
+      // Queue for user messages injected during agent execution (REPL mid-session input)
+      pendingUserMessages = [];
       // Execution Tree - first-class model for nested subagent support
       tree;
       parentNodeId;
@@ -8969,6 +8900,7 @@ var init_agent = __esm({
           );
         }
         this.signal = options.signal;
+        this.retryConfig = resolveRetryConfig(options.retryConfig);
         this.agentContextConfig = {
           model: this.model,
           temperature: this.temperature
@@ -9186,6 +9118,44 @@ var init_agent = __esm({
       getCompactionStats() {
         return this.compactionManager?.getStats() ?? null;
       }
+      /**
+       * Get the conversation manager for this agent.
+       * Used by REPL mode to extract session history for continuation.
+       *
+       * @returns The conversation manager containing all messages
+       *
+       * @example
+       * ```typescript
+       * // After running agent, extract history for next session
+       * const history = agent.getConversation().getConversationHistory();
+       * // Pass to next agent via builder.withHistory()
+       * ```
+       */
+      getConversation() {
+        return this.conversation;
+      }
+      /**
+       * Inject a user message to be processed in the next iteration.
+       * Used by REPL mode to allow user input during a running session.
+       *
+       * The message is queued and will be added to the conversation before
+       * the next LLM call. This allows users to provide additional context
+       * or instructions while the agent is executing.
+       *
+       * @param message - The user message to inject
+       *
+       * @example
+       * ```typescript
+       * // While agent is running in TUI:
+       * tui.onMidSessionInput((msg) => {
+       *   agent.injectUserMessage(msg);
+       * });
+       * ```
+       */
+      injectUserMessage(message) {
+        this.pendingUserMessages.push(message);
+        this.logger.debug("User message queued for injection", { message });
+      }
       /**
        * Run the agent loop.
        * Clean, simple orchestration - all complexity is in StreamProcessor.
@@ -9204,96 +9174,30 @@ var init_agent = __esm({
           maxIterations: this.maxIterations
         });
         while (currentIteration < this.maxIterations) {
-          if (this.signal?.aborted) {
-            this.logger.info("Agent loop terminated by abort signal", {
+          if (await this.checkAbortAndNotify(currentIteration)) {
+            return;
+          }
+          while (this.pendingUserMessages.length > 0) {
+            const msg = this.pendingUserMessages.shift();
+            this.conversation.addUserMessage(msg);
+            this.logger.info("Injected user message into conversation", {
               iteration: currentIteration,
-              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);
-              }
+              messageLength: msg.length
             });
-            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,
@@ -9309,7 +9213,7 @@ var init_agent = __esm({
               request: llmOptions.messages
             });
             const currentLLMNodeId = llmNode.id;
-            const stream2 = this.client.stream(llmOptions);
+            const stream2 = await this.createStreamWithRetry(llmOptions, currentIteration);
             const processor = new StreamProcessor({
               iteration: currentIteration,
               registry: this.registry,
@@ -9329,7 +9233,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;
@@ -9352,6 +9259,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,
@@ -9375,81 +9288,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");
@@ -9485,6 +9338,53 @@ var init_agent = __esm({
           reason: currentIteration >= this.maxIterations ? "max_iterations" : "natural_completion"
         });
       }
+      /**
+       * Create LLM stream with retry logic.
+       * Wraps the stream creation with exponential backoff for transient failures.
+       */
+      async createStreamWithRetry(llmOptions, iteration) {
+        if (!this.retryConfig.enabled) {
+          return this.client.stream(llmOptions);
+        }
+        const { retries, minTimeout, maxTimeout, factor, randomize, onRetry, onRetriesExhausted, shouldRetry } = this.retryConfig;
+        try {
+          return await (0, import_p_retry.default)(
+            async (attemptNumber) => {
+              this.logger.debug("Creating LLM stream", { attempt: attemptNumber, maxAttempts: retries + 1 });
+              return this.client.stream(llmOptions);
+            },
+            {
+              retries,
+              minTimeout,
+              maxTimeout,
+              factor,
+              randomize,
+              signal: this.signal,
+              onFailedAttempt: (context) => {
+                const { error, attemptNumber, retriesLeft } = context;
+                this.logger.warn(
+                  `LLM call failed (attempt ${attemptNumber}/${attemptNumber + retriesLeft}), retrying...`,
+                  { error: error.message, retriesLeft }
+                );
+                onRetry?.(error, attemptNumber);
+              },
+              shouldRetry: (context) => {
+                if (shouldRetry) {
+                  return shouldRetry(context.error);
+                }
+                return isRetryableError(context.error);
+              }
+            }
+          );
+        } catch (error) {
+          this.logger.error(`LLM call failed after ${retries + 1} attempts`, {
+            error: error.message,
+            iteration
+          });
+          onRetriesExhausted?.(error, retries + 1);
+          throw error;
+        }
+      }
       /**
        * Handle LLM error through controller.
        */
@@ -9602,6 +9502,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).
        *
@@ -9658,6 +9762,7 @@ var init_builder = __esm({
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
       compactionConfig;
+      retryConfig;
       signal;
       trailingMessage;
       subagentConfig;
@@ -9828,37 +9933,90 @@ var init_builder = __esm({
         return this.withHistory([message]);
       }
       /**
-       * Set the human input handler for interactive conversations.
+       * Clear any previously set conversation history.
+       * Used before setting new cumulative history in REPL mode.
        *
-       * @param handler - Function to handle human input requests
        * @returns This builder for chaining
        *
        * @example
        * ```typescript
-       * .onHumanInput(async (question) => {
-       *   return await promptUser(question);
-       * })
+       * // Reset history before setting new cumulative history
+       * builder.clearHistory().withHistory(cumulativeHistory);
        * ```
        */
-      onHumanInput(handler) {
-        this.requestHumanInput = handler;
+      clearHistory() {
+        this.initialMessages = [];
         return this;
       }
       /**
-       * Set custom gadget marker prefix.
+       * Continue conversation from a previous agent's history.
+       * Extracts full conversation history and sets it as initial messages.
        *
-       * @param prefix - Custom start prefix for gadget markers
+       * This is the recommended way to implement REPL session continuation.
+       * It automatically handles history extraction and format conversion.
+       *
+       * @param agent - The previous agent to continue from
        * @returns This builder for chaining
        *
        * @example
        * ```typescript
-       * .withGadgetStartPrefix("<<GADGET_START>>")
+       * // REPL loop with session continuity
+       * let previousAgent: Agent | null = null;
+       *
+       * while (true) {
+       *   if (previousAgent) {
+       *     builder.continueFrom(previousAgent);
+       *   }
+       *   const agent = builder.ask(prompt);
+       *   await runAgent(agent);
+       *   previousAgent = agent;
+       * }
        * ```
        */
-      withGadgetStartPrefix(prefix) {
-        this.gadgetStartPrefix = prefix;
-        return this;
-      }
+      continueFrom(agent) {
+        const history = agent.getConversation().getConversationHistory();
+        this.clearHistory();
+        for (const msg of history) {
+          if (msg.role === "user") {
+            this.initialMessages.push({ role: "user", content: msg.content });
+          } else if (msg.role === "assistant") {
+            this.initialMessages.push({ role: "assistant", content: msg.content });
+          }
+        }
+        return this;
+      }
+      /**
+       * Set the human input handler for interactive conversations.
+       *
+       * @param handler - Function to handle human input requests
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .onHumanInput(async (question) => {
+       *   return await promptUser(question);
+       * })
+       * ```
+       */
+      onHumanInput(handler) {
+        this.requestHumanInput = handler;
+        return this;
+      }
+      /**
+       * Set custom gadget marker prefix.
+       *
+       * @param prefix - Custom start prefix for gadget markers
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withGadgetStartPrefix("<<GADGET_START>>")
+       * ```
+       */
+      withGadgetStartPrefix(prefix) {
+        this.gadgetStartPrefix = prefix;
+        return this;
+      }
       /**
        * Set custom gadget marker suffix.
        *
@@ -10055,6 +10213,60 @@ var init_builder = __esm({
         this.compactionConfig = { enabled: false };
         return this;
       }
+      /**
+       * Configure retry behavior for LLM API calls.
+       *
+       * Retry is enabled by default with conservative settings (3 retries, exponential backoff).
+       * Use this method to customize retry behavior for rate limits, timeouts, and transient errors.
+       *
+       * @param config - Retry configuration options
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // Custom retry configuration
+       * .withRetry({
+       *   retries: 5,
+       *   minTimeout: 2000,
+       *   maxTimeout: 60000,
+       * })
+       *
+       * // With monitoring callbacks
+       * .withRetry({
+       *   onRetry: (error, attempt) => {
+       *     console.log(`Retry ${attempt}: ${error.message}`);
+       *   },
+       *   onRetriesExhausted: (error, attempts) => {
+       *     alerting.warn(`Failed after ${attempts} attempts`);
+       *   }
+       * })
+       *
+       * // Custom retry logic
+       * .withRetry({
+       *   shouldRetry: (error) => error.message.includes('429'),
+       * })
+       * ```
+       */
+      withRetry(config) {
+        this.retryConfig = { ...config, enabled: config.enabled ?? true };
+        return this;
+      }
+      /**
+       * Disable automatic retry for LLM API calls.
+       *
+       * By default, retry is enabled. Use this method to explicitly disable it.
+       *
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withoutRetry() // Disable automatic retry
+       * ```
+       */
+      withoutRetry() {
+        this.retryConfig = { enabled: false };
+        return this;
+      }
       /**
        * Set an abort signal for cancelling requests mid-flight.
        *
@@ -10372,6 +10584,7 @@ ${endPrefix}`
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
+          retryConfig: this.retryConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
           onSubagentEvent: this.subagentEventCallback,
@@ -10557,6 +10770,7 @@ ${endPrefix}`
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
+          retryConfig: this.retryConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
           onSubagentEvent: this.subagentEventCallback,
@@ -10576,6 +10790,7 @@ var index_exports = {};
 __export(index_exports, {
   AbortException: () => AbortException,
   AbstractGadget: () => AbstractGadget,
+  Agent: () => Agent,
   AgentBuilder: () => AgentBuilder,
   AnthropicMessagesProvider: () => AnthropicMessagesProvider,
   CompactionManager: () => CompactionManager,
@@ -10583,8 +10798,13 @@ __export(index_exports, {
   DEFAULT_COMPACTION_CONFIG: () => DEFAULT_COMPACTION_CONFIG,
   DEFAULT_HINTS: () => DEFAULT_HINTS,
   DEFAULT_PROMPTS: () => DEFAULT_PROMPTS,
+  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
   DEFAULT_SUMMARIZATION_PROMPT: () => DEFAULT_SUMMARIZATION_PROMPT,
   ExecutionTree: () => ExecutionTree,
+  FALLBACK_CHARS_PER_TOKEN: () => FALLBACK_CHARS_PER_TOKEN,
+  GADGET_ARG_PREFIX: () => GADGET_ARG_PREFIX,
+  GADGET_END_PREFIX: () => GADGET_END_PREFIX,
+  GADGET_START_PREFIX: () => GADGET_START_PREFIX,
   Gadget: () => Gadget,
   GadgetCallParser: () => GadgetCallParser,
   GadgetExecutor: () => GadgetExecutor,
@@ -10598,9 +10818,6 @@ __export(index_exports, {
   LLMist: () => LLMist,
   MODEL_ALIASES: () => MODEL_ALIASES,
   MediaStore: () => MediaStore,
-  MockBuilder: () => MockBuilder,
-  MockManager: () => MockManager,
-  MockProviderAdapter: () => MockProviderAdapter,
   ModelIdentifierParser: () => ModelIdentifierParser,
   ModelRegistry: () => ModelRegistry,
   OpenAIChatProvider: () => OpenAIChatProvider,
@@ -10621,11 +10838,7 @@ __export(index_exports, {
   createHints: () => createHints,
   createLogger: () => createLogger,
   createMediaOutput: () => createMediaOutput,
-  createMockAdapter: () => createMockAdapter,
-  createMockClient: () => createMockClient,
-  createMockStream: () => createMockStream,
   createOpenAIProviderFromEnv: () => createOpenAIProviderFromEnv,
-  createTextMockStream: () => createTextMockStream,
   defaultLogger: () => defaultLogger,
   detectAudioMimeType: () => detectAudioMimeType,
   detectImageMimeType: () => detectImageMimeType,
@@ -10634,8 +10847,8 @@ __export(index_exports, {
   filterByDepth: () => filterByDepth,
   filterByParent: () => filterByParent,
   filterRootEvents: () => filterRootEvents,
+  formatLLMError: () => formatLLMError,
   getHostExports: () => getHostExports,
-  getMockManager: () => getMockManager,
   getModelId: () => getModelId,
   getProvider: () => getProvider,
   groupByParent: () => groupByParent,
@@ -10643,16 +10856,17 @@ __export(index_exports, {
   imageFromBase64: () => imageFromBase64,
   imageFromBuffer: () => imageFromBuffer,
   imageFromUrl: () => imageFromUrl,
+  isAbortError: () => isAbortError,
   isAudioPart: () => isAudioPart,
   isDataUrl: () => isDataUrl,
   isGadgetEvent: () => isGadgetEvent,
   isImagePart: () => isImagePart,
   isLLMEvent: () => isLLMEvent,
+  isRetryableError: () => isRetryableError,
   isRootEvent: () => isRootEvent,
   isSubagentEvent: () => isSubagentEvent,
   isTextPart: () => isTextPart,
   iterationProgressHint: () => iterationProgressHint,
-  mockLLM: () => mockLLM,
   normalizeMessageContent: () => normalizeMessageContent,
   parallelGadgetHint: () => parallelGadgetHint,
   parseDataUrl: () => parseDataUrl,
@@ -10660,6 +10874,7 @@ __export(index_exports, {
   resolveHintTemplate: () => resolveHintTemplate,
   resolveModel: () => resolveModel,
   resolvePromptTemplate: () => resolvePromptTemplate,
+  resolveRetryConfig: () => resolveRetryConfig,
   resolveRulesTemplate: () => resolveRulesTemplate,
   resolveSubagentModel: () => resolveSubagentModel,
   resolveValue: () => resolveValue,
@@ -10669,15 +10884,19 @@ __export(index_exports, {
   resultWithImages: () => resultWithImages,
   resultWithMedia: () => resultWithMedia,
   runWithHandlers: () => runWithHandlers,
+  schemaToJSONSchema: () => schemaToJSONSchema,
   stream: () => stream,
   text: () => text,
   toBase64: () => toBase64,
   validateAndApplyDefaults: () => validateAndApplyDefaults,
   validateGadgetParams: () => validateGadgetParams,
+  validateGadgetSchema: () => validateGadgetSchema,
   z: () => import_zod3.z
 });
 module.exports = __toCommonJS(index_exports);
 var import_zod3 = require("zod");
+init_constants();
+init_constants2();
 init_builder();
 init_event_handlers();
 
@@ -11460,7 +11679,6 @@ var HookPresets = class _HookPresets {
 init_config();
 init_manager();
 init_strategies();
-init_strategy();
 
 // src/agent/index.ts
 init_conversation_manager();
@@ -11568,6 +11786,23 @@ init_stream_processor();
 
 // src/index.ts
 init_client();
+
+// src/core/errors.ts
+function isAbortError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.name === "AbortError") return true;
+  if (error.name === "APIConnectionAbortedError") return true;
+  if (error.name === "APIUserAbortError") return true;
+  const message = error.message.toLowerCase();
+  if (message.includes("abort")) return true;
+  if (message.includes("cancelled")) return true;
+  if (message.includes("canceled")) return true;
+  return false;
+}
+
+// src/index.ts
+init_agent();
+init_retry();
 init_execution_tree();
 
 // src/core/execution-events.ts
@@ -11765,6 +12000,8 @@ function validateGadgetParams(gadget, params) {
 }
 
 // src/index.ts
+init_schema_to_json();
+init_schema_validator();
 init_logger();
 
 // src/utils/config-resolver.ts
@@ -11816,1006 +12053,6 @@ init_anthropic();
 init_discovery();
 init_gemini();
 init_openai();
-
-// src/testing/cli-helpers.ts
-var import_node_stream = require("stream");
-
-// src/testing/mock-manager.ts
-init_logger();
-var MockManager = class _MockManager {
-  static instance = null;
-  mocks = /* @__PURE__ */ new Map();
-  stats = /* @__PURE__ */ new Map();
-  options;
-  logger;
-  nextId = 1;
-  constructor(options = {}) {
-    this.options = {
-      strictMode: options.strictMode ?? false,
-      debug: options.debug ?? false,
-      recordStats: options.recordStats ?? true
-    };
-    this.logger = createLogger({ name: "MockManager", minLevel: this.options.debug ? 2 : 3 });
-  }
-  /**
-   * Get the global MockManager instance.
-   * Creates one if it doesn't exist.
-   */
-  static getInstance(options) {
-    if (!_MockManager.instance) {
-      _MockManager.instance = new _MockManager(options);
-    } else if (options) {
-      console.warn(
-        "MockManager.getInstance() called with options, but instance already exists. Options are ignored. Use setOptions() to update options or reset() to reinitialize."
-      );
-    }
-    return _MockManager.instance;
-  }
-  /**
-   * Reset the global instance (useful for testing).
-   */
-  static reset() {
-    _MockManager.instance = null;
-  }
-  /**
-   * Register a new mock.
-   *
-   * @param registration - The mock registration configuration
-   * @returns The ID of the registered mock
-   *
-   * @example
-   * const manager = MockManager.getInstance();
-   * const mockId = manager.register({
-   *   label: 'GPT-4 mock',
-   *   matcher: (ctx) => ctx.modelName.includes('gpt-4'),
-   *   response: { text: 'Mocked response' }
-   * });
-   */
-  register(registration) {
-    const id = registration.id ?? `mock-${this.nextId++}`;
-    const mock = {
-      id,
-      matcher: registration.matcher,
-      response: registration.response,
-      label: registration.label,
-      once: registration.once
-    };
-    this.mocks.set(id, mock);
-    if (this.options.recordStats) {
-      this.stats.set(id, { matchCount: 0 });
-    }
-    this.logger.debug(
-      `Registered mock: ${id}${mock.label ? ` (${mock.label})` : ""}${mock.once ? " [once]" : ""}`
-    );
-    return id;
-  }
-  /**
-   * Unregister a mock by ID.
-   */
-  unregister(id) {
-    const deleted = this.mocks.delete(id);
-    if (deleted) {
-      this.stats.delete(id);
-      this.logger.debug(`Unregistered mock: ${id}`);
-    }
-    return deleted;
-  }
-  /**
-   * Clear all registered mocks.
-   */
-  clear() {
-    this.mocks.clear();
-    this.stats.clear();
-    this.logger.debug("Cleared all mocks");
-  }
-  /**
-   * Find and return a matching mock for the given context.
-   * Returns the mock response if found, null otherwise.
-   */
-  async findMatch(context) {
-    this.logger.debug(
-      `Finding match for: ${context.provider}:${context.modelName} (${this.mocks.size} mocks registered)`
-    );
-    for (const [id, mock] of this.mocks.entries()) {
-      let matches = false;
-      try {
-        matches = await Promise.resolve(mock.matcher(context));
-      } catch (error) {
-        this.logger.warn(`Error in matcher ${id}:`, error);
-        if (this.options.strictMode) {
-          throw new Error(`Matcher error in mock ${id}: ${error}`);
-        }
-        continue;
-      }
-      if (matches) {
-        this.logger.debug(`Mock matched: ${id}${mock.label ? ` (${mock.label})` : ""}`);
-        if (this.options.recordStats) {
-          const stats = this.stats.get(id);
-          if (stats) {
-            stats.matchCount++;
-            stats.lastUsed = /* @__PURE__ */ new Date();
-          }
-        }
-        if (mock.once) {
-          this.mocks.delete(id);
-          this.stats.delete(id);
-          this.logger.debug(`Removed one-time mock: ${id}`);
-        }
-        const response = typeof mock.response === "function" ? await Promise.resolve(mock.response(context)) : mock.response;
-        return response;
-      }
-    }
-    this.logger.debug("No mock matched");
-    if (this.options.strictMode) {
-      throw new Error(
-        `No mock registered for ${context.provider}:${context.modelName}. Register a mock using MockManager.getInstance().register() or disable strictMode.`
-      );
-    }
-    return {
-      text: "",
-      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-      finishReason: "stop"
-    };
-  }
-  /**
-   * Get statistics for a specific mock.
-   */
-  getStats(id) {
-    return this.stats.get(id);
-  }
-  /**
-   * Get all registered mock IDs.
-   */
-  getMockIds() {
-    return Array.from(this.mocks.keys());
-  }
-  /**
-   * Get the number of registered mocks.
-   */
-  getCount() {
-    return this.mocks.size;
-  }
-  /**
-   * Update the mock manager options.
-   */
-  setOptions(options) {
-    this.options = { ...this.options, ...options };
-    this.logger = createLogger({ name: "MockManager", minLevel: this.options.debug ? 2 : 3 });
-  }
-};
-function getMockManager(options) {
-  return MockManager.getInstance(options);
-}
-
-// src/testing/mock-stream.ts
-init_constants();
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function generateInvocationId() {
-  return `inv-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function splitIntoChunks(text3, minChunkSize = 5, maxChunkSize = 30) {
-  const chunks = [];
-  let remaining = text3;
-  while (remaining.length > 0) {
-    const chunkSize = Math.min(
-      Math.floor(Math.random() * (maxChunkSize - minChunkSize + 1)) + minChunkSize,
-      remaining.length
-    );
-    let chunk;
-    if (chunkSize < remaining.length) {
-      const substr = remaining.substring(0, chunkSize);
-      const lastSpace = substr.lastIndexOf(" ");
-      if (lastSpace > minChunkSize / 2) {
-        chunk = substr.substring(0, lastSpace + 1);
-      } else {
-        chunk = substr;
-      }
-    } else {
-      chunk = remaining;
-    }
-    chunks.push(chunk);
-    remaining = remaining.substring(chunk.length);
-  }
-  return chunks;
-}
-function serializeToBlockFormat(obj, prefix = "") {
-  let result = "";
-  for (const [key, value] of Object.entries(obj)) {
-    const pointer = prefix ? `${prefix}/${key}` : key;
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        const item = value[i];
-        const itemPointer = `${pointer}/${i}`;
-        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
-          result += serializeToBlockFormat(item, itemPointer);
-        } else if (Array.isArray(item)) {
-          for (let j = 0; j < item.length; j++) {
-            result += `${GADGET_ARG_PREFIX}${itemPointer}/${j}
-${String(item[j])}
-`;
-          }
-        } else {
-          result += `${GADGET_ARG_PREFIX}${itemPointer}
-${String(item)}
-`;
-        }
-      }
-    } else if (typeof value === "object") {
-      result += serializeToBlockFormat(value, pointer);
-    } else {
-      result += `${GADGET_ARG_PREFIX}${pointer}
-${String(value)}
-`;
-    }
-  }
-  return result;
-}
-function formatGadgetCalls(gadgetCalls) {
-  let text3 = "";
-  const calls = [];
-  for (const call of gadgetCalls) {
-    const invocationId = call.invocationId ?? generateInvocationId();
-    calls.push({ name: call.gadgetName, invocationId });
-    const blockParams = serializeToBlockFormat(call.parameters);
-    text3 += `
-${GADGET_START_PREFIX}${call.gadgetName}
-${blockParams}${GADGET_END_PREFIX}`;
-  }
-  return { text: text3, calls };
-}
-async function* createMockStream(response) {
-  if (response.delayMs) {
-    await sleep(response.delayMs);
-  }
-  const streamDelay = response.streamDelayMs ?? 0;
-  let fullText = response.text ?? "";
-  if (response.gadgetCalls && response.gadgetCalls.length > 0) {
-    const { text: gadgetText } = formatGadgetCalls(response.gadgetCalls);
-    fullText += gadgetText;
-  }
-  if (fullText.length > 0) {
-    const chunks = streamDelay > 0 ? splitIntoChunks(fullText) : [fullText];
-    for (let i = 0; i < chunks.length; i++) {
-      const isLast = i === chunks.length - 1;
-      const chunk = {
-        text: chunks[i]
-      };
-      if (isLast) {
-        if (response.finishReason !== void 0) {
-          chunk.finishReason = response.finishReason;
-        }
-        if (response.usage) {
-          chunk.usage = response.usage;
-        }
-      }
-      yield chunk;
-      if (streamDelay > 0 && !isLast) {
-        await sleep(streamDelay);
-      }
-    }
-  } else {
-    yield {
-      text: "",
-      finishReason: response.finishReason ?? "stop",
-      usage: response.usage ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
-    };
-  }
-}
-function createTextMockStream(text3, options) {
-  return createMockStream({
-    text: text3,
-    delayMs: options?.delayMs,
-    streamDelayMs: options?.streamDelayMs,
-    usage: options?.usage,
-    finishReason: "stop"
-  });
-}
-
-// src/testing/mock-adapter.ts
-var MockProviderAdapter = class {
-  providerId = "mock";
-  priority = 100;
-  // High priority: check mocks before real providers
-  mockManager;
-  constructor(options) {
-    this.mockManager = getMockManager(options);
-  }
-  supports(_descriptor) {
-    return true;
-  }
-  stream(options, descriptor, _spec) {
-    const context = {
-      model: options.model,
-      provider: descriptor.provider,
-      modelName: descriptor.name,
-      options,
-      messages: options.messages
-    };
-    return this.createMockStreamFromContext(context);
-  }
-  async *createMockStreamFromContext(context) {
-    const mockResponse = await this.mockManager.findMatch(context);
-    if (!mockResponse) {
-      yield {
-        text: "",
-        finishReason: "stop",
-        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
-      };
-      return;
-    }
-    yield* createMockStream(mockResponse);
-  }
-  // ==========================================================================
-  // Image Generation Support
-  // ==========================================================================
-  /**
-   * Check if this adapter supports image generation for a given model.
-   * Returns true if there's a registered mock with images for this model.
-   */
-  supportsImageGeneration(_modelId) {
-    return true;
-  }
-  /**
-   * Generate mock images based on registered mocks.
-   *
-   * @param options - Image generation options
-   * @returns Mock image generation result
-   */
-  async generateImage(options) {
-    const context = {
-      model: options.model,
-      provider: "mock",
-      modelName: options.model,
-      options: {
-        model: options.model,
-        messages: [{ role: "user", content: options.prompt }]
-      },
-      messages: [{ role: "user", content: options.prompt }]
-    };
-    const mockResponse = await this.mockManager.findMatch(context);
-    if (!mockResponse?.images || mockResponse.images.length === 0) {
-      throw new Error(
-        `No mock registered for image generation with model "${options.model}". Use mockLLM().forModel("${options.model}").returnsImage(...).register() to add one.`
-      );
-    }
-    return this.createImageResult(options, mockResponse);
-  }
-  /**
-   * Transform mock response into ImageGenerationResult format.
-   *
-   * @param options - Original image generation options
-   * @param mockResponse - Mock response containing image data
-   * @returns ImageGenerationResult with mock data and zero cost
-   */
-  createImageResult(options, mockResponse) {
-    const images = mockResponse.images ?? [];
-    return {
-      images: images.map((img) => ({
-        b64Json: img.data,
-        revisedPrompt: img.revisedPrompt
-      })),
-      model: options.model,
-      usage: {
-        imagesGenerated: images.length,
-        size: options.size ?? "1024x1024",
-        quality: options.quality ?? "standard"
-      },
-      cost: 0
-      // Mock cost is always 0
-    };
-  }
-  // ==========================================================================
-  // Speech Generation Support
-  // ==========================================================================
-  /**
-   * Check if this adapter supports speech generation for a given model.
-   * Returns true if there's a registered mock with audio for this model.
-   */
-  supportsSpeechGeneration(_modelId) {
-    return true;
-  }
-  /**
-   * Generate mock speech based on registered mocks.
-   *
-   * @param options - Speech generation options
-   * @returns Mock speech generation result
-   */
-  async generateSpeech(options) {
-    const context = {
-      model: options.model,
-      provider: "mock",
-      modelName: options.model,
-      options: {
-        model: options.model,
-        messages: [{ role: "user", content: options.input }]
-      },
-      messages: [{ role: "user", content: options.input }]
-    };
-    const mockResponse = await this.mockManager.findMatch(context);
-    if (!mockResponse?.audio) {
-      throw new Error(
-        `No mock registered for speech generation with model "${options.model}". Use mockLLM().forModel("${options.model}").returnsAudio(...).register() to add one.`
-      );
-    }
-    return this.createSpeechResult(options, mockResponse);
-  }
-  /**
-   * Transform mock response into SpeechGenerationResult format.
-   * Converts base64 audio data to ArrayBuffer.
-   *
-   * @param options - Original speech generation options
-   * @param mockResponse - Mock response containing audio data
-   * @returns SpeechGenerationResult with mock data and zero cost
-   */
-  createSpeechResult(options, mockResponse) {
-    const audio = mockResponse.audio;
-    const binaryString = atob(audio.data);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    const format = this.mimeTypeToAudioFormat(audio.mimeType);
-    return {
-      audio: bytes.buffer,
-      model: options.model,
-      usage: {
-        characterCount: options.input.length
-      },
-      cost: 0,
-      // Mock cost is always 0
-      format
-    };
-  }
-  /**
-   * Map MIME type to audio format for SpeechGenerationResult.
-   * Defaults to "mp3" for unknown MIME types.
-   *
-   * @param mimeType - Audio MIME type string
-   * @returns Audio format identifier
-   */
-  mimeTypeToAudioFormat(mimeType) {
-    const mapping = {
-      "audio/mp3": "mp3",
-      "audio/mpeg": "mp3",
-      "audio/wav": "wav",
-      "audio/webm": "opus",
-      "audio/ogg": "opus"
-    };
-    return mapping[mimeType] ?? "mp3";
-  }
-};
-function createMockAdapter(options) {
-  return new MockProviderAdapter(options);
-}
-
-// src/testing/mock-builder.ts
-init_input_content();
-init_messages();
-function hasImageContent(content) {
-  if (typeof content === "string") return false;
-  return content.some((part) => isImagePart(part));
-}
-function hasAudioContent(content) {
-  if (typeof content === "string") return false;
-  return content.some((part) => isAudioPart(part));
-}
-function countImages(content) {
-  if (typeof content === "string") return 0;
-  return content.filter((part) => isImagePart(part)).length;
-}
-var MockBuilder = class {
-  matchers = [];
-  response = {};
-  label;
-  isOnce = false;
-  id;
-  /**
-   * Match calls to a specific model (by name, supports partial matching).
-   *
-   * @example
-   * mockLLM().forModel('gpt-5')
-   * mockLLM().forModel('claude') // matches any Claude model
-   */
-  forModel(modelName) {
-    if (!modelName || modelName.trim() === "") {
-      throw new Error("Model name cannot be empty");
-    }
-    this.matchers.push((ctx) => ctx.modelName.includes(modelName));
-    return this;
-  }
-  /**
-   * Match calls to any model.
-   * Useful when you want to mock responses regardless of the model used.
-   *
-   * @example
-   * mockLLM().forAnyModel()
-   */
-  forAnyModel() {
-    this.matchers.push(() => true);
-    return this;
-  }
-  /**
-   * Match calls to a specific provider.
-   *
-   * @example
-   * mockLLM().forProvider('openai')
-   * mockLLM().forProvider('anthropic')
-   */
-  forProvider(provider) {
-    if (!provider || provider.trim() === "") {
-      throw new Error("Provider name cannot be empty");
-    }
-    this.matchers.push((ctx) => ctx.provider === provider);
-    return this;
-  }
-  /**
-   * Match calls to any provider.
-   * Useful when you want to mock responses regardless of the provider used.
-   *
-   * @example
-   * mockLLM().forAnyProvider()
-   */
-  forAnyProvider() {
-    this.matchers.push(() => true);
-    return this;
-  }
-  /**
-   * Match when any message contains the given text (case-insensitive).
-   *
-   * @example
-   * mockLLM().whenMessageContains('hello')
-   */
-  whenMessageContains(text3) {
-    this.matchers.push(
-      (ctx) => ctx.messages.some(
-        (msg) => extractMessageText(msg.content).toLowerCase().includes(text3.toLowerCase())
-      )
-    );
-    return this;
-  }
-  /**
-   * Match when the last message contains the given text (case-insensitive).
-   *
-   * @example
-   * mockLLM().whenLastMessageContains('goodbye')
-   */
-  whenLastMessageContains(text3) {
-    this.matchers.push((ctx) => {
-      const lastMsg = ctx.messages[ctx.messages.length - 1];
-      if (!lastMsg) return false;
-      return extractMessageText(lastMsg.content).toLowerCase().includes(text3.toLowerCase());
-    });
-    return this;
-  }
-  /**
-   * Match when any message matches the given regex.
-   *
-   * @example
-   * mockLLM().whenMessageMatches(/calculate \d+/)
-   */
-  whenMessageMatches(regex) {
-    this.matchers.push((ctx) => ctx.messages.some((msg) => regex.test(extractMessageText(msg.content))));
-    return this;
-  }
-  /**
-   * Match when a message with a specific role contains text.
-   *
-   * @example
-   * mockLLM().whenRoleContains('system', 'You are a helpful assistant')
-   */
-  whenRoleContains(role, text3) {
-    this.matchers.push(
-      (ctx) => ctx.messages.some(
-        (msg) => msg.role === role && extractMessageText(msg.content).toLowerCase().includes(text3.toLowerCase())
-      )
-    );
-    return this;
-  }
-  /**
-   * Match based on the number of messages in the conversation.
-   *
-   * @example
-   * mockLLM().whenMessageCount((count) => count > 10)
-   */
-  whenMessageCount(predicate) {
-    this.matchers.push((ctx) => predicate(ctx.messages.length));
-    return this;
-  }
-  /**
-   * Add a custom matcher function.
-   * This provides full control over matching logic.
-   *
-   * @example
-   * mockLLM().when((ctx) => {
-   *   return ctx.options.temperature > 0.8;
-   * })
-   */
-  when(matcher) {
-    this.matchers.push(matcher);
-    return this;
-  }
-  // ==========================================================================
-  // Multimodal Matchers
-  // ==========================================================================
-  /**
-   * Match when any message contains an image.
-   *
-   * @example
-   * mockLLM().whenMessageHasImage().returns("I see an image of a sunset.")
-   */
-  whenMessageHasImage() {
-    this.matchers.push((ctx) => ctx.messages.some((msg) => hasImageContent(msg.content)));
-    return this;
-  }
-  /**
-   * Match when any message contains audio.
-   *
-   * @example
-   * mockLLM().whenMessageHasAudio().returns("I hear music playing.")
-   */
-  whenMessageHasAudio() {
-    this.matchers.push((ctx) => ctx.messages.some((msg) => hasAudioContent(msg.content)));
-    return this;
-  }
-  /**
-   * Match based on the number of images in the last message.
-   *
-   * @example
-   * mockLLM().whenImageCount((n) => n >= 2).returns("Comparing multiple images...")
-   */
-  whenImageCount(predicate) {
-    this.matchers.push((ctx) => {
-      const lastMsg = ctx.messages[ctx.messages.length - 1];
-      if (!lastMsg) return false;
-      return predicate(countImages(lastMsg.content));
-    });
-    return this;
-  }
-  /**
-   * Set the text response to return.
-   * Can be a static string or a function that returns a string dynamically.
-   *
-   * @example
-   * mockLLM().returns('Hello, world!')
-   * mockLLM().returns(() => `Response at ${Date.now()}`)
-   * mockLLM().returns((ctx) => `You said: ${ctx.messages[0]?.content}`)
-   */
-  returns(text3) {
-    if (typeof text3 === "function") {
-      this.response = async (ctx) => {
-        const resolvedText = await Promise.resolve().then(() => text3(ctx));
-        return { text: resolvedText };
-      };
-    } else {
-      if (typeof this.response === "function") {
-        throw new Error("Cannot use returns() after withResponse() with a function");
-      }
-      this.response.text = text3;
-    }
-    return this;
-  }
-  /**
-   * Set gadget calls to include in the response.
-   *
-   * @example
-   * mockLLM().returnsGadgetCalls([
-   *   { gadgetName: 'calculator', parameters: { op: 'add', a: 1, b: 2 } }
-   * ])
-   */
-  returnsGadgetCalls(calls) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use returnsGadgetCalls() after withResponse() with a function");
-    }
-    this.response.gadgetCalls = calls;
-    return this;
-  }
-  /**
-   * Add a single gadget call to the response.
-   *
-   * @example
-   * mockLLM()
-   *   .returnsGadgetCall('calculator', { op: 'add', a: 1, b: 2 })
-   *   .returnsGadgetCall('logger', { message: 'Done!' })
-   */
-  returnsGadgetCall(gadgetName, parameters) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use returnsGadgetCall() after withResponse() with a function");
-    }
-    if (!this.response.gadgetCalls) {
-      this.response.gadgetCalls = [];
-    }
-    this.response.gadgetCalls.push({ gadgetName, parameters });
-    return this;
-  }
-  // ==========================================================================
-  // Multimodal Response Helpers
-  // ==========================================================================
-  /**
-   * Return a single image in the response.
-   * Useful for mocking image generation endpoints.
-   *
-   * @param data - Image data (base64 string or Buffer)
-   * @param mimeType - MIME type (auto-detected if Buffer provided without type)
-   *
-   * @example
-   * mockLLM()
-   *   .forModel('dall-e-3')
-   *   .returnsImage(pngBuffer)
-   *   .register();
-   */
-  returnsImage(data, mimeType) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use returnsImage() after withResponse() with a function");
-    }
-    let imageData;
-    let imageMime;
-    if (typeof data === "string") {
-      imageData = data;
-      if (!mimeType) {
-        throw new Error("MIME type is required when providing base64 string data");
-      }
-      imageMime = mimeType;
-    } else {
-      imageData = toBase64(data);
-      const detected = mimeType ?? detectImageMimeType(data);
-      if (!detected) {
-        throw new Error(
-          "Could not detect image MIME type. Please provide the mimeType parameter explicitly."
-        );
-      }
-      imageMime = detected;
-    }
-    if (!this.response.images) {
-      this.response.images = [];
-    }
-    this.response.images.push({ data: imageData, mimeType: imageMime });
-    return this;
-  }
-  /**
-   * Return multiple images in the response.
-   *
-   * @example
-   * mockLLM()
-   *   .forModel('dall-e-3')
-   *   .returnsImages([
-   *     { data: pngBuffer1 },
-   *     { data: pngBuffer2 },
-   *   ])
-   *   .register();
-   */
-  returnsImages(images) {
-    for (const img of images) {
-      this.returnsImage(img.data, img.mimeType);
-      if (img.revisedPrompt && this.response && typeof this.response !== "function") {
-        const lastImage = this.response.images?.[this.response.images.length - 1];
-        if (lastImage) {
-          lastImage.revisedPrompt = img.revisedPrompt;
-        }
-      }
-    }
-    return this;
-  }
-  /**
-   * Return audio data in the response.
-   * Useful for mocking speech synthesis endpoints.
-   *
-   * @param data - Audio data (base64 string or Buffer)
-   * @param mimeType - MIME type (auto-detected if Buffer provided without type)
-   *
-   * @example
-   * mockLLM()
-   *   .forModel('tts-1')
-   *   .returnsAudio(mp3Buffer)
-   *   .register();
-   */
-  returnsAudio(data, mimeType) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use returnsAudio() after withResponse() with a function");
-    }
-    let audioData;
-    let audioMime;
-    if (typeof data === "string") {
-      audioData = data;
-      if (!mimeType) {
-        throw new Error("MIME type is required when providing base64 string data");
-      }
-      audioMime = mimeType;
-    } else {
-      audioData = toBase64(data);
-      const detected = mimeType ?? detectAudioMimeType(data);
-      if (!detected) {
-        throw new Error(
-          "Could not detect audio MIME type. Please provide the mimeType parameter explicitly."
-        );
-      }
-      audioMime = detected;
-    }
-    this.response.audio = { data: audioData, mimeType: audioMime };
-    return this;
-  }
-  /**
-   * Set the complete mock response object.
-   * This allows full control over all response properties.
-   * Can also be a function that generates the response dynamically based on context.
-   *
-   * @example
-   * // Static response
-   * mockLLM().withResponse({
-   *   text: 'Hello',
-   *   usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
-   *   finishReason: 'stop'
-   * })
-   *
-   * @example
-   * // Dynamic response
-   * mockLLM().withResponse((ctx) => ({
-   *   text: `You said: ${ctx.messages[ctx.messages.length - 1]?.content}`,
-   *   usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 }
-   * }))
-   */
-  withResponse(response) {
-    this.response = response;
-    return this;
-  }
-  /**
-   * Set simulated token usage.
-   *
-   * @example
-   * mockLLM().withUsage({ inputTokens: 100, outputTokens: 50, totalTokens: 150 })
-   */
-  withUsage(usage) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use withUsage() after withResponse() with a function");
-    }
-    if (usage.inputTokens < 0 || usage.outputTokens < 0 || usage.totalTokens < 0) {
-      throw new Error("Token counts cannot be negative");
-    }
-    if (usage.totalTokens !== usage.inputTokens + usage.outputTokens) {
-      throw new Error("totalTokens must equal inputTokens + outputTokens");
-    }
-    this.response.usage = usage;
-    return this;
-  }
-  /**
-   * Set the finish reason.
-   *
-   * @example
-   * mockLLM().withFinishReason('stop')
-   * mockLLM().withFinishReason('length')
-   */
-  withFinishReason(reason) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use withFinishReason() after withResponse() with a function");
-    }
-    this.response.finishReason = reason;
-    return this;
-  }
-  /**
-   * Set initial delay before streaming starts (simulates network latency).
-   *
-   * @example
-   * mockLLM().withDelay(100) // 100ms delay
-   */
-  withDelay(ms) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use withDelay() after withResponse() with a function");
-    }
-    if (ms < 0) {
-      throw new Error("Delay must be non-negative");
-    }
-    this.response.delayMs = ms;
-    return this;
-  }
-  /**
-   * Set delay between stream chunks (simulates realistic streaming).
-   *
-   * @example
-   * mockLLM().withStreamDelay(10) // 10ms between chunks
-   */
-  withStreamDelay(ms) {
-    if (typeof this.response === "function") {
-      throw new Error("Cannot use withStreamDelay() after withResponse() with a function");
-    }
-    if (ms < 0) {
-      throw new Error("Stream delay must be non-negative");
-    }
-    this.response.streamDelayMs = ms;
-    return this;
-  }
-  /**
-   * Set a label for this mock (useful for debugging).
-   *
-   * @example
-   * mockLLM().withLabel('greeting mock')
-   */
-  withLabel(label) {
-    this.label = label;
-    return this;
-  }
-  /**
-   * Set a specific ID for this mock.
-   *
-   * @example
-   * mockLLM().withId('my-custom-mock-id')
-   */
-  withId(id) {
-    this.id = id;
-    return this;
-  }
-  /**
-   * Mark this mock as one-time use (will be removed after first match).
-   *
-   * @example
-   * mockLLM().once()
-   */
-  once() {
-    this.isOnce = true;
-    return this;
-  }
-  /**
-   * Build the mock registration without registering it.
-   * Useful if you want to register it manually later.
-   *
-   * @returns The built MockRegistration object (without id if not specified)
-   */
-  build() {
-    if (this.matchers.length === 0) {
-      throw new Error(
-        "Mock must have at least one matcher. Use .when(), .forModel(), .forProvider(), etc."
-      );
-    }
-    const combinedMatcher = async (ctx) => {
-      for (const matcher of this.matchers) {
-        const matches = await Promise.resolve(matcher(ctx));
-        if (!matches) return false;
-      }
-      return true;
-    };
-    return {
-      id: this.id,
-      matcher: combinedMatcher,
-      response: this.response,
-      label: this.label,
-      once: this.isOnce
-    };
-  }
-  /**
-   * Register this mock with the global MockManager.
-   * Returns the ID of the registered mock.
-   *
-   * @example
-   * const mockId = mockLLM().forModel('gpt-5').returns('Hello!').register();
-   * // Later: getMockManager().unregister(mockId);
-   */
-  register() {
-    const mockManager = getMockManager();
-    const registration = this.build();
-    return mockManager.register(registration);
-  }
-};
-function mockLLM() {
-  return new MockBuilder();
-}
-
-// src/testing/mock-client.ts
-init_client();
-function createMockClient(options) {
-  return new LLMist({
-    adapters: [new MockProviderAdapter(options)],
-    autoDiscoverProviders: false,
-    defaultProvider: "mock"
-  });
-}
-
-// src/testing/mock-gadget.ts
-init_gadget();
-
-// src/index.ts
 function getHostExports(ctx) {
   if (!ctx?.hostExports) {
     throw new Error(
@@ -12828,6 +12065,7 @@ function getHostExports(ctx) {
 0 && (module.exports = {
   AbortException,
   AbstractGadget,
+  Agent,
   AgentBuilder,
   AnthropicMessagesProvider,
   CompactionManager,
@@ -12835,8 +12073,13 @@ function getHostExports(ctx) {
   DEFAULT_COMPACTION_CONFIG,
   DEFAULT_HINTS,
   DEFAULT_PROMPTS,
+  DEFAULT_RETRY_CONFIG,
   DEFAULT_SUMMARIZATION_PROMPT,
   ExecutionTree,
+  FALLBACK_CHARS_PER_TOKEN,
+  GADGET_ARG_PREFIX,
+  GADGET_END_PREFIX,
+  GADGET_START_PREFIX,
   Gadget,
   GadgetCallParser,
   GadgetExecutor,
@@ -12850,9 +12093,6 @@ function getHostExports(ctx) {
   LLMist,
   MODEL_ALIASES,
   MediaStore,
-  MockBuilder,
-  MockManager,
-  MockProviderAdapter,
   ModelIdentifierParser,
   ModelRegistry,
   OpenAIChatProvider,
@@ -12873,11 +12113,7 @@ function getHostExports(ctx) {
   createHints,
   createLogger,
   createMediaOutput,
-  createMockAdapter,
-  createMockClient,
-  createMockStream,
   createOpenAIProviderFromEnv,
-  createTextMockStream,
   defaultLogger,
   detectAudioMimeType,
   detectImageMimeType,
@@ -12886,8 +12122,8 @@ function getHostExports(ctx) {
   filterByDepth,
   filterByParent,
   filterRootEvents,
+  formatLLMError,
   getHostExports,
-  getMockManager,
   getModelId,
   getProvider,
   groupByParent,
@@ -12895,16 +12131,17 @@ function getHostExports(ctx) {
   imageFromBase64,
   imageFromBuffer,
   imageFromUrl,
+  isAbortError,
   isAudioPart,
   isDataUrl,
   isGadgetEvent,
   isImagePart,
   isLLMEvent,
+  isRetryableError,
   isRootEvent,
   isSubagentEvent,
   isTextPart,
   iterationProgressHint,
-  mockLLM,
   normalizeMessageContent,
   parallelGadgetHint,
   parseDataUrl,
@@ -12912,6 +12149,7 @@ function getHostExports(ctx) {
   resolveHintTemplate,
   resolveModel,
   resolvePromptTemplate,
+  resolveRetryConfig,
   resolveRulesTemplate,
   resolveSubagentModel,
   resolveValue,
@@ -12921,11 +12159,13 @@ function getHostExports(ctx) {
   resultWithImages,
   resultWithMedia,
   runWithHandlers,
+  schemaToJSONSchema,
   stream,
   text,
   toBase64,
   validateAndApplyDefaults,
   validateGadgetParams,
+  validateGadgetSchema,
   z
 });
 //# sourceMappingURL=index.cjs.map