llmist 7.0.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";
@@ -2577,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
+    };
   }
 });
 
@@ -3047,6 +3191,9 @@ var init_conversation_manager = __esm({
           }
         }
       }
+      getConversationHistory() {
+        return [...this.initialMessages, ...this.historyBuilder.build()];
+      }
     };
   }
 });
@@ -3689,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") {
@@ -7807,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
@@ -8624,7 +8760,7 @@ var init_stream_processor = __esm({
 });
 
 // src/agent/agent.ts
-var Agent;
+var import_p_retry, Agent;
 var init_agent = __esm({
   "src/agent/agent.ts"() {
     "use strict";
@@ -8636,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();
@@ -8670,6 +8808,8 @@ var init_agent = __esm({
       mediaStore;
       // Cancellation
       signal;
+      // Retry configuration
+      retryConfig;
       // Subagent configuration
       agentContextConfig;
       subagentConfig;
@@ -8684,6 +8824,8 @@ var init_agent = __esm({
       // 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;
@@ -8758,6 +8900,7 @@ var init_agent = __esm({
           );
         }
         this.signal = options.signal;
+        this.retryConfig = resolveRetryConfig(options.retryConfig);
         this.agentContextConfig = {
           model: this.model,
           temperature: this.temperature
@@ -8975,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.
@@ -8996,6 +9177,14 @@ var init_agent = __esm({
           if (await this.checkAbortAndNotify(currentIteration)) {
             return;
           }
+          while (this.pendingUserMessages.length > 0) {
+            const msg = this.pendingUserMessages.shift();
+            this.conversation.addUserMessage(msg);
+            this.logger.info("Injected user message into conversation", {
+              iteration: currentIteration,
+              messageLength: msg.length
+            });
+          }
           this.logger.debug("Starting iteration", { iteration: currentIteration });
           try {
             const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
@@ -9024,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,
@@ -9149,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.
        */
@@ -9526,6 +9762,7 @@ var init_builder = __esm({
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
       compactionConfig;
+      retryConfig;
       signal;
       trailingMessage;
       subagentConfig;
@@ -9695,6 +9932,59 @@ var init_builder = __esm({
       addMessage(message) {
         return this.withHistory([message]);
       }
+      /**
+       * Clear any previously set conversation history.
+       * Used before setting new cumulative history in REPL mode.
+       *
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // Reset history before setting new cumulative history
+       * builder.clearHistory().withHistory(cumulativeHistory);
+       * ```
+       */
+      clearHistory() {
+        this.initialMessages = [];
+        return this;
+      }
+      /**
+       * Continue conversation from a previous agent's history.
+       * Extracts full conversation history and sets it as initial messages.
+       *
+       * 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
+       * // 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;
+       * }
+       * ```
+       */
+      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.
        *
@@ -9923,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.
        *
@@ -10240,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,
@@ -10425,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,
@@ -10444,6 +10790,7 @@ var index_exports = {};
 __export(index_exports, {
   AbortException: () => AbortException,
   AbstractGadget: () => AbstractGadget,
+  Agent: () => Agent,
   AgentBuilder: () => AgentBuilder,
   AnthropicMessagesProvider: () => AnthropicMessagesProvider,
   CompactionManager: () => CompactionManager,
@@ -10451,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,
@@ -10466,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,
@@ -10489,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,
@@ -10502,8 +10847,8 @@ __export(index_exports, {
   filterByDepth: () => filterByDepth,
   filterByParent: () => filterByParent,
   filterRootEvents: () => filterRootEvents,
+  formatLLMError: () => formatLLMError,
   getHostExports: () => getHostExports,
-  getMockManager: () => getMockManager,
   getModelId: () => getModelId,
   getProvider: () => getProvider,
   groupByParent: () => groupByParent,
@@ -10511,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,
@@ -10528,6 +10874,7 @@ __export(index_exports, {
   resolveHintTemplate: () => resolveHintTemplate,
   resolveModel: () => resolveModel,
   resolvePromptTemplate: () => resolvePromptTemplate,
+  resolveRetryConfig: () => resolveRetryConfig,
   resolveRulesTemplate: () => resolveRulesTemplate,
   resolveSubagentModel: () => resolveSubagentModel,
   resolveValue: () => resolveValue,
@@ -10537,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();
 
@@ -11328,7 +11679,6 @@ var HookPresets = class _HookPresets {
 init_config();
 init_manager();
 init_strategies();
-init_strategy();
 
 // src/agent/index.ts
 init_conversation_manager();
@@ -11436,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
@@ -11633,6 +12000,8 @@ function validateGadgetParams(gadget, params) {
 }
 
 // src/index.ts
+init_schema_to_json();
+init_schema_validator();
 init_logger();
 
 // src/utils/config-resolver.ts
@@ -11684,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(
@@ -12696,6 +12065,7 @@ function getHostExports(ctx) {
 0 && (module.exports = {
   AbortException,
   AbstractGadget,
+  Agent,
   AgentBuilder,
   AnthropicMessagesProvider,
   CompactionManager,
@@ -12703,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,
@@ -12718,9 +12093,6 @@ function getHostExports(ctx) {
   LLMist,
   MODEL_ALIASES,
   MediaStore,
-  MockBuilder,
-  MockManager,
-  MockProviderAdapter,
   ModelIdentifierParser,
   ModelRegistry,
   OpenAIChatProvider,
@@ -12741,11 +12113,7 @@ function getHostExports(ctx) {
   createHints,
   createLogger,
   createMediaOutput,
-  createMockAdapter,
-  createMockClient,
-  createMockStream,
   createOpenAIProviderFromEnv,
-  createTextMockStream,
   defaultLogger,
   detectAudioMimeType,
   detectImageMimeType,
@@ -12754,8 +12122,8 @@ function getHostExports(ctx) {
   filterByDepth,
   filterByParent,
   filterRootEvents,
+  formatLLMError,
   getHostExports,
-  getMockManager,
   getModelId,
   getProvider,
   groupByParent,
@@ -12763,16 +12131,17 @@ function getHostExports(ctx) {
   imageFromBase64,
   imageFromBuffer,
   imageFromUrl,
+  isAbortError,
   isAudioPart,
   isDataUrl,
   isGadgetEvent,
   isImagePart,
   isLLMEvent,
+  isRetryableError,
   isRootEvent,
   isSubagentEvent,
   isTextPart,
   iterationProgressHint,
-  mockLLM,
   normalizeMessageContent,
   parallelGadgetHint,
   parseDataUrl,
@@ -12780,6 +12149,7 @@ function getHostExports(ctx) {
   resolveHintTemplate,
   resolveModel,
   resolvePromptTemplate,
+  resolveRetryConfig,
   resolveRulesTemplate,
   resolveSubagentModel,
   resolveValue,
@@ -12789,11 +12159,13 @@ function getHostExports(ctx) {
   resultWithImages,
   resultWithMedia,
   runWithHandlers,
+  schemaToJSONSchema,
   stream,
   text,
   toBase64,
   validateAndApplyDefaults,
   validateGadgetParams,
+  validateGadgetSchema,
   z
 });
 //# sourceMappingURL=index.cjs.map