llmist 2.5.0 → 3.0.0

package/dist/testing/index.cjs

@@ -134,6 +134,12 @@ function isAudioPart(part) {
 function text(content) {
   return { type: "text", text: content };
 }
+function imageFromBase64(data, mediaType) {
+  return {
+    type: "image",
+    source: { type: "base64", mediaType, data }
+  };
+}
 function imageFromUrl(url) {
   return {
     type: "image",
@@ -194,6 +200,12 @@ function toBase64(data) {
   }
   return Buffer.from(data).toString("base64");
 }
+function audioFromBase64(data, mediaType) {
+  return {
+    type: "audio",
+    source: { type: "base64", mediaType, data }
+  };
+}
 function audioFromBuffer(buffer, mediaType) {
   const detectedType = mediaType ?? detectAudioMimeType(buffer);
   if (!detectedType) {
@@ -240,7 +252,9 @@ var init_input_content = __esm({
       // WAV (RIFF)
       { bytes: [82, 73, 70, 70], mimeType: "audio/wav" },
       // WebM
-      { bytes: [26, 69, 223, 163], mimeType: "audio/webm" }
+      { bytes: [26, 69, 223, 163], mimeType: "audio/webm" },
+      // FLAC (fLaC)
+      { bytes: [102, 76, 97, 67], mimeType: "audio/flac" }
     ];
   }
 });
@@ -287,13 +301,13 @@ var init_prompt_config = __esm({
 });
 
 // src/core/messages.ts
-function normalizeContent(content) {
+function normalizeMessageContent(content) {
   if (typeof content === "string") {
     return [{ type: "text", text: content }];
   }
   return content;
 }
-function extractText(content) {
+function extractMessageText(content) {
   if (typeof content === "string") {
     return content;
   }
@@ -653,7 +667,17 @@ Produces: { "items": ["first", "second"] }`);
         this.messages.push({ role: "user", content: parts });
         return this;
       }
-      addGadgetCall(gadget, parameters, result) {
+      /**
+       * Record a gadget execution result in the message history.
+       * Creates an assistant message with the gadget invocation and a user message with the result.
+       *
+       * @param gadget - Name of the gadget that was executed
+       * @param parameters - Parameters that were passed to the gadget
+       * @param result - Text result from the gadget execution
+       * @param media - Optional media outputs from the gadget
+       * @param mediaIds - Optional IDs for the media outputs
+       */
+      addGadgetCallResult(gadget, parameters, result, media, mediaIds) {
         const paramStr = this.formatBlockParameters(parameters, "");
         this.messages.push({
           role: "assistant",
@@ -661,10 +685,25 @@ Produces: { "items": ["first", "second"] }`);
 ${paramStr}
 ${this.endPrefix}`
         });
-        this.messages.push({
-          role: "user",
-          content: `Result: ${result}`
-        });
+        if (media && media.length > 0 && mediaIds && mediaIds.length > 0) {
+          const idRefs = media.map((m, i) => `[Media: ${mediaIds[i]} (${m.kind})]`).join("\n");
+          const textWithIds = `Result: ${result}
+${idRefs}`;
+          const parts = [text(textWithIds)];
+          for (const item of media) {
+            if (item.kind === "image") {
+              parts.push(imageFromBase64(item.data, item.mimeType));
+            } else if (item.kind === "audio") {
+              parts.push(audioFromBase64(item.data, item.mimeType));
+            }
+          }
+          this.messages.push({ role: "user", content: parts });
+        } else {
+          this.messages.push({
+            role: "user",
+            content: `Result: ${result}`
+          });
+        }
         return this;
       }
       /**
@@ -998,22 +1037,226 @@ var init_registry = __esm({
   }
 });
 
+// src/gadgets/media-store.ts
+function getLlmistTmpDir() {
+  return (0, import_node_path2.join)((0, import_node_os.homedir)(), ".llmist", "tmp");
+}
+var import_node_crypto, import_promises, import_node_os, import_node_path2, MIME_TO_EXTENSION, MediaStore;
+var init_media_store = __esm({
+  "src/gadgets/media-store.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    import_promises = require("fs/promises");
+    import_node_os = require("os");
+    import_node_path2 = require("path");
+    MIME_TO_EXTENSION = {
+      // Images
+      "image/png": ".png",
+      "image/jpeg": ".jpg",
+      "image/gif": ".gif",
+      "image/webp": ".webp",
+      "image/svg+xml": ".svg",
+      "image/bmp": ".bmp",
+      "image/tiff": ".tiff",
+      // Audio
+      "audio/mp3": ".mp3",
+      "audio/mpeg": ".mp3",
+      "audio/wav": ".wav",
+      "audio/webm": ".webm",
+      "audio/ogg": ".ogg",
+      "audio/flac": ".flac",
+      "audio/aac": ".aac",
+      // Video
+      "video/mp4": ".mp4",
+      "video/webm": ".webm",
+      "video/ogg": ".ogv",
+      "video/quicktime": ".mov",
+      "video/x-msvideo": ".avi",
+      // Documents
+      "application/pdf": ".pdf",
+      "application/json": ".json",
+      "text/plain": ".txt",
+      "text/html": ".html",
+      "text/css": ".css",
+      "text/javascript": ".js"
+    };
+    MediaStore = class {
+      items = /* @__PURE__ */ new Map();
+      outputDir;
+      counter = 0;
+      initialized = false;
+      /**
+       * Create a new MediaStore.
+       *
+       * @param sessionId - Optional session ID for the output directory.
+       *                    If not provided, a random ID is generated.
+       */
+      constructor(sessionId) {
+        const id = sessionId ?? (0, import_node_crypto.randomBytes)(8).toString("hex");
+        this.outputDir = (0, import_node_path2.join)(getLlmistTmpDir(), `media-${id}`);
+      }
+      /**
+       * Get the output directory path.
+       */
+      getOutputDir() {
+        return this.outputDir;
+      }
+      /**
+       * Ensure the output directory exists.
+       * @throws Error if directory creation fails
+       */
+      async ensureDir() {
+        if (this.initialized) return;
+        try {
+          await (0, import_promises.mkdir)(this.outputDir, { recursive: true });
+          this.initialized = true;
+        } catch (error) {
+          throw new Error(
+            `MediaStore: Failed to create directory ${this.outputDir}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Generate a unique media ID.
+       * Format: "media_" + 6 random alphanumeric characters
+       */
+      generateId() {
+        const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+        let id = "media_";
+        const bytes = (0, import_node_crypto.randomBytes)(6);
+        for (let i = 0; i < 6; i++) {
+          id += chars[bytes[i] % chars.length];
+        }
+        return id;
+      }
+      /**
+       * Get file extension from MIME type.
+       */
+      getExtension(mimeType) {
+        return MIME_TO_EXTENSION[mimeType] ?? ".bin";
+      }
+      /**
+       * Store media and return stored metadata with ID.
+       *
+       * @param media - The media output from a gadget
+       * @param gadgetName - Name of the gadget that created this media
+       * @returns Stored media information including generated ID
+       * @throws Error if file write fails
+       */
+      async store(media, gadgetName) {
+        await this.ensureDir();
+        const id = this.generateId();
+        const ext = this.getExtension(media.mimeType);
+        const filename = media.fileName ?? `${gadgetName}_${String(++this.counter).padStart(3, "0")}${ext}`;
+        const filePath = (0, import_node_path2.join)(this.outputDir, filename);
+        const buffer = Buffer.from(media.data, "base64");
+        try {
+          await (0, import_promises.writeFile)(filePath, buffer);
+        } catch (error) {
+          throw new Error(
+            `MediaStore: Failed to write media file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        const stored = {
+          id,
+          kind: media.kind,
+          path: filePath,
+          mimeType: media.mimeType,
+          sizeBytes: buffer.length,
+          description: media.description,
+          metadata: media.metadata,
+          gadgetName,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.items.set(id, stored);
+        return stored;
+      }
+      /**
+       * Get stored media by ID.
+       *
+       * @param id - The media ID (e.g., "media_a1b2c3")
+       * @returns The stored media or undefined if not found
+       */
+      get(id) {
+        return this.items.get(id);
+      }
+      /**
+       * Get the actual file path for a media ID.
+       * Convenience method for gadgets that need the raw path.
+       *
+       * @param id - The media ID
+       * @returns The file path or undefined if not found
+       */
+      getPath(id) {
+        return this.items.get(id)?.path;
+      }
+      /**
+       * List all stored media, optionally filtered by kind.
+       *
+       * @param kind - Optional media kind to filter by
+       * @returns Array of stored media items
+       */
+      list(kind) {
+        const all = Array.from(this.items.values());
+        if (kind) {
+          return all.filter((item) => item.kind === kind);
+        }
+        return all;
+      }
+      /**
+       * Get the count of stored media items.
+       */
+      get size() {
+        return this.items.size;
+      }
+      /**
+       * Check if a media ID exists.
+       */
+      has(id) {
+        return this.items.has(id);
+      }
+      /**
+       * Clear in-memory store without deleting files.
+       * Resets the counter but leaves files on disk.
+       */
+      clear() {
+        this.items.clear();
+        this.counter = 0;
+      }
+      /**
+       * Delete all stored files and clear memory.
+       * Removes the entire session directory.
+       */
+      async cleanup() {
+        if (this.initialized) {
+          try {
+            await (0, import_promises.rm)(this.outputDir, { recursive: true, force: true });
+          } catch {
+          }
+          this.initialized = false;
+        }
+        this.clear();
+      }
+    };
+  }
+});
+
 // src/gadgets/exceptions.ts
-var BreakLoopException, HumanInputException, TimeoutException, AbortError;
+var TaskCompletionSignal, HumanInputRequiredException, TimeoutException, AbortException;
 var init_exceptions = __esm({
   "src/gadgets/exceptions.ts"() {
     "use strict";
-    BreakLoopException = class extends Error {
+    TaskCompletionSignal = class extends Error {
       constructor(message) {
         super(message ?? "Agent loop terminated by gadget");
-        this.name = "BreakLoopException";
+        this.name = "TaskCompletionSignal";
       }
     };
-    HumanInputException = class extends Error {
+    HumanInputRequiredException = class extends Error {
       question;
       constructor(question) {
         super(`Human input required: ${question}`);
-        this.name = "HumanInputException";
+        this.name = "HumanInputRequiredException";
         this.question = question;
       }
     };
@@ -1027,10 +1270,10 @@ var init_exceptions = __esm({
         this.timeoutMs = timeoutMs;
       }
     };
-    AbortError = class extends Error {
+    AbortException = class extends Error {
       constructor(message) {
         super(message || "Gadget execution was aborted");
-        this.name = "AbortError";
+        this.name = "AbortException";
       }
     };
   }
@@ -1120,7 +1363,7 @@ var init_schema_to_json = __esm({
 });
 
 // src/gadgets/gadget.ts
-function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
+function formatParamsForBlockExample(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
   const lines = [];
   for (const [key, value] of Object.entries(params)) {
     const fullPath = prefix ? `${prefix}/${key}` : key;
@@ -1128,14 +1371,14 @@ function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX)
       value.forEach((item, index) => {
         const itemPath = `${fullPath}/${index}`;
         if (typeof item === "object" && item !== null) {
-          lines.push(formatParamsAsBlock(item, itemPath, argPrefix));
+          lines.push(formatParamsForBlockExample(item, itemPath, argPrefix));
         } else {
           lines.push(`${argPrefix}${itemPath}`);
           lines.push(String(item));
         }
       });
     } else if (typeof value === "object" && value !== null) {
-      lines.push(formatParamsAsBlock(value, fullPath, argPrefix));
+      lines.push(formatParamsForBlockExample(value, fullPath, argPrefix));
     } else {
       lines.push(`${argPrefix}${fullPath}`);
       lines.push(String(value));
@@ -1224,7 +1467,7 @@ function formatSchemaAsPlainText(schema, indent = "", atRoot = true) {
   }
   return lines.join("\n");
 }
-var BaseGadget;
+var AbstractGadget;
 var init_gadget = __esm({
   "src/gadgets/gadget.ts"() {
     "use strict";
@@ -1232,7 +1475,7 @@ var init_gadget = __esm({
     init_exceptions();
     init_schema_to_json();
     init_schema_validator();
-    BaseGadget = class {
+    AbstractGadget = class {
       /**
        * The name of the gadget. Used for identification when LLM calls it.
        * If not provided, defaults to the class name.
@@ -1260,14 +1503,14 @@ var init_gadget = __esm({
        */
       examples;
       /**
-       * Throws an AbortError if the execution has been aborted.
+       * Throws an AbortException if the execution has been aborted.
        *
        * Call this at key checkpoints in long-running gadgets to allow early exit
        * when the gadget has been cancelled (e.g., due to timeout). This enables
        * resource cleanup and prevents unnecessary work after cancellation.
        *
        * @param ctx - The execution context containing the abort signal
-       * @throws AbortError if ctx.signal.aborted is true
+       * @throws AbortException if ctx.signal.aborted is true
        *
        * @example
        * ```typescript
@@ -1292,7 +1535,7 @@ var init_gadget = __esm({
        */
       throwIfAborted(ctx) {
         if (ctx?.signal?.aborted) {
-          throw new AbortError();
+          throw new AbortException();
         }
       }
       /**
@@ -1433,7 +1676,9 @@ var init_gadget = __esm({
               parts.push(`# ${example.comment}`);
             }
             parts.push(`${effectiveStartPrefix}${gadgetName}`);
-            parts.push(formatParamsAsBlock(example.params, "", effectiveArgPrefix));
+            parts.push(
+              formatParamsForBlockExample(example.params, "", effectiveArgPrefix)
+            );
             parts.push(effectiveEndPrefix);
             if (example.output !== void 0) {
               parts.push("");
@@ -1450,7 +1695,7 @@ var init_gadget = __esm({
 
 // src/gadgets/create-gadget.ts
 function createGadget(config) {
-  class DynamicGadget extends BaseGadget {
+  class DynamicGadget extends AbstractGadget {
     name = config.name;
     description = config.description;
     parameterSchema = config.schema;
@@ -1635,6 +1880,18 @@ var init_output_viewer = __esm({
   }
 });
 
+// src/agent/agent-internal-key.ts
+function isValidAgentKey(key) {
+  return key === AGENT_INTERNAL_KEY;
+}
+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");
+  }
+});
+
 // src/agent/compaction/config.ts
 function resolveCompactionConfig(config = {}) {
   const trigger = config.triggerThresholdPercent ?? DEFAULT_COMPACTION_CONFIG.triggerThresholdPercent;
@@ -1882,9 +2139,9 @@ var init_hybrid = __esm({
 var init_strategies = __esm({
   "src/agent/compaction/strategies/index.ts"() {
     "use strict";
+    init_hybrid();
     init_sliding_window();
     init_summarization();
-    init_hybrid();
   }
 });
 
@@ -2046,98 +2303,6 @@ var init_manager = __esm({
   }
 });
 
-// src/agent/gadget-output-store.ts
-var import_node_crypto, GadgetOutputStore;
-var init_gadget_output_store = __esm({
-  "src/agent/gadget-output-store.ts"() {
-    "use strict";
-    import_node_crypto = require("crypto");
-    GadgetOutputStore = class {
-      outputs = /* @__PURE__ */ new Map();
-      /**
-       * Store a gadget output and return its ID.
-       *
-       * @param gadgetName - Name of the gadget that produced the output
-       * @param content - Full output content to store
-       * @returns Generated ID for retrieving the output later
-       */
-      store(gadgetName, content) {
-        const id = this.generateId(gadgetName);
-        const encoder = new TextEncoder();
-        const stored = {
-          id,
-          gadgetName,
-          content,
-          byteSize: encoder.encode(content).length,
-          lineCount: content.split("\n").length,
-          timestamp: /* @__PURE__ */ new Date()
-        };
-        this.outputs.set(id, stored);
-        return id;
-      }
-      /**
-       * Retrieve a stored output by ID.
-       *
-       * @param id - The output ID (e.g., "Search_d34db33f")
-       * @returns The stored output or undefined if not found
-       */
-      get(id) {
-        return this.outputs.get(id);
-      }
-      /**
-       * Check if an output exists.
-       *
-       * @param id - The output ID to check
-       * @returns True if the output exists
-       */
-      has(id) {
-        return this.outputs.has(id);
-      }
-      /**
-       * Get all stored output IDs.
-       *
-       * @returns Array of output IDs
-       */
-      getIds() {
-        return Array.from(this.outputs.keys());
-      }
-      /**
-       * Get the number of stored outputs.
-       */
-      get size() {
-        return this.outputs.size;
-      }
-      /**
-       * Clear all stored outputs.
-       * Called when the agent run completes.
-       */
-      clear() {
-        this.outputs.clear();
-      }
-      /**
-       * Generate a unique ID for a stored output.
-       * Format: {GadgetName}_{8 hex chars}
-       */
-      generateId(gadgetName) {
-        const hex = (0, import_node_crypto.randomBytes)(4).toString("hex");
-        return `${gadgetName}_${hex}`;
-      }
-    };
-  }
-});
-
-// src/agent/agent-internal-key.ts
-function isValidAgentKey(key) {
-  return key === AGENT_INTERNAL_KEY;
-}
-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");
-  }
-});
-
 // src/agent/conversation-manager.ts
 var ConversationManager;
 var init_conversation_manager = __esm({
@@ -2168,8 +2333,8 @@ var init_conversation_manager = __esm({
       addAssistantMessage(content) {
         this.historyBuilder.addAssistant(content);
       }
-      addGadgetCall(gadgetName, parameters, result) {
-        this.historyBuilder.addGadgetCall(gadgetName, parameters, result);
+      addGadgetCallResult(gadgetName, parameters, result, media, mediaIds) {
+        this.historyBuilder.addGadgetCallResult(gadgetName, parameters, result, media, mediaIds);
       }
       getMessages() {
         return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
@@ -2189,7 +2354,7 @@ var init_conversation_manager = __esm({
           if (msg.role === "user") {
             this.historyBuilder.addUser(msg.content);
           } else if (msg.role === "assistant") {
-            this.historyBuilder.addAssistant(extractText(msg.content));
+            this.historyBuilder.addAssistant(extractMessageText(msg.content));
           }
         }
       }
@@ -2253,59 +2418,139 @@ var init_event_handlers = __esm({
   }
 });
 
-// src/agent/hook-validators.ts
-function validateBeforeLLMCallAction(action) {
-  if (!action || typeof action !== "object" || !("action" in action)) {
-    throw new HookValidationError(
-      "beforeLLMCall",
-      "Must return an action object with an 'action' field"
-    );
-  }
-  const actionType = action.action;
-  if (actionType !== "proceed" && actionType !== "skip") {
-    throw new HookValidationError(
-      "beforeLLMCall",
-      `Invalid action type: ${actionType}. Must be 'proceed' or 'skip'`
-    );
-  }
-  if (actionType === "skip" && !action.syntheticResponse) {
-    throw new HookValidationError(
-      "beforeLLMCall",
-      "When action is 'skip', syntheticResponse is required"
-    );
-  }
-}
-function validateAfterLLMCallAction(action) {
-  if (!action || typeof action !== "object" || !("action" in action)) {
-    throw new HookValidationError(
-      "afterLLMCall",
-      "Must return an action object with an 'action' field"
-    );
-  }
-  const actionType = action.action;
-  const validActions = ["continue", "append_messages", "modify_and_continue", "append_and_modify"];
-  if (!validActions.includes(actionType)) {
-    throw new HookValidationError(
-      "afterLLMCall",
-      `Invalid action type: ${actionType}. Must be one of: ${validActions.join(", ")}`
-    );
-  }
-  if (actionType === "append_messages" || actionType === "append_and_modify") {
-    if (!("messages" in action) || !action.messages || !Array.isArray(action.messages)) {
-      throw new HookValidationError(
-        "afterLLMCall",
-        `When action is '${actionType}', messages array is required`
-      );
-    }
-    if (action.messages.length === 0) {
-      throw new HookValidationError(
-        "afterLLMCall",
-        `When action is '${actionType}', messages array must not be empty`
-      );
-    }
-    for (let i = 0; i < action.messages.length; i++) {
-      const msg = action.messages[i];
-      if (!msg || typeof msg !== "object") {
+// src/agent/gadget-output-store.ts
+var import_node_crypto2, GadgetOutputStore;
+var init_gadget_output_store = __esm({
+  "src/agent/gadget-output-store.ts"() {
+    "use strict";
+    import_node_crypto2 = require("crypto");
+    GadgetOutputStore = class {
+      outputs = /* @__PURE__ */ new Map();
+      /**
+       * Store a gadget output and return its ID.
+       *
+       * @param gadgetName - Name of the gadget that produced the output
+       * @param content - Full output content to store
+       * @returns Generated ID for retrieving the output later
+       */
+      store(gadgetName, content) {
+        const id = this.generateId(gadgetName);
+        const encoder = new TextEncoder();
+        const stored = {
+          id,
+          gadgetName,
+          content,
+          byteSize: encoder.encode(content).length,
+          lineCount: content.split("\n").length,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.outputs.set(id, stored);
+        return id;
+      }
+      /**
+       * Retrieve a stored output by ID.
+       *
+       * @param id - The output ID (e.g., "Search_d34db33f")
+       * @returns The stored output or undefined if not found
+       */
+      get(id) {
+        return this.outputs.get(id);
+      }
+      /**
+       * Check if an output exists.
+       *
+       * @param id - The output ID to check
+       * @returns True if the output exists
+       */
+      has(id) {
+        return this.outputs.has(id);
+      }
+      /**
+       * Get all stored output IDs.
+       *
+       * @returns Array of output IDs
+       */
+      getIds() {
+        return Array.from(this.outputs.keys());
+      }
+      /**
+       * Get the number of stored outputs.
+       */
+      get size() {
+        return this.outputs.size;
+      }
+      /**
+       * Clear all stored outputs.
+       * Called when the agent run completes.
+       */
+      clear() {
+        this.outputs.clear();
+      }
+      /**
+       * Generate a unique ID for a stored output.
+       * Format: {GadgetName}_{8 hex chars}
+       */
+      generateId(gadgetName) {
+        const hex = (0, import_node_crypto2.randomBytes)(4).toString("hex");
+        return `${gadgetName}_${hex}`;
+      }
+    };
+  }
+});
+
+// src/agent/hook-validators.ts
+function validateBeforeLLMCallAction(action) {
+  if (!action || typeof action !== "object" || !("action" in action)) {
+    throw new HookValidationError(
+      "beforeLLMCall",
+      "Must return an action object with an 'action' field"
+    );
+  }
+  const actionType = action.action;
+  if (actionType !== "proceed" && actionType !== "skip") {
+    throw new HookValidationError(
+      "beforeLLMCall",
+      `Invalid action type: ${actionType}. Must be 'proceed' or 'skip'`
+    );
+  }
+  if (actionType === "skip" && !action.syntheticResponse) {
+    throw new HookValidationError(
+      "beforeLLMCall",
+      "When action is 'skip', syntheticResponse is required"
+    );
+  }
+}
+function validateAfterLLMCallAction(action) {
+  if (!action || typeof action !== "object" || !("action" in action)) {
+    throw new HookValidationError(
+      "afterLLMCall",
+      "Must return an action object with an 'action' field"
+    );
+  }
+  const actionType = action.action;
+  const validActions = ["continue", "append_messages", "modify_and_continue", "append_and_modify"];
+  if (!validActions.includes(actionType)) {
+    throw new HookValidationError(
+      "afterLLMCall",
+      `Invalid action type: ${actionType}. Must be one of: ${validActions.join(", ")}`
+    );
+  }
+  if (actionType === "append_messages" || actionType === "append_and_modify") {
+    if (!("messages" in action) || !action.messages || !Array.isArray(action.messages)) {
+      throw new HookValidationError(
+        "afterLLMCall",
+        `When action is '${actionType}', messages array is required`
+      );
+    }
+    if (action.messages.length === 0) {
+      throw new HookValidationError(
+        "afterLLMCall",
+        `When action is '${actionType}', messages array must not be empty`
+      );
+    }
+    for (let i = 0; i < action.messages.length; i++) {
+      const msg = action.messages[i];
+      if (!msg || typeof msg !== "object") {
         throw new HookValidationError("afterLLMCall", `Message at index ${i} must be an object`);
       }
       if (!msg.role || !msg.content) {
@@ -2563,8 +2808,7 @@ var init_schema_introspector = __esm({
             const values = def?.values;
             const value = values?.[0] ?? def?.value;
             if (typeof value === "string") return "string";
-            if (typeof value === "number" || typeof value === "bigint")
-              return "number";
+            if (typeof value === "number" || typeof value === "bigint") return "number";
             if (typeof value === "boolean") return "boolean";
             return "unknown";
           }
@@ -2836,7 +3080,13 @@ var init_cost_reporting_client = __esm({
             cacheCreationInputTokens = chunk.usage.cacheCreationInputTokens ?? 0;
           }
         }
-        this.reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+        this.reportCostFromUsage(
+          model,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens,
+          cacheCreationInputTokens
+        );
         return result;
       }
       /**
@@ -2876,7 +3126,13 @@ var init_cost_reporting_client = __esm({
             }
           }
         } finally {
-          this.reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+          this.reportCostFromUsage(
+            model,
+            inputTokens,
+            outputTokens,
+            cachedInputTokens,
+            cacheCreationInputTokens
+          );
         }
       }
       /**
@@ -2914,7 +3170,13 @@ var init_cost_reporting_client = __esm({
             }
           } finally {
             if (inputTokens > 0 || outputTokens > 0) {
-              reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+              reportCostFromUsage(
+                model,
+                inputTokens,
+                outputTokens,
+                cachedInputTokens,
+                cacheCreationInputTokens
+              );
             }
           }
         }
@@ -2942,12 +3204,12 @@ var init_cost_reporting_client = __esm({
 });
 
 // src/gadgets/error-formatter.ts
-var GadgetErrorFormatter;
+var GadgetExecutionErrorFormatter;
 var init_error_formatter = __esm({
   "src/gadgets/error-formatter.ts"() {
     "use strict";
     init_constants();
-    GadgetErrorFormatter = class {
+    GadgetExecutionErrorFormatter = class {
       argPrefix;
       startPrefix;
       endPrefix;
@@ -3033,16 +3295,16 @@ function stripMarkdownFences(content) {
   cleaned = cleaned.replace(closingFence, "");
   return cleaned.trim();
 }
-var globalInvocationCounter, StreamParser;
+var globalInvocationCounter, GadgetCallParser;
 var init_parser = __esm({
   "src/gadgets/parser.ts"() {
     "use strict";
     init_constants();
     init_block_params();
     globalInvocationCounter = 0;
-    StreamParser = class {
+    GadgetCallParser = class {
       buffer = "";
-      lastReportedTextLength = 0;
+      lastEmittedTextOffset = 0;
       startPrefix;
       endPrefix;
       argPrefix;
@@ -3051,16 +3313,20 @@ var init_parser = __esm({
         this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
         this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
       }
-      takeTextUntil(index) {
-        if (index <= this.lastReportedTextLength) {
+      /**
+       * Extract and consume text up to the given index.
+       * Returns undefined if no meaningful text to emit.
+       */
+      extractTextSegment(index) {
+        if (index <= this.lastEmittedTextOffset) {
           return void 0;
         }
-        const segment = this.buffer.slice(this.lastReportedTextLength, index);
-        this.lastReportedTextLength = index;
+        const segment = this.buffer.slice(this.lastEmittedTextOffset, index);
+        this.lastEmittedTextOffset = index;
         return segment.trim().length > 0 ? segment : void 0;
       }
       /**
-       * Parse gadget name with optional invocation ID and dependencies.
+       * Parse gadget invocation metadata from the header line.
        *
        * Supported formats:
        * - `GadgetName` - Auto-generate ID, no dependencies
@@ -3069,24 +3335,24 @@ var init_parser = __esm({
        *
        * Dependencies must be comma-separated invocation IDs.
        */
-      parseGadgetName(gadgetName) {
-        const parts = gadgetName.split(":");
+      parseInvocationMetadata(headerLine) {
+        const parts = headerLine.split(":");
         if (parts.length === 1) {
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: `gadget_${++globalInvocationCounter}`,
             dependencies: []
           };
         } else if (parts.length === 2) {
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: parts[1].trim(),
             dependencies: []
           };
         } else {
           const deps = parts[2].split(",").map((d) => d.trim()).filter((d) => d.length > 0);
           return {
-            actualName: parts[0],
+            gadgetName: parts[0],
             invocationId: parts[1].trim(),
             dependencies: deps
           };
@@ -3118,15 +3384,15 @@ var init_parser = __esm({
         while (true) {
           const partStartIndex = this.buffer.indexOf(this.startPrefix, startIndex);
           if (partStartIndex === -1) break;
-          const textBefore = this.takeTextUntil(partStartIndex);
+          const textBefore = this.extractTextSegment(partStartIndex);
           if (textBefore !== void 0) {
             yield { type: "text", content: textBefore };
           }
           const metadataStartIndex = partStartIndex + this.startPrefix.length;
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex === -1) break;
-          const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-          const { actualName: actualGadgetName, invocationId, dependencies } = this.parseGadgetName(gadgetName);
+          const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
+          const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
           const contentStartIndex = metadataEndIndex + 1;
           let partEndIndex;
           let endMarkerLength = 0;
@@ -3146,7 +3412,7 @@ var init_parser = __esm({
           yield {
             type: "gadget_call",
             call: {
-              gadgetName: actualGadgetName,
+              gadgetName,
               invocationId,
               parametersRaw,
               parameters,
@@ -3155,33 +3421,33 @@ var init_parser = __esm({
             }
           };
           startIndex = partEndIndex + endMarkerLength;
-          this.lastReportedTextLength = startIndex;
+          this.lastEmittedTextOffset = startIndex;
         }
         if (startIndex > 0) {
           this.buffer = this.buffer.substring(startIndex);
-          this.lastReportedTextLength = 0;
+          this.lastEmittedTextOffset = 0;
         }
       }
       // Finalize parsing and return remaining text or incomplete gadgets
       *finalize() {
-        const startIndex = this.buffer.indexOf(this.startPrefix, this.lastReportedTextLength);
+        const startIndex = this.buffer.indexOf(this.startPrefix, this.lastEmittedTextOffset);
         if (startIndex !== -1) {
-          const textBefore = this.takeTextUntil(startIndex);
+          const textBefore = this.extractTextSegment(startIndex);
           if (textBefore !== void 0) {
             yield { type: "text", content: textBefore };
           }
           const metadataStartIndex = startIndex + this.startPrefix.length;
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex !== -1) {
-            const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-            const { actualName: actualGadgetName, invocationId, dependencies } = this.parseGadgetName(gadgetName);
+            const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
+            const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
             const contentStartIndex = metadataEndIndex + 1;
             const parametersRaw = this.buffer.substring(contentStartIndex).trim();
             const { parameters, parseError } = this.parseParameters(parametersRaw);
             yield {
               type: "gadget_call",
               call: {
-                gadgetName: actualGadgetName,
+                gadgetName,
                 invocationId,
                 parametersRaw,
                 parameters,
@@ -3192,7 +3458,7 @@ var init_parser = __esm({
             return;
           }
         }
-        const remainingText = this.takeTextUntil(this.buffer.length);
+        const remainingText = this.extractTextSegment(this.buffer.length);
         if (remainingText !== void 0) {
           yield { type: "text", content: remainingText };
         }
@@ -3200,7 +3466,7 @@ var init_parser = __esm({
       // Reset parser state (note: global invocation counter is NOT reset to ensure unique IDs)
       reset() {
         this.buffer = "";
-        this.lastReportedTextLength = 0;
+        this.lastEmittedTextOffset = 0;
       }
     };
   }
@@ -3219,13 +3485,16 @@ var init_executor = __esm({
     init_exceptions();
     init_parser();
     GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client) {
+      constructor(registry, requestHumanInput, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client, mediaStore, agentConfig, subagentConfig) {
         this.registry = registry;
-        this.onHumanInputRequired = onHumanInputRequired;
+        this.requestHumanInput = requestHumanInput;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
         this.client = client;
+        this.mediaStore = mediaStore;
+        this.agentConfig = agentConfig;
+        this.subagentConfig = subagentConfig;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
-        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
+        this.errorFormatter = new GadgetExecutionErrorFormatter(errorFormatterOptions);
         this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
       }
       logger;
@@ -3245,13 +3514,17 @@ var init_executor = __esm({
         });
       }
       /**
-       * Normalizes gadget execute result to consistent format.
-       * Handles both string returns (backwards compat) and object returns with cost.
+       * Unify gadget execute result to consistent internal format.
+       * Handles string returns (backwards compat), object returns with cost,
+       * and object returns with media.
        */
-      normalizeExecuteResult(raw) {
+      unifyExecuteResult(raw) {
         if (typeof raw === "string") {
           return { result: raw, cost: 0 };
         }
+        if ("media" in raw && raw.media) {
+          return { result: raw.result, media: raw.media, cost: raw.cost ?? 0 };
+        }
         return { result: raw.result, cost: raw.cost ?? 0 };
       }
       // Execute a gadget call asynchronously
@@ -3363,7 +3636,9 @@ var init_executor = __esm({
           const ctx = {
             reportCost,
             llmist: this.client ? new CostReportingLLMistWrapper(this.client, reportCost) : void 0,
-            signal: abortController.signal
+            signal: abortController.signal,
+            agentConfig: this.agentConfig,
+            subagentConfig: this.subagentConfig
           };
           let rawResult;
           if (timeoutMs && timeoutMs > 0) {
@@ -3378,8 +3653,21 @@ var init_executor = __esm({
           } else {
             rawResult = await Promise.resolve(gadget.execute(validatedParameters, ctx));
           }
-          const { result, cost: returnCost } = this.normalizeExecuteResult(rawResult);
+          const { result, media, cost: returnCost } = this.unifyExecuteResult(rawResult);
           const totalCost = callbackCost + returnCost;
+          let mediaIds;
+          let storedMedia;
+          if (media && media.length > 0 && this.mediaStore) {
+            storedMedia = await Promise.all(
+              media.map((item) => this.mediaStore.store(item, call.gadgetName))
+            );
+            mediaIds = storedMedia.map((m) => m.id);
+            this.logger.debug("Stored media outputs", {
+              gadgetName: call.gadgetName,
+              mediaIds,
+              count: media.length
+            });
+          }
           const executionTimeMs = Date.now() - startTime;
           this.logger.info("Gadget executed successfully", {
             gadgetName: call.gadgetName,
@@ -3387,7 +3675,8 @@ var init_executor = __esm({
             executionTimeMs,
             cost: totalCost > 0 ? totalCost : void 0,
             callbackCost: callbackCost > 0 ? callbackCost : void 0,
-            returnCost: returnCost > 0 ? returnCost : void 0
+            returnCost: returnCost > 0 ? returnCost : void 0,
+            mediaCount: media?.length
           });
           this.logger.debug("Gadget result", {
             gadgetName: call.gadgetName,
@@ -3395,7 +3684,8 @@ var init_executor = __esm({
             parameters: validatedParameters,
             result,
             cost: totalCost,
-            executionTimeMs
+            executionTimeMs,
+            mediaIds
           });
           return {
             gadgetName: call.gadgetName,
@@ -3403,10 +3693,13 @@ var init_executor = __esm({
             parameters: validatedParameters,
             result,
             executionTimeMs,
-            cost: totalCost
+            cost: totalCost,
+            media,
+            mediaIds,
+            storedMedia
           };
         } catch (error) {
-          if (error instanceof BreakLoopException) {
+          if (error instanceof TaskCompletionSignal) {
             this.logger.info("Gadget requested loop termination", {
               gadgetName: call.gadgetName,
               message: error.message
@@ -3434,7 +3727,7 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
-          if (error instanceof AbortError) {
+          if (error instanceof AbortException) {
             this.logger.info("Gadget execution was aborted", {
               gadgetName: call.gadgetName,
               executionTimeMs: Date.now() - startTime
@@ -3447,14 +3740,14 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
-          if (error instanceof HumanInputException) {
+          if (error instanceof HumanInputRequiredException) {
             this.logger.info("Gadget requested human input", {
               gadgetName: call.gadgetName,
               question: error.question
             });
-            if (this.onHumanInputRequired) {
+            if (this.requestHumanInput) {
               try {
-                const answer = await this.onHumanInputRequired(error.question);
+                const answer = await this.requestHumanInput(error.question);
                 this.logger.debug("Human input received", {
                   gadgetName: call.gadgetName,
                   answerLength: answer.length
@@ -3552,13 +3845,13 @@ var init_stream_processor = __esm({
       parser;
       executor;
       stopOnGadgetError;
-      shouldContinueAfterError;
-      accumulatedText = "";
-      shouldStopExecution = false;
+      canRecoverFromGadgetError;
+      responseText = "";
+      executionHalted = false;
       observerFailureCount = 0;
       // Dependency tracking for gadget execution DAG
       /** Gadgets waiting for their dependencies to complete */
-      pendingGadgets = /* @__PURE__ */ new Map();
+      gadgetsAwaitingDependencies = /* @__PURE__ */ new Map();
       /** Completed gadget results, keyed by invocation ID */
       completedResults = /* @__PURE__ */ new Map();
       /** Invocation IDs of gadgets that have failed (error or skipped due to dependency) */
@@ -3569,19 +3862,22 @@ var init_stream_processor = __esm({
         this.hooks = options.hooks ?? {};
         this.logger = options.logger ?? createLogger({ name: "llmist:stream-processor" });
         this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.shouldContinueAfterError = options.shouldContinueAfterError;
-        this.parser = new StreamParser({
+        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
+        this.parser = new GadgetCallParser({
           startPrefix: options.gadgetStartPrefix,
           endPrefix: options.gadgetEndPrefix,
           argPrefix: options.gadgetArgPrefix
         });
         this.executor = new GadgetExecutor(
           options.registry,
-          options.onHumanInputRequired,
+          options.requestHumanInput,
           this.logger.getSubLogger({ name: "executor" }),
           options.defaultGadgetTimeoutMs,
           { argPrefix: options.gadgetArgPrefix },
-          options.client
+          options.client,
+          options.mediaStore,
+          options.agentConfig,
+          options.subagentConfig
         );
       }
       /**
@@ -3602,7 +3898,7 @@ var init_stream_processor = __esm({
             if (this.hooks.interceptors?.interceptRawChunk) {
               const context = {
                 iteration: this.iteration,
-                accumulatedText: this.accumulatedText,
+                accumulatedText: this.responseText,
                 logger: this.logger
               };
               const intercepted = this.hooks.interceptors.interceptRawChunk(processedChunk, context);
@@ -3613,7 +3909,7 @@ var init_stream_processor = __esm({
               }
             }
             if (processedChunk) {
-              this.accumulatedText += processedChunk;
+              this.responseText += processedChunk;
             }
           }
           if (this.hooks.observers?.onStreamChunk && (processedChunk || chunk.usage)) {
@@ -3622,7 +3918,7 @@ var init_stream_processor = __esm({
               const context = {
                 iteration: this.iteration,
                 rawChunk: processedChunk,
-                accumulatedText: this.accumulatedText,
+                accumulatedText: this.responseText,
                 usage,
                 logger: this.logger
               };
@@ -3645,12 +3941,12 @@ var init_stream_processor = __esm({
               }
             }
           }
-          if (this.shouldStopExecution) {
+          if (this.executionHalted) {
             this.logger.info("Breaking from LLM stream due to gadget error");
             break;
           }
         }
-        if (!this.shouldStopExecution) {
+        if (!this.executionHalted) {
           for (const event of this.parser.finalize()) {
             const processedEvents = await this.processEvent(event);
             outputs.push(...processedEvents);
@@ -3674,11 +3970,11 @@ var init_stream_processor = __esm({
             }
           }
         }
-        let finalMessage = this.accumulatedText;
+        let finalMessage = this.responseText;
         if (this.hooks.interceptors?.interceptAssistantMessage) {
           const context = {
             iteration: this.iteration,
-            rawResponse: this.accumulatedText,
+            rawResponse: this.responseText,
             logger: this.logger
           };
           finalMessage = this.hooks.interceptors.interceptAssistantMessage(finalMessage, context);
@@ -3689,7 +3985,7 @@ var init_stream_processor = __esm({
           didExecuteGadgets,
           finishReason,
           usage,
-          rawResponse: this.accumulatedText,
+          rawResponse: this.responseText,
           finalMessage
         };
       }
@@ -3712,7 +4008,7 @@ var init_stream_processor = __esm({
         if (this.hooks.interceptors?.interceptTextChunk) {
           const context = {
             iteration: this.iteration,
-            accumulatedText: this.accumulatedText,
+            accumulatedText: this.responseText,
             logger: this.logger
           };
           const intercepted = this.hooks.interceptors.interceptTextChunk(content, context);
@@ -3731,7 +4027,7 @@ var init_stream_processor = __esm({
        * After each execution, pending gadgets are checked to see if they can now run.
        */
       async processGadgetCall(call) {
-        if (this.shouldStopExecution) {
+        if (this.executionHalted) {
           this.logger.debug("Skipping gadget execution due to previous error", {
             gadgetName: call.gadgetName
           });
@@ -3770,7 +4066,7 @@ var init_stream_processor = __esm({
               invocationId: call.invocationId,
               waitingOn: unsatisfied
             });
-            this.pendingGadgets.set(call.invocationId, call);
+            this.gadgetsAwaitingDependencies.set(call.invocationId, call);
             return events;
           }
         }
@@ -3792,14 +4088,14 @@ var init_stream_processor = __esm({
             error: call.parseError,
             rawParameters: call.parametersRaw
           });
-          const shouldContinue = await this.checkContinueAfterError(
+          const shouldContinue = await this.checkCanRecoverFromError(
             call.parseError,
             call.gadgetName,
             "parse",
             call.parameters
           );
           if (!shouldContinue) {
-            this.shouldStopExecution = true;
+            this.executionHalted = true;
           }
         }
         let parameters = call.parameters ?? {};
@@ -3923,14 +4219,14 @@ var init_stream_processor = __esm({
         events.push({ type: "gadget_result", result });
         if (result.error) {
           const errorType = this.determineErrorType(call, result);
-          const shouldContinue = await this.checkContinueAfterError(
+          const shouldContinue = await this.checkCanRecoverFromError(
             result.error,
             result.gadgetName,
             errorType,
             result.parameters
           );
           if (!shouldContinue) {
-            this.shouldStopExecution = true;
+            this.executionHalted = true;
           }
         }
         return events;
@@ -4017,11 +4313,11 @@ var init_stream_processor = __esm({
       async processPendingGadgets() {
         const events = [];
         let progress = true;
-        while (progress && this.pendingGadgets.size > 0) {
+        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
           progress = false;
           const readyToExecute = [];
           const readyToSkip = [];
-          for (const [invocationId, call] of this.pendingGadgets) {
+          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
             const failedDep = call.dependencies.find((dep) => this.failedInvocations.has(dep));
             if (failedDep) {
               readyToSkip.push({ call, failedDep });
@@ -4033,7 +4329,7 @@ var init_stream_processor = __esm({
             }
           }
           for (const { call, failedDep } of readyToSkip) {
-            this.pendingGadgets.delete(call.invocationId);
+            this.gadgetsAwaitingDependencies.delete(call.invocationId);
             const skipEvents = await this.handleFailedDependency(call, failedDep);
             events.push(...skipEvents);
             progress = true;
@@ -4044,7 +4340,7 @@ var init_stream_processor = __esm({
               invocationIds: readyToExecute.map((c) => c.invocationId)
             });
             for (const call of readyToExecute) {
-              this.pendingGadgets.delete(call.invocationId);
+              this.gadgetsAwaitingDependencies.delete(call.invocationId);
             }
             const executePromises = readyToExecute.map((call) => this.executeGadgetWithHooks(call));
             const results = await Promise.all(executePromises);
@@ -4054,9 +4350,9 @@ var init_stream_processor = __esm({
             progress = true;
           }
         }
-        if (this.pendingGadgets.size > 0) {
-          const pendingIds = new Set(this.pendingGadgets.keys());
-          for (const [invocationId, call] of this.pendingGadgets) {
+        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));
@@ -4087,7 +4383,7 @@ var init_stream_processor = __esm({
             };
             events.push(skipEvent);
           }
-          this.pendingGadgets.clear();
+          this.gadgetsAwaitingDependencies.clear();
         }
         return events;
       }
@@ -4117,19 +4413,19 @@ var init_stream_processor = __esm({
         );
       }
       /**
-       * Check if execution should continue after an error.
+       * Check if execution can recover from an error.
        *
        * Returns true if we should continue processing subsequent gadgets, false if we should stop.
        *
        * Logic:
-       * - If custom shouldContinueAfterError is provided, use it
+       * - If custom canRecoverFromGadgetError is provided, use it
        * - Otherwise, use stopOnGadgetError config:
        *   - stopOnGadgetError=true → return false (stop execution)
        *   - stopOnGadgetError=false → return true (continue execution)
        */
-      async checkContinueAfterError(error, gadgetName, errorType, parameters) {
-        if (this.shouldContinueAfterError) {
-          return await this.shouldContinueAfterError({
+      async checkCanRecoverFromError(error, gadgetName, errorType, parameters) {
+        if (this.canRecoverFromGadgetError) {
+          return await this.canRecoverFromGadgetError({
             error,
             gadgetName,
             errorType,
@@ -4170,13 +4466,14 @@ var init_agent = __esm({
     init_constants();
     init_messages();
     init_model_shortcuts();
+    init_media_store();
     init_output_viewer();
     init_logger();
-    init_manager();
-    init_gadget_output_store();
     init_agent_internal_key();
+    init_manager();
     init_conversation_manager();
     init_event_handlers();
+    init_gadget_output_store();
     init_hook_validators();
     init_stream_processor();
     Agent = class {
@@ -4191,22 +4488,27 @@ var init_agent = __esm({
       gadgetStartPrefix;
       gadgetEndPrefix;
       gadgetArgPrefix;
-      onHumanInputRequired;
+      requestHumanInput;
       textOnlyHandler;
       textWithGadgetsHandler;
       stopOnGadgetError;
-      shouldContinueAfterError;
+      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       defaultMaxTokens;
-      userPromptProvided;
+      hasUserPrompt;
       // Gadget output limiting
       outputStore;
       outputLimitEnabled;
       outputLimitCharLimit;
       // Context compaction
       compactionManager;
+      // Media storage (for gadgets returning images, audio, etc.)
+      mediaStore;
       // Cancellation
       signal;
+      // Subagent configuration
+      agentContextConfig;
+      subagentConfig;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -4226,15 +4528,16 @@ var init_agent = __esm({
         this.gadgetStartPrefix = options.gadgetStartPrefix;
         this.gadgetEndPrefix = options.gadgetEndPrefix;
         this.gadgetArgPrefix = options.gadgetArgPrefix;
-        this.onHumanInputRequired = options.onHumanInputRequired;
+        this.requestHumanInput = options.requestHumanInput;
         this.textOnlyHandler = options.textOnlyHandler ?? "terminate";
         this.textWithGadgetsHandler = options.textWithGadgetsHandler;
         this.stopOnGadgetError = options.stopOnGadgetError ?? true;
-        this.shouldContinueAfterError = options.shouldContinueAfterError;
+        this.canRecoverFromGadgetError = options.canRecoverFromGadgetError;
         this.defaultGadgetTimeoutMs = options.defaultGadgetTimeoutMs;
         this.defaultMaxTokens = this.resolveMaxTokensFromCatalog(options.model);
         this.outputLimitEnabled = options.gadgetOutputLimit ?? DEFAULT_GADGET_OUTPUT_LIMIT;
         this.outputStore = new GadgetOutputStore();
+        this.mediaStore = new MediaStore();
         const limitPercent = options.gadgetOutputLimitPercent ?? DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT;
         const limits = this.client.modelRegistry.getModelLimits(this.model);
         const contextWindow = limits?.contextWindow ?? FALLBACK_CONTEXT_WINDOW;
@@ -4245,7 +4548,7 @@ var init_agent = __esm({
             createGadgetOutputViewer(this.outputStore, this.outputLimitCharLimit)
           );
         }
-        this.hooks = this.mergeOutputLimiterHook(options.hooks);
+        this.hooks = this.chainOutputLimiterWithUserHooks(options.hooks);
         const baseBuilder = new LLMMessageBuilder(options.promptConfig);
         if (options.systemPrompt) {
           baseBuilder.addSystem(options.systemPrompt);
@@ -4265,7 +4568,7 @@ var init_agent = __esm({
           endPrefix: options.gadgetEndPrefix,
           argPrefix: options.gadgetArgPrefix
         });
-        this.userPromptProvided = !!options.userPrompt;
+        this.hasUserPrompt = !!options.userPrompt;
         if (options.userPrompt) {
           this.conversation.addUserMessage(options.userPrompt);
         }
@@ -4278,6 +4581,11 @@ var init_agent = __esm({
           );
         }
         this.signal = options.signal;
+        this.agentContextConfig = {
+          model: this.model,
+          temperature: this.temperature
+        };
+        this.subagentConfig = options.subagentConfig;
       }
       /**
        * Get the gadget registry for this agent.
@@ -4300,6 +4608,36 @@ var init_agent = __esm({
       getRegistry() {
         return this.registry;
       }
+      /**
+       * Get the media store for this agent session.
+       *
+       * The media store holds all media outputs (images, audio, etc.) produced by gadgets
+       * during this agent's execution. Use this to:
+       * - Access stored media files by ID
+       * - List all stored media
+       * - Clean up temporary files after execution
+       *
+       * @returns The MediaStore instance for this agent
+       *
+       * @example
+       * ```typescript
+       * const agent = new AgentBuilder()
+       *   .withModel("sonnet")
+       *   .build();
+       *
+       * // After execution, access stored media
+       * const store = agent.getMediaStore();
+       * for (const media of store.list()) {
+       *   console.log(`${media.id}: ${media.path}`);
+       * }
+       *
+       * // Clean up when done
+       * await store.cleanup();
+       * ```
+       */
+      getMediaStore() {
+        return this.mediaStore;
+      }
       /**
        * Manually trigger context compaction.
        *
@@ -4354,7 +4692,7 @@ var init_agent = __esm({
        * @throws {Error} If no user prompt was provided (when using build() without ask())
        */
       async *run() {
-        if (!this.userPromptProvided) {
+        if (!this.hasUserPrompt) {
           throw new Error(
             "No user prompt provided. Use .ask(prompt) instead of .build(), or call agent.run() after providing a prompt."
           );
@@ -4471,11 +4809,14 @@ var init_agent = __esm({
               gadgetArgPrefix: this.gadgetArgPrefix,
               hooks: this.hooks,
               logger: this.logger.getSubLogger({ name: "stream-processor" }),
-              onHumanInputRequired: this.onHumanInputRequired,
+              requestHumanInput: this.requestHumanInput,
               stopOnGadgetError: this.stopOnGadgetError,
-              shouldContinueAfterError: this.shouldContinueAfterError,
+              canRecoverFromGadgetError: this.canRecoverFromGadgetError,
               defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
-              client: this.client
+              client: this.client,
+              mediaStore: this.mediaStore,
+              agentConfig: this.agentContextConfig,
+              subagentConfig: this.subagentConfig
             });
             const result = await processor.process(stream2);
             for (const output of result.outputs) {
@@ -4528,19 +4869,21 @@ var init_agent = __esm({
                   if (msg.role === "user") {
                     this.conversation.addUserMessage(msg.content);
                   } else if (msg.role === "assistant") {
-                    this.conversation.addAssistantMessage(extractText(msg.content));
+                    this.conversation.addAssistantMessage(extractMessageText(msg.content));
                   } else if (msg.role === "system") {
-                    this.conversation.addUserMessage(`[System] ${extractText(msg.content)}`);
+                    this.conversation.addUserMessage(`[System] ${extractMessageText(msg.content)}`);
                   }
                 }
               }
             }
             if (result.didExecuteGadgets) {
               if (this.textWithGadgetsHandler) {
-                const textContent = result.outputs.filter((output) => output.type === "text").map((output) => output.content).join("");
+                const textContent = result.outputs.filter(
+                  (output) => output.type === "text"
+                ).map((output) => output.content).join("");
                 if (textContent.trim()) {
                   const { gadgetName, parameterMapping, resultMapping } = this.textWithGadgetsHandler;
-                  this.conversation.addGadgetCall(
+                  this.conversation.addGadgetCallResult(
                     gadgetName,
                     parameterMapping(textContent),
                     resultMapping ? resultMapping(textContent) : textContent
@@ -4550,16 +4893,18 @@ var init_agent = __esm({
               for (const output of result.outputs) {
                 if (output.type === "gadget_result") {
                   const gadgetResult = output.result;
-                  this.conversation.addGadgetCall(
+                  this.conversation.addGadgetCallResult(
                     gadgetResult.gadgetName,
                     gadgetResult.parameters,
-                    gadgetResult.error ?? gadgetResult.result ?? ""
+                    gadgetResult.error ?? gadgetResult.result ?? "",
+                    gadgetResult.media,
+                    gadgetResult.mediaIds
                   );
                 }
               }
             } else {
               if (finalMessage.trim()) {
-                this.conversation.addGadgetCall(
+                this.conversation.addGadgetCallResult(
                   "TellUser",
                   { message: finalMessage, done: false, type: "info" },
                   `\u2139\uFE0F  ${finalMessage}`
@@ -4685,10 +5030,10 @@ var init_agent = __esm({
         return this.client.modelRegistry.getModelLimits(unprefixedModelId)?.maxOutputTokens;
       }
       /**
-       * Merge the output limiter interceptor into user-provided hooks.
+       * Chain the output limiter interceptor with user-provided hooks.
        * The limiter runs first, then chains to any user interceptor.
        */
-      mergeOutputLimiterHook(userHooks) {
+      chainOutputLimiterWithUserHooks(userHooks) {
         if (!this.outputLimitEnabled) {
           return userHooks ?? {};
         }
@@ -4767,20 +5112,21 @@ var init_builder = __esm({
       promptConfig;
       gadgets = [];
       initialMessages = [];
-      onHumanInputRequired;
+      requestHumanInput;
       gadgetStartPrefix;
       gadgetEndPrefix;
       gadgetArgPrefix;
       textOnlyHandler;
       textWithGadgetsHandler;
       stopOnGadgetError;
-      shouldContinueAfterError;
+      canRecoverFromGadgetError;
       defaultGadgetTimeoutMs;
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
       compactionConfig;
       signal;
       trailingMessage;
+      subagentConfig;
       constructor(client) {
         this.client = client;
       }
@@ -4871,13 +5217,13 @@ var init_builder = __esm({
        *
        * @example
        * ```typescript
-       * .withPromptConfig({
+       * .withPromptTemplateConfig({
        *   mainInstruction: "Use the gadget markers below:",
        *   rules: ["Always use markers", "Never use function calling"]
        * })
        * ```
        */
-      withPromptConfig(config) {
+      withPromptTemplateConfig(config) {
         this.promptConfig = config;
         return this;
       }
@@ -4957,7 +5303,7 @@ var init_builder = __esm({
        * ```
        */
       onHumanInput(handler) {
-        this.onHumanInputRequired = handler;
+        this.requestHumanInput = handler;
         return this;
       }
       /**
@@ -5092,9 +5438,9 @@ var init_builder = __esm({
        * Provides fine-grained control over whether to continue after different types of errors.
        * Overrides `stopOnGadgetError` when provided.
        *
-       * **Note:** This builder method configures the underlying `shouldContinueAfterError` option
+       * **Note:** This builder method configures the underlying `canRecoverFromGadgetError` option
        * in `AgentOptions`. The method is named `withErrorHandler` for better developer experience,
-       * but maps to the `shouldContinueAfterError` property internally.
+       * but maps to the `canRecoverFromGadgetError` property internally.
        *
        * @param handler - Function that decides whether to continue after an error.
        *                  Return `true` to continue execution, `false` to stop.
@@ -5115,7 +5461,7 @@ var init_builder = __esm({
        * ```
        */
       withErrorHandler(handler) {
-        this.shouldContinueAfterError = handler;
+        this.canRecoverFromGadgetError = handler;
         return this;
       }
       /**
@@ -5256,6 +5602,27 @@ var init_builder = __esm({
         this.signal = signal;
         return this;
       }
+      /**
+       * Set subagent configuration overrides.
+       *
+       * Subagent gadgets (like BrowseWeb) can read these settings from ExecutionContext
+       * to inherit model and other options from the CLI configuration.
+       *
+       * @param config - Subagent configuration map keyed by gadget name
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withSubagentConfig({
+       *   BrowseWeb: { model: "inherit", maxIterations: 20, headless: true },
+       *   CodeAnalyzer: { model: "sonnet", maxIterations: 10 }
+       * })
+       * ```
+       */
+      withSubagentConfig(config) {
+        this.subagentConfig = config;
+        return this;
+      }
       /**
        * Add an ephemeral trailing message that appears at the end of each LLM request.
        *
@@ -5420,19 +5787,20 @@ ${endPrefix}`
           hooks: this.composeHooks(),
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
-          onHumanInputRequired: this.onHumanInputRequired,
+          requestHumanInput: this.requestHumanInput,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
-          shouldContinueAfterError: this.shouldContinueAfterError,
+          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
-          signal: this.signal
+          signal: this.signal,
+          subagentConfig: this.subagentConfig
         };
       }
       ask(userPrompt) {
@@ -5601,19 +5969,20 @@ ${endPrefix}`
           hooks: this.composeHooks(),
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
-          onHumanInputRequired: this.onHumanInputRequired,
+          requestHumanInput: this.requestHumanInput,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
           gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
-          shouldContinueAfterError: this.shouldContinueAfterError,
+          canRecoverFromGadgetError: this.canRecoverFromGadgetError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
-          signal: this.signal
+          signal: this.signal,
+          subagentConfig: this.subagentConfig
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -5919,9 +6288,9 @@ var init_base_provider = __esm({
        */
       async *stream(options, descriptor, spec) {
         const preparedMessages = this.prepareMessages(options.messages);
-        const payload = this.buildRequestPayload(options, descriptor, spec, preparedMessages);
+        const payload = this.buildApiRequest(options, descriptor, spec, preparedMessages);
         const rawStream = await this.executeStreamRequest(payload, options.signal);
-        yield* this.wrapStream(rawStream);
+        yield* this.normalizeProviderStream(rawStream);
       }
       /**
        * Prepare messages for the request.
@@ -6021,11 +6390,11 @@ var init_anthropic = __esm({
           "Anthropic does not support speech generation. Use OpenAI (TTS) or Google Gemini (TTS) instead."
         );
       }
-      buildRequestPayload(options, descriptor, spec, messages) {
+      buildApiRequest(options, descriptor, spec, messages) {
         const systemMessages = messages.filter((message) => message.role === "system");
         const system = systemMessages.length > 0 ? systemMessages.map((m, index) => ({
           type: "text",
-          text: extractText(m.content),
+          text: extractMessageText(m.content),
           // Add cache_control to the LAST system message block
           ...index === systemMessages.length - 1 ? { cache_control: { type: "ephemeral" } } : {}
         })) : void 0;
@@ -6062,7 +6431,7 @@ var init_anthropic = __esm({
        * Handles text, images (base64 only), and applies cache_control.
        */
       convertToAnthropicContent(content, addCacheControl) {
-        const parts = normalizeContent(content);
+        const parts = normalizeMessageContent(content);
         return parts.map((part, index) => {
           const isLastPart = index === parts.length - 1;
           const cacheControl = addCacheControl && isLastPart ? { cache_control: { type: "ephemeral" } } : {};
@@ -6108,7 +6477,7 @@ var init_anthropic = __esm({
         const stream2 = await client.messages.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         let inputTokens = 0;
         let cachedInputTokens = 0;
@@ -6185,7 +6554,7 @@ var init_anthropic = __esm({
       async countTokens(messages, descriptor, _spec) {
         const client = this.client;
         const systemMessages = messages.filter((message) => message.role === "system");
-        const system = systemMessages.length > 0 ? systemMessages.map((m) => extractText(m.content)).join("\n\n") : void 0;
+        const system = systemMessages.length > 0 ? systemMessages.map((m) => extractMessageText(m.content)).join("\n\n") : void 0;
         const conversation = messages.filter(
           (message) => message.role !== "system"
         ).map((message) => ({
@@ -6207,7 +6576,7 @@ var init_anthropic = __esm({
           let totalChars = 0;
           let imageCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -6898,7 +7267,7 @@ var init_gemini = __esm({
           format: spec?.defaultFormat ?? "wav"
         };
       }
-      buildRequestPayload(options, descriptor, _spec, messages) {
+      buildApiRequest(options, descriptor, _spec, messages) {
         const contents = this.convertMessagesToContents(messages);
         const generationConfig = this.buildGenerationConfig(options);
         const config = {
@@ -6950,7 +7319,7 @@ var init_gemini = __esm({
           if (message.role === "system") {
             expandedMessages.push({
               role: "user",
-              content: extractText(message.content)
+              content: extractMessageText(message.content)
             });
             expandedMessages.push({
               role: "assistant",
@@ -7000,7 +7369,7 @@ var init_gemini = __esm({
        * Handles text, images, and audio (Gemini supports all three).
        */
       convertToGeminiParts(content) {
-        const parts = normalizeContent(content);
+        const parts = normalizeMessageContent(content);
         return parts.map((part) => {
           if (part.type === "text") {
             return { text: part.text };
@@ -7045,10 +7414,10 @@ var init_gemini = __esm({
         }
         return Object.keys(config).length > 0 ? config : null;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         for await (const chunk of stream2) {
-          const text3 = this.extractText(chunk);
+          const text3 = this.extractMessageText(chunk);
           if (text3) {
             yield { text: text3, rawEvent: chunk };
           }
@@ -7059,7 +7428,7 @@ var init_gemini = __esm({
           }
         }
       }
-      extractText(chunk) {
+      extractMessageText(chunk) {
         if (!chunk?.candidates) {
           return "";
         }
@@ -7124,7 +7493,7 @@ var init_gemini = __esm({
           let totalChars = 0;
           let mediaCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -7645,14 +8014,7 @@ var OPENAI_TTS_VOICES, OPENAI_TTS_EXTENDED_VOICES, OPENAI_TTS_FORMATS, openaiSpe
 var init_openai_speech_models = __esm({
   "src/providers/openai-speech-models.ts"() {
     "use strict";
-    OPENAI_TTS_VOICES = [
-      "alloy",
-      "echo",
-      "fable",
-      "onyx",
-      "nova",
-      "shimmer"
-    ];
+    OPENAI_TTS_VOICES = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"];
     OPENAI_TTS_EXTENDED_VOICES = [
       ...OPENAI_TTS_VOICES,
       "ash",
@@ -7877,7 +8239,7 @@ var init_openai = __esm({
           format
         };
       }
-      buildRequestPayload(options, descriptor, spec, messages) {
+      buildApiRequest(options, descriptor, spec, messages) {
         const { maxTokens, temperature, topP, stopSequences, extra } = options;
         const supportsTemperature = spec?.metadata?.supportsTemperature !== false;
         const shouldIncludeTemperature = typeof temperature === "number" && supportsTemperature;
@@ -7912,7 +8274,7 @@ var init_openai = __esm({
             ...message.name ? { name: message.name } : {}
           };
         }
-        const textContent = typeof message.content === "string" ? message.content : extractText(message.content);
+        const textContent = typeof message.content === "string" ? message.content : extractMessageText(message.content);
         if (role === "system") {
           return {
             role: "system",
@@ -7972,7 +8334,7 @@ var init_openai = __esm({
         const stream2 = await client.chat.completions.create(payload, signal ? { signal } : void 0);
         return stream2;
       }
-      async *wrapStream(iterable) {
+      async *normalizeProviderStream(iterable) {
         const stream2 = iterable;
         for await (const chunk of stream2) {
           const text3 = chunk.choices.map((choice) => choice.delta?.content ?? "").join("");
@@ -8030,9 +8392,9 @@ var init_openai = __esm({
               tokenCount += OPENAI_MESSAGE_OVERHEAD_TOKENS;
               const roleText = ROLE_MAP[message.role];
               tokenCount += encoding.encode(roleText).length;
-              const textContent = extractText(message.content);
+              const textContent = extractMessageText(message.content);
               tokenCount += encoding.encode(textContent).length;
-              const parts = normalizeContent(message.content);
+              const parts = normalizeMessageContent(message.content);
               for (const part of parts) {
                 if (part.type === "image") {
                   imageCount++;
@@ -8057,7 +8419,7 @@ var init_openai = __esm({
           let totalChars = 0;
           let imageCount = 0;
           for (const msg of messages) {
-            const parts = normalizeContent(msg.content);
+            const parts = normalizeMessageContent(msg.content);
             for (const part of parts) {
               if (part.type === "text") {
                 totalChars += part.text.length;
@@ -8350,9 +8712,7 @@ var init_image = __esm({
         return this.findImageAdapter(modelId) !== void 0;
       }
       findImageAdapter(modelId) {
-        return this.adapters.find(
-          (adapter) => adapter.supportsImageGeneration?.(modelId) ?? false
-        );
+        return this.adapters.find((adapter) => adapter.supportsImageGeneration?.(modelId) ?? false);
       }
     };
   }
@@ -8404,9 +8764,7 @@ var init_speech = __esm({
         return this.findSpeechAdapter(modelId) !== void 0;
       }
       findSpeechAdapter(modelId) {
-        return this.adapters.find(
-          (adapter) => adapter.supportsSpeechGeneration?.(modelId) ?? false
-        );
+        return this.adapters.find((adapter) => adapter.supportsSpeechGeneration?.(modelId) ?? false);
       }
     };
   }
@@ -8517,11 +8875,7 @@ var init_vision = __esm({
             if (!parsed) {
               throw new Error("Invalid data URL format");
             }
-            builder.addUserWithImage(
-              options.prompt,
-              parsed.data,
-              parsed.mimeType
-            );
+            builder.addUserWithImage(options.prompt, parsed.data, parsed.mimeType);
           } else {
             const buffer = Buffer.from(options.image, "base64");
             builder.addUserWithImage(options.prompt, buffer, options.mimeType);
@@ -8952,46 +9306,271 @@ __export(testing_exports, {
 });
 module.exports = __toCommonJS(testing_exports);
 
-// src/gadgets/validation.ts
-function validateAndApplyDefaults(schema, params) {
-  const result = schema.safeParse(params);
-  if (result.success) {
-    return {
-      success: true,
-      data: result.data
-    };
-  }
-  const issues = result.error.issues.map((issue) => ({
-    path: issue.path.join(".") || "root",
-    message: issue.message
-  }));
-  const formattedError = `Invalid parameters: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`;
+// src/testing/cli-helpers.ts
+var import_node_stream = require("stream");
+function createTestEnvironment(options = {}) {
+  const stdin = createMockReadable(options.stdin);
+  const stdout = new import_node_stream.PassThrough();
+  const stderr = new import_node_stream.PassThrough();
+  let exitCode;
   return {
-    success: false,
-    error: formattedError,
-    issues
+    stdin,
+    stdout,
+    stderr,
+    isTTY: options.isTTY ?? false,
+    argv: options.argv ?? ["node", "llmist"],
+    env: { ...filterDefinedEnv(process.env), ...options.env },
+    get exitCode() {
+      return exitCode;
+    },
+    setExitCode: (code) => {
+      exitCode = code;
+    }
   };
 }
-function validateGadgetParams(gadget, params) {
-  if (!gadget.parameterSchema) {
-    return {
-      success: true,
-      data: params
-    };
+function createMockReadable(input) {
+  if (!input) {
+    const stream3 = new import_node_stream.Readable({ read() {
+    } });
+    stream3.push(null);
+    return stream3;
   }
-  return validateAndApplyDefaults(gadget.parameterSchema, params);
+  const content = Array.isArray(input) ? `${input.join("\n")}
+` : input;
+  const stream2 = new import_node_stream.Readable({ read() {
+  } });
+  stream2.push(content);
+  stream2.push(null);
+  return stream2;
 }
-
-// src/testing/gadget-testing.ts
-async function testGadget(gadget, params, options) {
-  let validatedParams = params;
-  if (!options?.skipValidation) {
-    const validationResult = validateGadgetParams(gadget, params);
-    if (!validationResult.success) {
-      return {
-        error: validationResult.error,
-        validatedParams: params
-      };
+function createMockWritable() {
+  const chunks = [];
+  const stream2 = new import_node_stream.Writable({
+    write(chunk, _encoding, callback) {
+      chunks.push(Buffer.from(chunk));
+      callback();
+    }
+  });
+  stream2.getData = () => Buffer.concat(chunks).toString("utf8");
+  return stream2;
+}
+async function collectOutput(stream2, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timeoutId = setTimeout(() => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    }, timeout);
+    stream2.on("data", (chunk) => {
+      chunks.push(Buffer.from(chunk));
+    });
+    stream2.on("end", () => {
+      clearTimeout(timeoutId);
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    stream2.on("error", (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+function getBufferedOutput(stream2) {
+  const chunks = [];
+  for (; ; ) {
+    const chunk = stream2.read();
+    if (chunk === null) break;
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function createMockPrompt(responses) {
+  let index = 0;
+  return async (_question) => {
+    if (index >= responses.length) {
+      throw new Error(`Mock prompt exhausted: no response for question ${index + 1}`);
+    }
+    return responses[index++];
+  };
+}
+var MockPromptRecorder = class {
+  responses;
+  index = 0;
+  questions = [];
+  constructor(responses) {
+    this.responses = responses;
+  }
+  /**
+   * The prompt function to use in tests.
+   */
+  prompt = async (question) => {
+    this.questions.push(question);
+    if (this.index >= this.responses.length) {
+      throw new Error(`Mock prompt exhausted after ${this.index} questions`);
+    }
+    return this.responses[this.index++];
+  };
+  /**
+   * Get all questions that were asked.
+   */
+  getQuestions() {
+    return [...this.questions];
+  }
+  /**
+   * Get the number of questions asked.
+   */
+  getQuestionCount() {
+    return this.questions.length;
+  }
+  /**
+   * Reset the recorder state.
+   */
+  reset(newResponses) {
+    this.index = 0;
+    this.questions = [];
+    if (newResponses) {
+      this.responses = newResponses;
+    }
+  }
+};
+async function waitFor(condition, timeout = 5e3, interval = 50) {
+  const startTime = Date.now();
+  while (!condition()) {
+    if (Date.now() - startTime > timeout) {
+      throw new Error(`waitFor timed out after ${timeout}ms`);
+    }
+    await sleep(interval);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function filterDefinedEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/testing/conversation-fixtures.ts
+function createConversation(turnCount, options) {
+  const messages = [];
+  const userPrefix = options?.userPrefix ?? "User message";
+  const assistantPrefix = options?.assistantPrefix ?? "Assistant response";
+  const contentLength = options?.contentLength ?? 100;
+  for (let i = 0; i < turnCount; i++) {
+    const padding = " ".repeat(Math.max(0, contentLength - 30));
+    messages.push({
+      role: "user",
+      content: `${userPrefix} ${i + 1}: This is turn ${i + 1} of the conversation.${padding}`
+    });
+    messages.push({
+      role: "assistant",
+      content: `${assistantPrefix} ${i + 1}: I acknowledge turn ${i + 1}.${padding}`
+    });
+  }
+  return messages;
+}
+function createConversationWithGadgets(turnCount, gadgetCallsPerTurn = 1, options) {
+  const messages = [];
+  const gadgetNames = options?.gadgetNames ?? ["search", "calculate", "read"];
+  const contentLength = options?.contentLength ?? 50;
+  let gadgetIndex = 0;
+  for (let turn = 0; turn < turnCount; turn++) {
+    messages.push({
+      role: "user",
+      content: `User request ${turn + 1}${"x".repeat(contentLength)}`
+    });
+    for (let g = 0; g < gadgetCallsPerTurn; g++) {
+      const gadgetName = gadgetNames[gadgetIndex % gadgetNames.length];
+      gadgetIndex++;
+      messages.push({
+        role: "assistant",
+        content: `!!!GADGET_START:${gadgetName}
+!!!ARG:query
+test query ${turn}-${g}
+!!!GADGET_END`
+      });
+      messages.push({
+        role: "user",
+        content: `Result: Gadget ${gadgetName} returned result for query ${turn}-${g}`
+      });
+    }
+    messages.push({
+      role: "assistant",
+      content: `Final response for turn ${turn + 1}${"y".repeat(contentLength)}`
+    });
+  }
+  return messages;
+}
+function estimateTokens(messages) {
+  return Math.ceil(messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4);
+}
+function createUserMessage(content) {
+  return { role: "user", content };
+}
+function createAssistantMessage(content) {
+  return { role: "assistant", content };
+}
+function createSystemMessage(content) {
+  return { role: "system", content };
+}
+function createMinimalConversation() {
+  return [
+    { role: "user", content: "Hello" },
+    { role: "assistant", content: "Hi there!" }
+  ];
+}
+function createLargeConversation(targetTokens, options) {
+  const tokensPerTurn = options?.tokensPerTurn ?? 200;
+  const turnsNeeded = Math.ceil(targetTokens / tokensPerTurn);
+  const charsPerMessage = Math.floor(tokensPerTurn * 4 / 2);
+  return createConversation(turnsNeeded, {
+    contentLength: charsPerMessage
+  });
+}
+
+// src/gadgets/validation.ts
+function validateAndApplyDefaults(schema, params) {
+  const result = schema.safeParse(params);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  const issues = result.error.issues.map((issue) => ({
+    path: issue.path.join(".") || "root",
+    message: issue.message
+  }));
+  const formattedError = `Invalid parameters: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`;
+  return {
+    success: false,
+    error: formattedError,
+    issues
+  };
+}
+function validateGadgetParams(gadget, params) {
+  if (!gadget.parameterSchema) {
+    return {
+      success: true,
+      data: params
+    };
+  }
+  return validateAndApplyDefaults(gadget.parameterSchema, params);
+}
+
+// src/testing/gadget-testing.ts
+async function testGadget(gadget, params, options) {
+  let validatedParams = params;
+  if (!options?.skipValidation) {
+    const validationResult = validateGadgetParams(gadget, params);
+    if (!validationResult.success) {
+      return {
+        error: validationResult.error,
+        validatedParams: params
+      };
     }
     validatedParams = validationResult.data;
   }
@@ -9189,7 +9768,7 @@ function getMockManager(options) {
 
 // src/testing/mock-stream.ts
 init_constants();
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function generateInvocationId() {
@@ -9270,7 +9849,7 @@ ${blockParams}${GADGET_END_PREFIX}`;
 }
 async function* createMockStream(response) {
   if (response.delayMs) {
-    await sleep(response.delayMs);
+    await sleep2(response.delayMs);
   }
   const streamDelay = response.streamDelayMs ?? 0;
   let fullText = response.text ?? "";
@@ -9295,7 +9874,7 @@ async function* createMockStream(response) {
       }
       yield chunk;
       if (streamDelay > 0 && !isLast) {
-        await sleep(streamDelay);
+        await sleep2(streamDelay);
       }
     }
   } else {
@@ -9572,7 +10151,9 @@ var MockBuilder = class {
    */
   whenMessageContains(text3) {
     this.matchers.push(
-      (ctx) => ctx.messages.some((msg) => extractText(msg.content).toLowerCase().includes(text3.toLowerCase()))
+      (ctx) => ctx.messages.some(
+        (msg) => extractMessageText(msg.content).toLowerCase().includes(text3.toLowerCase())
+      )
     );
     return this;
   }
@@ -9586,7 +10167,7 @@ var MockBuilder = class {
     this.matchers.push((ctx) => {
       const lastMsg = ctx.messages[ctx.messages.length - 1];
       if (!lastMsg) return false;
-      return extractText(lastMsg.content).toLowerCase().includes(text3.toLowerCase());
+      return extractMessageText(lastMsg.content).toLowerCase().includes(text3.toLowerCase());
     });
     return this;
   }
@@ -9597,7 +10178,7 @@ var MockBuilder = class {
    * mockLLM().whenMessageMatches(/calculate \d+/)
    */
   whenMessageMatches(regex) {
-    this.matchers.push((ctx) => ctx.messages.some((msg) => regex.test(extractText(msg.content))));
+    this.matchers.push((ctx) => ctx.messages.some((msg) => regex.test(extractMessageText(msg.content))));
     return this;
   }
   /**
@@ -9609,7 +10190,7 @@ var MockBuilder = class {
   whenRoleContains(role, text3) {
     this.matchers.push(
       (ctx) => ctx.messages.some(
-        (msg) => msg.role === role && extractText(msg.content).toLowerCase().includes(text3.toLowerCase())
+        (msg) => msg.role === role && extractMessageText(msg.content).toLowerCase().includes(text3.toLowerCase())
       )
     );
     return this;
@@ -10010,32 +10591,161 @@ function createMockClient(options) {
   });
 }
 
-// src/testing/mock-gadget.ts
-init_gadget();
-var MockGadgetImpl = class extends BaseGadget {
-  name;
-  description;
-  parameterSchema;
-  timeoutMs;
-  calls = [];
-  resultValue;
-  resultFn;
-  errorToThrow;
-  delayMs;
-  shouldTrackCalls;
-  constructor(config) {
-    super();
-    this.name = config.name;
-    this.description = config.description ?? `Mock gadget: ${config.name}`;
-    this.parameterSchema = config.schema;
-    this.resultValue = config.result;
-    this.resultFn = config.resultFn;
-    this.delayMs = config.delayMs ?? 0;
-    this.shouldTrackCalls = config.trackCalls ?? true;
-    this.timeoutMs = config.timeoutMs;
-    if (config.error) {
-      this.errorToThrow = typeof config.error === "string" ? new Error(config.error) : config.error;
-    }
+// src/testing/mock-conversation.ts
+var MockConversationManager = class {
+  history;
+  baseMessages;
+  replacementHistory;
+  replaceHistoryCallCount = 0;
+  addedMessages = [];
+  constructor(history = [], baseMessages = []) {
+    this.history = [...history];
+    this.baseMessages = [...baseMessages];
+  }
+  addUserMessage(content) {
+    const msg = { role: "user", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addAssistantMessage(content) {
+    const msg = { role: "assistant", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addGadgetCallResult(gadgetName, parameters, result) {
+    const assistantMsg = {
+      role: "assistant",
+      content: `!!!GADGET_START:${gadgetName}
+${JSON.stringify(parameters)}
+!!!GADGET_END`
+    };
+    const resultMsg = {
+      role: "user",
+      content: `Result: ${result}`
+    };
+    this.history.push(assistantMsg);
+    this.history.push(resultMsg);
+    this.addedMessages.push(assistantMsg);
+    this.addedMessages.push(resultMsg);
+  }
+  getMessages() {
+    return [...this.baseMessages, ...this.history];
+  }
+  getHistoryMessages() {
+    return [...this.history];
+  }
+  getBaseMessages() {
+    return [...this.baseMessages];
+  }
+  replaceHistory(newHistory) {
+    this.replacementHistory = [...newHistory];
+    this.history = [...newHistory];
+    this.replaceHistoryCallCount++;
+  }
+  // ============================================
+  // Test Helper Methods
+  // ============================================
+  /**
+   * Check if replaceHistory was called.
+   */
+  wasReplaceHistoryCalled() {
+    return this.replaceHistoryCallCount > 0;
+  }
+  /**
+   * Get the number of times replaceHistory was called.
+   */
+  getReplaceHistoryCallCount() {
+    return this.replaceHistoryCallCount;
+  }
+  /**
+   * Get the most recent history passed to replaceHistory.
+   * Returns undefined if replaceHistory was never called.
+   */
+  getReplacementHistory() {
+    return this.replacementHistory;
+  }
+  /**
+   * Get all messages that were added via add* methods.
+   */
+  getAddedMessages() {
+    return [...this.addedMessages];
+  }
+  /**
+   * Reset all tracking state while preserving the conversation.
+   */
+  resetTracking() {
+    this.replacementHistory = void 0;
+    this.replaceHistoryCallCount = 0;
+    this.addedMessages = [];
+  }
+  /**
+   * Completely reset the mock to initial state.
+   * Note: baseMessages cannot be changed after construction.
+   */
+  reset(history = []) {
+    this.history = [...history];
+    this.resetTracking();
+  }
+  /**
+   * Set the history directly (for test setup).
+   */
+  setHistory(messages) {
+    this.history = [...messages];
+  }
+  /**
+   * Get the current history length.
+   */
+  getHistoryLength() {
+    return this.history.length;
+  }
+  /**
+   * Get total message count (base + history).
+   */
+  getTotalMessageCount() {
+    return this.baseMessages.length + this.history.length;
+  }
+};
+function createMockConversationManager(turnCount, baseMessages = []) {
+  const history = [];
+  for (let i = 0; i < turnCount; i++) {
+    history.push({
+      role: "user",
+      content: `User message ${i + 1}: This is turn ${i + 1} of the conversation.`
+    });
+    history.push({
+      role: "assistant",
+      content: `Assistant response ${i + 1}: I acknowledge turn ${i + 1}.`
+    });
+  }
+  return new MockConversationManager(history, baseMessages);
+}
+
+// src/testing/mock-gadget.ts
+init_gadget();
+var MockGadgetImpl = class extends AbstractGadget {
+  name;
+  description;
+  parameterSchema;
+  timeoutMs;
+  calls = [];
+  resultValue;
+  resultFn;
+  errorToThrow;
+  delayMs;
+  shouldTrackCalls;
+  constructor(config) {
+    super();
+    this.name = config.name;
+    this.description = config.description ?? `Mock gadget: ${config.name}`;
+    this.parameterSchema = config.schema;
+    this.resultValue = config.result;
+    this.resultFn = config.resultFn;
+    this.delayMs = config.delayMs ?? 0;
+    this.shouldTrackCalls = config.trackCalls ?? true;
+    this.timeoutMs = config.timeoutMs;
+    if (config.error) {
+      this.errorToThrow = typeof config.error === "string" ? new Error(config.error) : config.error;
+    }
   }
   async execute(params) {
     if (this.shouldTrackCalls) {
@@ -10169,7 +10879,7 @@ function createTestStream(chunks) {
 function createTextStream(text3, options) {
   return async function* () {
     if (options?.delayMs) {
-      await sleep2(options.delayMs);
+      await sleep3(options.delayMs);
     }
     const chunkSize = options?.chunkSize ?? text3.length;
     const chunks = [];
@@ -10191,7 +10901,7 @@ function createTextStream(text3, options) {
       }
       yield chunk;
       if (options?.chunkDelayMs && !isLast) {
-        await sleep2(options.chunkDelayMs);
+        await sleep3(options.chunkDelayMs);
       }
     }
   }();
@@ -10229,365 +10939,9 @@ function createErrorStream(chunksBeforeError, error) {
     throw error;
   }();
 }
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/testing/conversation-fixtures.ts
-function createConversation(turnCount, options) {
-  const messages = [];
-  const userPrefix = options?.userPrefix ?? "User message";
-  const assistantPrefix = options?.assistantPrefix ?? "Assistant response";
-  const contentLength = options?.contentLength ?? 100;
-  for (let i = 0; i < turnCount; i++) {
-    const padding = " ".repeat(Math.max(0, contentLength - 30));
-    messages.push({
-      role: "user",
-      content: `${userPrefix} ${i + 1}: This is turn ${i + 1} of the conversation.${padding}`
-    });
-    messages.push({
-      role: "assistant",
-      content: `${assistantPrefix} ${i + 1}: I acknowledge turn ${i + 1}.${padding}`
-    });
-  }
-  return messages;
-}
-function createConversationWithGadgets(turnCount, gadgetCallsPerTurn = 1, options) {
-  const messages = [];
-  const gadgetNames = options?.gadgetNames ?? ["search", "calculate", "read"];
-  const contentLength = options?.contentLength ?? 50;
-  let gadgetIndex = 0;
-  for (let turn = 0; turn < turnCount; turn++) {
-    messages.push({
-      role: "user",
-      content: `User request ${turn + 1}${"x".repeat(contentLength)}`
-    });
-    for (let g = 0; g < gadgetCallsPerTurn; g++) {
-      const gadgetName = gadgetNames[gadgetIndex % gadgetNames.length];
-      gadgetIndex++;
-      messages.push({
-        role: "assistant",
-        content: `!!!GADGET_START:${gadgetName}
-!!!ARG:query
-test query ${turn}-${g}
-!!!GADGET_END`
-      });
-      messages.push({
-        role: "user",
-        content: `Result: Gadget ${gadgetName} returned result for query ${turn}-${g}`
-      });
-    }
-    messages.push({
-      role: "assistant",
-      content: `Final response for turn ${turn + 1}${"y".repeat(contentLength)}`
-    });
-  }
-  return messages;
-}
-function estimateTokens(messages) {
-  return Math.ceil(
-    messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4
-  );
-}
-function createUserMessage(content) {
-  return { role: "user", content };
-}
-function createAssistantMessage(content) {
-  return { role: "assistant", content };
-}
-function createSystemMessage(content) {
-  return { role: "system", content };
-}
-function createMinimalConversation() {
-  return [
-    { role: "user", content: "Hello" },
-    { role: "assistant", content: "Hi there!" }
-  ];
-}
-function createLargeConversation(targetTokens, options) {
-  const tokensPerTurn = options?.tokensPerTurn ?? 200;
-  const turnsNeeded = Math.ceil(targetTokens / tokensPerTurn);
-  const charsPerMessage = Math.floor(tokensPerTurn * 4 / 2);
-  return createConversation(turnsNeeded, {
-    contentLength: charsPerMessage
-  });
-}
-
-// src/testing/mock-conversation.ts
-var MockConversationManager = class {
-  history;
-  baseMessages;
-  replacementHistory;
-  replaceHistoryCallCount = 0;
-  addedMessages = [];
-  constructor(history = [], baseMessages = []) {
-    this.history = [...history];
-    this.baseMessages = [...baseMessages];
-  }
-  addUserMessage(content) {
-    const msg = { role: "user", content };
-    this.history.push(msg);
-    this.addedMessages.push(msg);
-  }
-  addAssistantMessage(content) {
-    const msg = { role: "assistant", content };
-    this.history.push(msg);
-    this.addedMessages.push(msg);
-  }
-  addGadgetCall(gadgetName, parameters, result) {
-    const assistantMsg = {
-      role: "assistant",
-      content: `!!!GADGET_START:${gadgetName}
-${JSON.stringify(parameters)}
-!!!GADGET_END`
-    };
-    const resultMsg = {
-      role: "user",
-      content: `Result: ${result}`
-    };
-    this.history.push(assistantMsg);
-    this.history.push(resultMsg);
-    this.addedMessages.push(assistantMsg);
-    this.addedMessages.push(resultMsg);
-  }
-  getMessages() {
-    return [...this.baseMessages, ...this.history];
-  }
-  getHistoryMessages() {
-    return [...this.history];
-  }
-  getBaseMessages() {
-    return [...this.baseMessages];
-  }
-  replaceHistory(newHistory) {
-    this.replacementHistory = [...newHistory];
-    this.history = [...newHistory];
-    this.replaceHistoryCallCount++;
-  }
-  // ============================================
-  // Test Helper Methods
-  // ============================================
-  /**
-   * Check if replaceHistory was called.
-   */
-  wasReplaceHistoryCalled() {
-    return this.replaceHistoryCallCount > 0;
-  }
-  /**
-   * Get the number of times replaceHistory was called.
-   */
-  getReplaceHistoryCallCount() {
-    return this.replaceHistoryCallCount;
-  }
-  /**
-   * Get the most recent history passed to replaceHistory.
-   * Returns undefined if replaceHistory was never called.
-   */
-  getReplacementHistory() {
-    return this.replacementHistory;
-  }
-  /**
-   * Get all messages that were added via add* methods.
-   */
-  getAddedMessages() {
-    return [...this.addedMessages];
-  }
-  /**
-   * Reset all tracking state while preserving the conversation.
-   */
-  resetTracking() {
-    this.replacementHistory = void 0;
-    this.replaceHistoryCallCount = 0;
-    this.addedMessages = [];
-  }
-  /**
-   * Completely reset the mock to initial state.
-   * Note: baseMessages cannot be changed after construction.
-   */
-  reset(history = []) {
-    this.history = [...history];
-    this.resetTracking();
-  }
-  /**
-   * Set the history directly (for test setup).
-   */
-  setHistory(messages) {
-    this.history = [...messages];
-  }
-  /**
-   * Get the current history length.
-   */
-  getHistoryLength() {
-    return this.history.length;
-  }
-  /**
-   * Get total message count (base + history).
-   */
-  getTotalMessageCount() {
-    return this.baseMessages.length + this.history.length;
-  }
-};
-function createMockConversationManager(turnCount, baseMessages = []) {
-  const history = [];
-  for (let i = 0; i < turnCount; i++) {
-    history.push({
-      role: "user",
-      content: `User message ${i + 1}: This is turn ${i + 1} of the conversation.`
-    });
-    history.push({
-      role: "assistant",
-      content: `Assistant response ${i + 1}: I acknowledge turn ${i + 1}.`
-    });
-  }
-  return new MockConversationManager(history, baseMessages);
-}
-
-// src/testing/cli-helpers.ts
-var import_node_stream = require("stream");
-function createTestEnvironment(options = {}) {
-  const stdin = createMockReadable(options.stdin);
-  const stdout = new import_node_stream.PassThrough();
-  const stderr = new import_node_stream.PassThrough();
-  let exitCode;
-  return {
-    stdin,
-    stdout,
-    stderr,
-    isTTY: options.isTTY ?? false,
-    argv: options.argv ?? ["node", "llmist"],
-    env: { ...filterDefinedEnv(process.env), ...options.env },
-    get exitCode() {
-      return exitCode;
-    },
-    setExitCode: (code) => {
-      exitCode = code;
-    }
-  };
-}
-function createMockReadable(input) {
-  if (!input) {
-    const stream3 = new import_node_stream.Readable({ read() {
-    } });
-    stream3.push(null);
-    return stream3;
-  }
-  const content = Array.isArray(input) ? `${input.join("\n")}
-` : input;
-  const stream2 = new import_node_stream.Readable({ read() {
-  } });
-  stream2.push(content);
-  stream2.push(null);
-  return stream2;
-}
-function createMockWritable() {
-  const chunks = [];
-  const stream2 = new import_node_stream.Writable({
-    write(chunk, _encoding, callback) {
-      chunks.push(Buffer.from(chunk));
-      callback();
-    }
-  });
-  stream2.getData = () => Buffer.concat(chunks).toString("utf8");
-  return stream2;
-}
-async function collectOutput(stream2, timeout = 5e3) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    const timeoutId = setTimeout(() => {
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    }, timeout);
-    stream2.on("data", (chunk) => {
-      chunks.push(Buffer.from(chunk));
-    });
-    stream2.on("end", () => {
-      clearTimeout(timeoutId);
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    });
-    stream2.on("error", (err) => {
-      clearTimeout(timeoutId);
-      reject(err);
-    });
-  });
-}
-function getBufferedOutput(stream2) {
-  const chunks = [];
-  for (; ; ) {
-    const chunk = stream2.read();
-    if (chunk === null) break;
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-function createMockPrompt(responses) {
-  let index = 0;
-  return async (_question) => {
-    if (index >= responses.length) {
-      throw new Error(`Mock prompt exhausted: no response for question ${index + 1}`);
-    }
-    return responses[index++];
-  };
-}
-var MockPromptRecorder = class {
-  responses;
-  index = 0;
-  questions = [];
-  constructor(responses) {
-    this.responses = responses;
-  }
-  /**
-   * The prompt function to use in tests.
-   */
-  prompt = async (question) => {
-    this.questions.push(question);
-    if (this.index >= this.responses.length) {
-      throw new Error(`Mock prompt exhausted after ${this.index} questions`);
-    }
-    return this.responses[this.index++];
-  };
-  /**
-   * Get all questions that were asked.
-   */
-  getQuestions() {
-    return [...this.questions];
-  }
-  /**
-   * Get the number of questions asked.
-   */
-  getQuestionCount() {
-    return this.questions.length;
-  }
-  /**
-   * Reset the recorder state.
-   */
-  reset(newResponses) {
-    this.index = 0;
-    this.questions = [];
-    if (newResponses) {
-      this.responses = newResponses;
-    }
-  }
-};
-async function waitFor(condition, timeout = 5e3, interval = 50) {
-  const startTime = Date.now();
-  while (!condition()) {
-    if (Date.now() - startTime > timeout) {
-      throw new Error(`waitFor timed out after ${timeout}ms`);
-    }
-    await sleep3(interval);
-  }
-}
 function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function filterDefinedEnv(env) {
-  const result = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (value !== void 0) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MockBuilder,