llmist 17.3.0 → 17.5.0

package/dist/chunk-HM7PUGPA.js

@@ -0,0 +1,2252 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/constants.ts
+var GADGET_START_PREFIX, GADGET_END_PREFIX, GADGET_ARG_PREFIX, DEFAULT_GADGET_OUTPUT_LIMIT, DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT, CHARS_PER_TOKEN, FALLBACK_CONTEXT_WINDOW;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    "use strict";
+    GADGET_START_PREFIX = "!!!GADGET_START:";
+    GADGET_END_PREFIX = "!!!GADGET_END";
+    GADGET_ARG_PREFIX = "!!!ARG:";
+    DEFAULT_GADGET_OUTPUT_LIMIT = true;
+    DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT = 15;
+    CHARS_PER_TOKEN = 2;
+    FALLBACK_CONTEXT_WINDOW = 128e3;
+  }
+});
+
+// src/core/input-content.ts
+function isTextPart(part) {
+  return part.type === "text";
+}
+function isImagePart(part) {
+  return part.type === "image";
+}
+function isAudioPart(part) {
+  return part.type === "audio";
+}
+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",
+    source: { type: "url", url }
+  };
+}
+function detectImageMimeType(data) {
+  const bytes = data instanceof Buffer ? data : Buffer.from(data);
+  for (const { bytes: magic, mimeType } of IMAGE_MAGIC_BYTES) {
+    if (bytes.length >= magic.length) {
+      let matches = true;
+      for (let i = 0; i < magic.length; i++) {
+        if (bytes[i] !== magic[i]) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) {
+        if (mimeType === "image/webp") {
+          if (bytes.length >= 12) {
+            const webpMarker = bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80;
+            if (!webpMarker) continue;
+          }
+        }
+        return mimeType;
+      }
+    }
+  }
+  return null;
+}
+function detectAudioMimeType(data) {
+  const bytes = data instanceof Buffer ? data : Buffer.from(data);
+  for (const { bytes: magic, mimeType } of AUDIO_MAGIC_BYTES) {
+    if (bytes.length >= magic.length) {
+      let matches = true;
+      for (let i = 0; i < magic.length; i++) {
+        if (bytes[i] !== magic[i]) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) {
+        if (mimeType === "audio/wav") {
+          if (bytes.length >= 12) {
+            const waveMarker = bytes[8] === 87 && bytes[9] === 65 && bytes[10] === 86 && bytes[11] === 69;
+            if (!waveMarker) continue;
+          }
+        }
+        return mimeType;
+      }
+    }
+  }
+  return null;
+}
+function toBase64(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  return Buffer.from(data).toString("base64");
+}
+function imageFromBuffer(buffer, mediaType) {
+  const detectedType = mediaType ?? detectImageMimeType(buffer);
+  if (!detectedType) {
+    throw new Error(
+      "Could not detect image MIME type. Please provide the mediaType parameter explicitly."
+    );
+  }
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      mediaType: detectedType,
+      data: toBase64(buffer)
+    }
+  };
+}
+function audioFromBase64(data, mediaType) {
+  return {
+    type: "audio",
+    source: { type: "base64", mediaType, data }
+  };
+}
+function audioFromBuffer(buffer, mediaType) {
+  const detectedType = mediaType ?? detectAudioMimeType(buffer);
+  if (!detectedType) {
+    throw new Error(
+      "Could not detect audio MIME type. Please provide the mediaType parameter explicitly."
+    );
+  }
+  return {
+    type: "audio",
+    source: {
+      type: "base64",
+      mediaType: detectedType,
+      data: toBase64(buffer)
+    }
+  };
+}
+function isDataUrl(input) {
+  return input.startsWith("data:");
+}
+function parseDataUrl(url) {
+  const match = url.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) return null;
+  return { mimeType: match[1], data: match[2] };
+}
+var IMAGE_MAGIC_BYTES, AUDIO_MAGIC_BYTES;
+var init_input_content = __esm({
+  "src/core/input-content.ts"() {
+    "use strict";
+    IMAGE_MAGIC_BYTES = [
+      { bytes: [255, 216, 255], mimeType: "image/jpeg" },
+      { bytes: [137, 80, 78, 71], mimeType: "image/png" },
+      { bytes: [71, 73, 70, 56], mimeType: "image/gif" },
+      // WebP starts with RIFF....WEBP
+      { bytes: [82, 73, 70, 70], mimeType: "image/webp" }
+    ];
+    AUDIO_MAGIC_BYTES = [
+      // MP3 frame sync
+      { bytes: [255, 251], mimeType: "audio/mp3" },
+      { bytes: [255, 250], mimeType: "audio/mp3" },
+      // ID3 tag (MP3)
+      { bytes: [73, 68, 51], mimeType: "audio/mp3" },
+      // OGG
+      { bytes: [79, 103, 103, 83], mimeType: "audio/ogg" },
+      // WAV (RIFF)
+      { bytes: [82, 73, 70, 70], mimeType: "audio/wav" },
+      // WebM
+      { bytes: [26, 69, 223, 163], mimeType: "audio/webm" },
+      // FLAC (fLaC)
+      { bytes: [102, 76, 97, 67], mimeType: "audio/flac" }
+    ];
+  }
+});
+
+// src/core/prompt-config.ts
+function resolvePromptTemplate(template, defaultValue, context) {
+  const resolved = template ?? defaultValue;
+  return typeof resolved === "function" ? resolved(context) : resolved;
+}
+function resolveRulesTemplate(rules, context) {
+  const resolved = rules ?? DEFAULT_PROMPTS.rules;
+  if (Array.isArray(resolved)) {
+    return resolved;
+  }
+  if (typeof resolved === "function") {
+    const result = resolved(context);
+    return Array.isArray(result) ? result : [result];
+  }
+  return [resolved];
+}
+function resolveHintTemplate(template, defaultValue, context) {
+  const resolved = template ?? defaultValue;
+  if (typeof resolved === "function") {
+    return resolved(context);
+  }
+  return resolved.replace(/\{iteration\}/g, String(context.iteration)).replace(/\{maxIterations\}/g, String(context.maxIterations)).replace(/\{remaining\}/g, String(context.remaining));
+}
+var DEFAULT_HINTS, DEFAULT_PROMPTS;
+var init_prompt_config = __esm({
+  "src/core/prompt-config.ts"() {
+    "use strict";
+    DEFAULT_HINTS = {
+      parallelGadgetsHint: "Tip: You can call multiple gadgets in a single response for efficiency.",
+      iterationProgressHint: "[Iteration {iteration}/{maxIterations}] Plan your actions accordingly."
+    };
+    DEFAULT_PROMPTS = {
+      mainInstruction: [
+        "\u26A0\uFE0F CRITICAL: RESPOND ONLY WITH GADGET INVOCATIONS",
+        "DO NOT use function calling or tool calling",
+        "You must output the exact text markers shown below in plain text.",
+        "EACH MARKER MUST START WITH A NEWLINE."
+      ].join("\n"),
+      criticalUsage: "INVOKE gadgets using the markers - do not describe what you want to do.",
+      formatDescription: (ctx) => `Parameters using ${ctx.argPrefix}name markers (value on next line(s), no escaping needed)`,
+      rules: () => [
+        "Output ONLY plain text with the exact markers - never use function/tool calling",
+        "You can invoke multiple gadgets in a single response",
+        "Gadgets without dependencies execute immediately (in parallel if multiple)",
+        "Use :invocation_id:dep1,dep2 syntax when a gadget needs results from prior gadgets",
+        "If any dependency fails, dependent gadgets are automatically skipped"
+      ],
+      customExamples: null
+    };
+  }
+});
+
+// src/core/messages.ts
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  return content;
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+var LLMMessageBuilder;
+var init_messages = __esm({
+  "src/core/messages.ts"() {
+    "use strict";
+    init_constants();
+    init_input_content();
+    init_prompt_config();
+    LLMMessageBuilder = class {
+      messages = [];
+      startPrefix = GADGET_START_PREFIX;
+      endPrefix = GADGET_END_PREFIX;
+      argPrefix = GADGET_ARG_PREFIX;
+      promptConfig;
+      constructor(promptConfig) {
+        this.promptConfig = promptConfig ?? {};
+      }
+      /**
+       * Set custom prefixes for gadget markers.
+       * Used to configure history builder to match system prompt markers.
+       */
+      withPrefixes(startPrefix, endPrefix, argPrefix) {
+        this.startPrefix = startPrefix;
+        this.endPrefix = endPrefix;
+        if (argPrefix) {
+          this.argPrefix = argPrefix;
+        }
+        return this;
+      }
+      addSystem(content, metadata) {
+        this.messages.push({ role: "system", content, metadata });
+        return this;
+      }
+      addGadgets(gadgets, options) {
+        if (options?.startPrefix) {
+          this.startPrefix = options.startPrefix;
+        }
+        if (options?.endPrefix) {
+          this.endPrefix = options.endPrefix;
+        }
+        if (options?.argPrefix) {
+          this.argPrefix = options.argPrefix;
+        }
+        const context = {
+          startPrefix: this.startPrefix,
+          endPrefix: this.endPrefix,
+          argPrefix: this.argPrefix,
+          gadgetCount: gadgets.length,
+          gadgetNames: gadgets.map((g) => g.name ?? g.constructor.name)
+        };
+        const parts = [];
+        const mainInstruction = resolvePromptTemplate(
+          this.promptConfig.mainInstruction,
+          DEFAULT_PROMPTS.mainInstruction,
+          context
+        );
+        parts.push(mainInstruction);
+        parts.push(this.buildGadgetsSection(gadgets));
+        parts.push(this.buildUsageSection(context));
+        this.messages.push({ role: "system", content: parts.join("") });
+        return this;
+      }
+      buildGadgetsSection(gadgets) {
+        const parts = [];
+        parts.push("\n\nAVAILABLE GADGETS");
+        parts.push("\n=================\n");
+        for (const gadget of gadgets) {
+          const gadgetName = gadget.name ?? gadget.constructor.name;
+          const instruction = gadget.getInstruction({
+            argPrefix: this.argPrefix,
+            startPrefix: this.startPrefix,
+            endPrefix: this.endPrefix
+          });
+          const schemaMarker = "\n\nInput Schema (BLOCK):";
+          const schemaIndex = instruction.indexOf(schemaMarker);
+          const description = (schemaIndex !== -1 ? instruction.substring(0, schemaIndex) : instruction).trim();
+          const schema = schemaIndex !== -1 ? instruction.substring(schemaIndex + schemaMarker.length).trim() : "";
+          parts.push(`
+GADGET: ${gadgetName}`);
+          parts.push(`
+${description}`);
+          if (schema) {
+            parts.push(`
+
+PARAMETERS (BLOCK):
+${schema}`);
+          }
+          parts.push("\n\n---");
+        }
+        return parts.join("");
+      }
+      buildUsageSection(context) {
+        const parts = [];
+        const formatDescription = resolvePromptTemplate(
+          this.promptConfig.formatDescription,
+          DEFAULT_PROMPTS.formatDescription,
+          context
+        );
+        parts.push("\n\nHOW TO INVOKE GADGETS");
+        parts.push("\n=====================\n");
+        const criticalUsage = resolvePromptTemplate(
+          this.promptConfig.criticalUsage,
+          DEFAULT_PROMPTS.criticalUsage,
+          context
+        );
+        parts.push(`
+CRITICAL: ${criticalUsage}
+`);
+        parts.push("\nFORMAT:");
+        parts.push(`
+  1. Start marker: ${this.startPrefix}gadget_name`);
+        parts.push(`
+     With ID: ${this.startPrefix}gadget_name:my_id`);
+        parts.push(`
+     With dependencies: ${this.startPrefix}gadget_name:my_id:dep1,dep2`);
+        parts.push(`
+  2. ${formatDescription}`);
+        parts.push(`
+  3. End marker: ${this.endPrefix}`);
+        parts.push(this.buildExamplesSection(context));
+        parts.push(this.buildRulesSection(context));
+        parts.push("\n");
+        return parts.join("");
+      }
+      buildExamplesSection(context) {
+        if (this.promptConfig.customExamples) {
+          return this.promptConfig.customExamples(context);
+        }
+        const parts = [];
+        const singleExample = `${this.startPrefix}translate
+${this.argPrefix}from
+English
+${this.argPrefix}to
+Polish
+${this.argPrefix}content
+Paris is the capital of France: a beautiful city.
+${this.endPrefix}`;
+        parts.push(`
+
+EXAMPLE (Single Gadget):
+
+${singleExample}`);
+        const multipleExample = `${this.startPrefix}translate
+${this.argPrefix}from
+English
+${this.argPrefix}to
+Polish
+${this.argPrefix}content
+Paris is the capital of France: a beautiful city.
+${this.endPrefix}
+${this.startPrefix}analyze
+${this.argPrefix}type
+economic_analysis
+${this.argPrefix}matter
+Polish Economy
+${this.argPrefix}question
+Analyze the following:
+- Polish arms exports 2025
+- Economic implications
+${this.endPrefix}`;
+        parts.push(`
+
+EXAMPLE (Multiple Gadgets):
+
+${multipleExample}`);
+        const dependencyExample = `${this.startPrefix}fetch_data:fetch_1
+${this.argPrefix}url
+https://api.example.com/users
+${this.endPrefix}
+${this.startPrefix}fetch_data:fetch_2
+${this.argPrefix}url
+https://api.example.com/orders
+${this.endPrefix}
+${this.startPrefix}merge_data:merge_1:fetch_1,fetch_2
+${this.argPrefix}format
+json
+${this.endPrefix}`;
+        parts.push(`
+
+EXAMPLE (With Dependencies):
+merge_1 waits for fetch_1 AND fetch_2 to complete.
+If either fails, merge_1 is automatically skipped.
+
+${dependencyExample}`);
+        parts.push(`
+
+BLOCK FORMAT SYNTAX:
+Block format uses ${this.argPrefix}name markers. Values are captured verbatim until the next marker.
+
+${this.argPrefix}filename
+calculator.ts
+${this.argPrefix}code
+class Calculator {
+  private history: string[] = [];
+
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(\`\${a} + \${b} = \${result}\`);
+    return result;
+  }
+}
+
+BLOCK FORMAT RULES:
+- Each parameter starts with ${this.argPrefix}parameterName on its own line
+- The value starts on the NEXT line after the marker
+- Value ends when the next ${this.argPrefix} or ${this.endPrefix} appears
+- NO escaping needed - write values exactly as they should appear
+- Perfect for code, JSON, markdown, or any content with special characters
+
+NESTED OBJECTS (use / separator):
+${this.argPrefix}config/timeout
+30
+${this.argPrefix}config/retries
+3
+Produces: { "config": { "timeout": "30", "retries": "3" } }
+
+ARRAYS (use numeric indices):
+${this.argPrefix}items/0
+first
+${this.argPrefix}items/1
+second
+Produces: { "items": ["first", "second"] }`);
+        return parts.join("");
+      }
+      buildRulesSection(context) {
+        const parts = [];
+        parts.push("\n\nRULES:");
+        const rules = resolveRulesTemplate(this.promptConfig.rules, context);
+        for (const rule of rules) {
+          parts.push(`
+  - ${rule}`);
+        }
+        return parts.join("");
+      }
+      /**
+       * Add a user message.
+       * Content can be a string (text only) or an array of content parts (multimodal).
+       *
+       * @param content - Message content
+       * @param metadata - Optional metadata
+       *
+       * @example
+       * ```typescript
+       * // Text only
+       * builder.addUser("Hello!");
+       *
+       * // Multimodal
+       * builder.addUser([
+       *   text("What's in this image?"),
+       *   imageFromBuffer(imageData),
+       * ]);
+       * ```
+       */
+      addUser(content, metadata) {
+        this.messages.push({ role: "user", content, metadata });
+        return this;
+      }
+      addAssistant(content, metadata) {
+        this.messages.push({ role: "assistant", content, metadata });
+        return this;
+      }
+      /**
+       * Add a user message with an image attachment.
+       *
+       * @param textContent - Text prompt
+       * @param imageData - Image data (Buffer, Uint8Array, or base64 string)
+       * @param mimeType - Optional MIME type (auto-detected if not provided)
+       *
+       * @example
+       * ```typescript
+       * builder.addUserWithImage(
+       *   "What's in this image?",
+       *   await fs.readFile("photo.jpg"),
+       *   "image/jpeg"  // Optional - auto-detected
+       * );
+       * ```
+       */
+      addUserWithImage(textContent, imageData, mimeType) {
+        const imageBuffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+        const detectedMime = mimeType ?? detectImageMimeType(imageBuffer);
+        if (!detectedMime) {
+          throw new Error(
+            "Could not detect image MIME type. Please provide the mimeType parameter explicitly."
+          );
+        }
+        const content = [
+          text(textContent),
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              mediaType: detectedMime,
+              data: toBase64(imageBuffer)
+            }
+          }
+        ];
+        this.messages.push({ role: "user", content });
+        return this;
+      }
+      /**
+       * Add a user message with an image URL (OpenAI only).
+       *
+       * @param textContent - Text prompt
+       * @param imageUrl - URL to the image
+       *
+       * @example
+       * ```typescript
+       * builder.addUserWithImageUrl(
+       *   "What's in this image?",
+       *   "https://example.com/image.jpg"
+       * );
+       * ```
+       */
+      addUserWithImageUrl(textContent, imageUrl) {
+        const content = [text(textContent), imageFromUrl(imageUrl)];
+        this.messages.push({ role: "user", content });
+        return this;
+      }
+      /**
+       * Add a user message with an audio attachment (Gemini only).
+       *
+       * @param textContent - Text prompt
+       * @param audioData - Audio data (Buffer, Uint8Array, or base64 string)
+       * @param mimeType - Optional MIME type (auto-detected if not provided)
+       *
+       * @example
+       * ```typescript
+       * builder.addUserWithAudio(
+       *   "Transcribe this audio",
+       *   await fs.readFile("recording.mp3"),
+       *   "audio/mp3"  // Optional - auto-detected
+       * );
+       * ```
+       */
+      addUserWithAudio(textContent, audioData, mimeType) {
+        const audioBuffer = typeof audioData === "string" ? Buffer.from(audioData, "base64") : audioData;
+        const content = [text(textContent), audioFromBuffer(audioBuffer, mimeType)];
+        this.messages.push({ role: "user", content });
+        return this;
+      }
+      /**
+       * Add a user message with multiple content parts.
+       * Provides full flexibility for complex multimodal messages.
+       *
+       * @param parts - Array of content parts
+       *
+       * @example
+       * ```typescript
+       * builder.addUserMultimodal([
+       *   text("Compare these images:"),
+       *   imageFromBuffer(image1),
+       *   imageFromBuffer(image2),
+       * ]);
+       * ```
+       */
+      addUserMultimodal(parts) {
+        this.messages.push({ role: "user", content: parts });
+        return this;
+      }
+      /**
+       * Record a gadget execution result in the message history.
+       * Creates an assistant message with the gadget invocation and a user message with the result.
+       *
+       * The invocationId is shown to the LLM so it can reference previous calls when building dependencies.
+       *
+       * @param gadget - Name of the gadget that was executed
+       * @param parameters - Parameters that were passed to the gadget
+       * @param result - Text result from the gadget execution
+       * @param invocationId - Invocation ID (shown to LLM so it can reference for dependencies)
+       * @param media - Optional media outputs from the gadget
+       * @param mediaIds - Optional IDs for the media outputs
+       * @param storedMedia - Optional stored media info including file paths
+       */
+      addGadgetCallResult(gadget, parameters, result, invocationId, media, mediaIds, storedMedia) {
+        const paramStr = this.formatBlockParameters(parameters, "");
+        this.messages.push({
+          role: "assistant",
+          content: `${this.startPrefix}${gadget}:${invocationId}
+${paramStr}
+${this.endPrefix}`
+        });
+        if (media && media.length > 0 && mediaIds && mediaIds.length > 0) {
+          const idRefs = media.map((m, i) => {
+            const path2 = storedMedia?.[i]?.path;
+            const pathInfo = path2 ? ` \u2192 saved to: ${path2}` : "";
+            return `[Media: ${mediaIds[i]} (${m.kind})${pathInfo}]`;
+          }).join("\n");
+          const textWithIds = `Result (${invocationId}): ${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 (${invocationId}): ${result}`
+          });
+        }
+        return this;
+      }
+      /**
+       * Format parameters as Block format with JSON Pointer paths.
+       * Uses the configured argPrefix for consistency with system prompt.
+       */
+      formatBlockParameters(params, prefix) {
+        const lines = [];
+        for (const [key, value] of Object.entries(params)) {
+          const fullPath = prefix ? `${prefix}/${key}` : key;
+          if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+              const itemPath = `${fullPath}/${index}`;
+              if (typeof item === "object" && item !== null) {
+                lines.push(this.formatBlockParameters(item, itemPath));
+              } else {
+                lines.push(`${this.argPrefix}${itemPath}`);
+                lines.push(String(item));
+              }
+            });
+          } else if (typeof value === "object" && value !== null) {
+            lines.push(this.formatBlockParameters(value, fullPath));
+          } else {
+            lines.push(`${this.argPrefix}${fullPath}`);
+            lines.push(String(value));
+          }
+        }
+        return lines.join("\n");
+      }
+      build() {
+        return [...this.messages];
+      }
+    };
+  }
+});
+
+// src/gadgets/exceptions.ts
+var TaskCompletionSignal, HumanInputRequiredException, TimeoutException, AbortException, BudgetPricingUnavailableError;
+var init_exceptions = __esm({
+  "src/gadgets/exceptions.ts"() {
+    "use strict";
+    TaskCompletionSignal = class extends Error {
+      constructor(message) {
+        super(message ?? "Agent loop terminated by gadget");
+        this.name = "TaskCompletionSignal";
+      }
+    };
+    HumanInputRequiredException = class extends Error {
+      question;
+      constructor(question) {
+        super(`Human input required: ${question}`);
+        this.name = "HumanInputRequiredException";
+        this.question = question;
+      }
+    };
+    TimeoutException = class extends Error {
+      timeoutMs;
+      gadgetName;
+      constructor(gadgetName, timeoutMs) {
+        super(`Gadget '${gadgetName}' execution exceeded timeout of ${timeoutMs}ms`);
+        this.name = "TimeoutException";
+        this.gadgetName = gadgetName;
+        this.timeoutMs = timeoutMs;
+      }
+    };
+    AbortException = class extends Error {
+      constructor(message) {
+        super(message || "Gadget execution was aborted");
+        this.name = "AbortException";
+      }
+    };
+    BudgetPricingUnavailableError = class extends Error {
+      model;
+      budget;
+      constructor(model, budget) {
+        super(
+          `Budget of $${budget.toFixed(2)} was set but model "${model}" has no valid pricing information in the model registry. Either register pricing for this model via client.modelRegistry.registerModel() or remove the budget constraint.`
+        );
+        this.name = "BudgetPricingUnavailableError";
+        this.model = model;
+        this.budget = budget;
+      }
+    };
+  }
+});
+
+// src/logging/logger.ts
+import { createWriteStream, mkdirSync } from "fs";
+import { dirname } from "path";
+import { Logger } from "tslog";
+function parseLogLevel(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "") {
+    return void 0;
+  }
+  const numericLevel = Number(normalized);
+  if (Number.isFinite(numericLevel)) {
+    return Math.max(0, Math.min(6, Math.floor(numericLevel)));
+  }
+  return LEVEL_NAME_TO_ID[normalized];
+}
+function parseEnvBoolean(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") return true;
+  if (normalized === "false" || normalized === "0") return false;
+  return void 0;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function createLogger(options = {}) {
+  const envMinLevel = parseLogLevel(process.env.LLMIST_LOG_LEVEL);
+  const envLogFile = process.env.LLMIST_LOG_FILE?.trim() ?? "";
+  const envLogReset = parseEnvBoolean(process.env.LLMIST_LOG_RESET);
+  const minLevel = options.minLevel ?? envMinLevel ?? 4;
+  const defaultType = options.type ?? "pretty";
+  const name = options.name ?? "llmist";
+  const logReset = options.logReset ?? envLogReset ?? false;
+  const envLogTee = parseEnvBoolean(process.env.LLMIST_LOG_TEE);
+  const teeToConsole = options.teeToConsole ?? envLogTee ?? false;
+  if (envLogFile && (!logFileInitialized || sharedLogFilePath !== envLogFile)) {
+    try {
+      if (sharedLogFileStream) {
+        sharedLogFileStream.end();
+        sharedLogFileStream = void 0;
+      }
+      mkdirSync(dirname(envLogFile), { recursive: true });
+      const flags = logReset ? "w" : "a";
+      sharedLogFileStream = createWriteStream(envLogFile, { flags });
+      sharedLogFilePath = envLogFile;
+      logFileInitialized = true;
+      writeErrorCount = 0;
+      writeErrorReported = false;
+      sharedLogFileStream.on("error", (error) => {
+        writeErrorCount++;
+        if (!writeErrorReported) {
+          console.error(`[llmist] Log file write error: ${error.message}`);
+          writeErrorReported = true;
+        }
+        if (writeErrorCount >= MAX_WRITE_ERRORS_BEFORE_DISABLE) {
+          console.error(
+            `[llmist] Too many log file errors (${writeErrorCount}), disabling file logging`
+          );
+          sharedLogFileStream?.end();
+          sharedLogFileStream = void 0;
+        }
+      });
+    } catch (error) {
+      console.error("Failed to initialize LLMIST_LOG_FILE output:", error);
+    }
+  }
+  const useFileLogging = Boolean(sharedLogFileStream);
+  const logger = new Logger({
+    name,
+    minLevel,
+    type: useFileLogging ? "pretty" : defaultType,
+    // Hide log position for file logging and non-pretty types
+    hideLogPositionForProduction: useFileLogging || defaultType !== "pretty",
+    prettyLogTemplate: LOG_TEMPLATE,
+    // Use overwrite to redirect tslog's formatted output to file instead of console
+    overwrite: useFileLogging ? {
+      transportFormatted: (logMetaMarkup, logArgs, _logErrors) => {
+        const args = logArgs.map(
+          (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+        );
+        if (sharedLogFileStream) {
+          const meta = stripAnsi(logMetaMarkup);
+          const fileArgs = args.map((a) => stripAnsi(a));
+          sharedLogFileStream.write(`${meta}${fileArgs.join(" ")}
+`);
+        }
+        if (teeToConsole) {
+          process.stdout.write(`${logMetaMarkup}${args.join(" ")}
+`);
+        }
+      }
+    } : void 0
+  });
+  return logger;
+}
+var LEVEL_NAME_TO_ID, sharedLogFilePath, sharedLogFileStream, logFileInitialized, writeErrorCount, writeErrorReported, MAX_WRITE_ERRORS_BEFORE_DISABLE, LOG_TEMPLATE, defaultLogger;
+var init_logger = __esm({
+  "src/logging/logger.ts"() {
+    "use strict";
+    LEVEL_NAME_TO_ID = {
+      silly: 0,
+      trace: 1,
+      debug: 2,
+      info: 3,
+      warn: 4,
+      error: 5,
+      fatal: 6
+    };
+    logFileInitialized = false;
+    writeErrorCount = 0;
+    writeErrorReported = false;
+    MAX_WRITE_ERRORS_BEFORE_DISABLE = 5;
+    LOG_TEMPLATE = "{{yyyy}}-{{mm}}-{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}	{{logLevelName}}	[{{name}}]	";
+    defaultLogger = createLogger();
+  }
+});
+
+// src/gadgets/schema-to-json.ts
+import * as z from "zod";
+function schemaToJSONSchema(schema, options) {
+  const jsonSchema = z.toJSONSchema(schema, options ?? { target: "draft-7" });
+  const mismatches = detectDescriptionMismatch(schema, jsonSchema);
+  if (mismatches.length > 0) {
+    defaultLogger.warn(
+      `Zod instance mismatch detected: ${mismatches.length} description(s) lost. For best results, use: import { z } from "llmist"`
+    );
+    return mergeDescriptions(schema, jsonSchema);
+  }
+  return jsonSchema;
+}
+function detectDescriptionMismatch(schema, jsonSchema) {
+  const mismatches = [];
+  function checkSchema(zodSchema, json, path2) {
+    if (!zodSchema || typeof zodSchema !== "object") return;
+    const def = zodSchema._def;
+    const jsonObj = json;
+    if (def?.description && !jsonObj?.description) {
+      mismatches.push(path2 || "root");
+    }
+    if (def?.typeName === "ZodObject" && def?.shape) {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        const properties = jsonObj?.properties;
+        const jsonProp = properties?.[key];
+        checkSchema(fieldSchema, jsonProp, path2 ? `${path2}.${key}` : key);
+      }
+    }
+    if (def?.typeName === "ZodArray" && def?.type) {
+      checkSchema(def.type, jsonObj?.items, path2 ? `${path2}[]` : "[]");
+    }
+    if ((def?.typeName === "ZodOptional" || def?.typeName === "ZodNullable") && def?.innerType) {
+      checkSchema(def.innerType, json, path2);
+    }
+    if (def?.typeName === "ZodDefault" && def?.innerType) {
+      checkSchema(def.innerType, json, path2);
+    }
+  }
+  checkSchema(schema, jsonSchema, "");
+  return mismatches;
+}
+function mergeDescriptions(schema, jsonSchema) {
+  function merge(zodSchema, json) {
+    if (!json || typeof json !== "object") return json;
+    const def = zodSchema._def;
+    const jsonObj = json;
+    const merged = { ...jsonObj };
+    if (def?.description && !jsonObj.description) {
+      merged.description = def.description;
+    }
+    if (def?.typeName === "ZodObject" && def?.shape && jsonObj.properties) {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      const properties = jsonObj.properties;
+      merged.properties = { ...properties };
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        if (properties[key]) {
+          merged.properties[key] = merge(fieldSchema, properties[key]);
+        }
+      }
+    }
+    if (def?.typeName === "ZodArray" && def?.type && jsonObj.items) {
+      merged.items = merge(def.type, jsonObj.items);
+    }
+    if ((def?.typeName === "ZodOptional" || def?.typeName === "ZodNullable") && def?.innerType) {
+      return merge(def.innerType, json);
+    }
+    if (def?.typeName === "ZodDefault" && def?.innerType) {
+      return merge(def.innerType, json);
+    }
+    return merged;
+  }
+  return merge(schema, jsonSchema);
+}
+var init_schema_to_json = __esm({
+  "src/gadgets/schema-to-json.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/gadgets/schema-validator.ts
+import * as z2 from "zod";
+function validateGadgetSchema(schema, gadgetName) {
+  let jsonSchema;
+  try {
+    jsonSchema = z2.toJSONSchema(schema, { target: "draft-7" });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Gadget "${gadgetName}" has a schema that cannot be serialized to JSON Schema.
+This usually happens with unsupported patterns like:
+- z.record() - use z.object({}).passthrough() instead
+- Complex transforms or custom refinements
+- Circular references
+
+Original error: ${errorMessage}
+
+Only use schema patterns that Zod v4's native toJSONSchema() supports.`
+    );
+  }
+  const issues = findUnknownTypes(jsonSchema);
+  if (issues.length > 0) {
+    const fieldList = issues.join(", ");
+    throw new Error(
+      `Gadget "${gadgetName}" uses z.unknown() which produces incomplete schemas.
+Problematic fields: ${fieldList}
+
+z.unknown() doesn't generate type information in JSON Schema, making it unclear
+to the LLM what data structure to provide.
+
+Suggestions:
+- Use z.object({}).passthrough() for flexible objects
+- Use z.record(z.string()) for key-value objects with string values
+- Define specific structure if possible
+
+Example fixes:
+  // \u274C Bad
+  content: z.unknown()
+
+  // \u2705 Good
+  content: z.object({}).passthrough()   // for flexible objects
+  content: z.record(z.string())         // for key-value objects
+  content: z.array(z.string())          // for arrays of strings
+`
+    );
+  }
+}
+function findUnknownTypes(schema, path2 = []) {
+  const issues = [];
+  if (!schema || typeof schema !== "object") {
+    return issues;
+  }
+  if (schema.definitions) {
+    for (const defSchema of Object.values(schema.definitions)) {
+      issues.push(...findUnknownTypes(defSchema, []));
+    }
+  }
+  if (schema.properties) {
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      const propPath = [...path2, propName];
+      if (hasNoType(propSchema)) {
+        issues.push(propPath.join(".") || propName);
+      }
+      issues.push(...findUnknownTypes(propSchema, propPath));
+    }
+  }
+  if (schema.items) {
+    const itemPath = [...path2, "[]"];
+    if (hasNoType(schema.items)) {
+      issues.push(itemPath.join("."));
+    }
+    issues.push(...findUnknownTypes(schema.items, itemPath));
+  }
+  if (schema.anyOf) {
+    schema.anyOf.forEach((subSchema, index) => {
+      issues.push(...findUnknownTypes(subSchema, [...path2, `anyOf[${index}]`]));
+    });
+  }
+  if (schema.oneOf) {
+    schema.oneOf.forEach((subSchema, index) => {
+      issues.push(...findUnknownTypes(subSchema, [...path2, `oneOf[${index}]`]));
+    });
+  }
+  if (schema.allOf) {
+    schema.allOf.forEach((subSchema, index) => {
+      issues.push(...findUnknownTypes(subSchema, [...path2, `allOf[${index}]`]));
+    });
+  }
+  return issues;
+}
+function hasNoType(prop) {
+  if (!prop || typeof prop !== "object") {
+    return false;
+  }
+  const hasType = prop.type !== void 0;
+  const hasRef = prop.$ref !== void 0;
+  const hasUnion = prop.anyOf !== void 0 || prop.oneOf !== void 0 || prop.allOf !== void 0;
+  if (hasType || hasRef || hasUnion) {
+    return false;
+  }
+  const keys = Object.keys(prop);
+  const metadataKeys = ["description", "title", "default", "examples"];
+  const hasOnlyMetadata = keys.every((key) => metadataKeys.includes(key));
+  return hasOnlyMetadata || keys.length === 0;
+}
+var init_schema_validator = __esm({
+  "src/gadgets/schema-validator.ts"() {
+    "use strict";
+  }
+});
+
+// src/gadgets/gadget.ts
+function formatParamsForBlockExample(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
+  const lines = [];
+  for (const [key, value] of Object.entries(params)) {
+    const fullPath = prefix ? `${prefix}/${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const itemPath = `${fullPath}/${index}`;
+        if (typeof item === "object" && item !== null) {
+          lines.push(
+            formatParamsForBlockExample(item, itemPath, argPrefix)
+          );
+        } else {
+          lines.push(`${argPrefix}${itemPath}`);
+          lines.push(String(item));
+        }
+      });
+    } else if (typeof value === "object" && value !== null) {
+      lines.push(
+        formatParamsForBlockExample(value, fullPath, argPrefix)
+      );
+    } else {
+      lines.push(`${argPrefix}${fullPath}`);
+      lines.push(String(value));
+    }
+  }
+  return lines.join("\n");
+}
+function formatParamLine(key, propObj, isRequired, indent = "") {
+  const type = propObj.type;
+  const description = propObj.description;
+  const enumValues = propObj.enum;
+  let line = `${indent}- ${key}`;
+  if (type === "array") {
+    const items = propObj.items;
+    const itemType = items?.type || "any";
+    line += ` (array of ${itemType})`;
+  } else if (type === "object" && propObj.properties) {
+    line += " (object)";
+  } else {
+    line += ` (${type})`;
+  }
+  if (isRequired && indent !== "") {
+    line += " [required]";
+  }
+  if (description) {
+    line += `: ${description}`;
+  }
+  if (enumValues) {
+    line += ` - one of: ${enumValues.map((v) => `"${v}"`).join(", ")}`;
+  }
+  return line;
+}
+function formatSchemaAsPlainText(schema, indent = "", atRoot = true) {
+  const lines = [];
+  const properties = schema.properties || {};
+  const required = schema.required || [];
+  if (atRoot && indent === "") {
+    const requiredProps = [];
+    const optionalProps = [];
+    for (const [key, prop] of Object.entries(properties)) {
+      if (required.includes(key)) {
+        requiredProps.push([key, prop]);
+      } else {
+        optionalProps.push([key, prop]);
+      }
+    }
+    const reqCount = requiredProps.length;
+    const optCount = optionalProps.length;
+    if (reqCount > 0 || optCount > 0) {
+      const parts = [];
+      if (reqCount > 0) parts.push(`${reqCount} required`);
+      if (optCount > 0) parts.push(`${optCount} optional`);
+      lines.push(parts.join(", "));
+      lines.push("");
+    }
+    if (reqCount > 0) {
+      lines.push("REQUIRED Parameters:");
+      for (const [key, prop] of requiredProps) {
+        lines.push(formatParamLine(key, prop, true, ""));
+        const propObj = prop;
+        if (propObj.type === "object" && propObj.properties) {
+          lines.push(formatSchemaAsPlainText(propObj, "  ", false));
+        }
+      }
+    }
+    if (optCount > 0) {
+      if (reqCount > 0) lines.push("");
+      lines.push("OPTIONAL Parameters:");
+      for (const [key, prop] of optionalProps) {
+        lines.push(formatParamLine(key, prop, false, ""));
+        const propObj = prop;
+        if (propObj.type === "object" && propObj.properties) {
+          lines.push(formatSchemaAsPlainText(propObj, "  ", false));
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  for (const [key, prop] of Object.entries(properties)) {
+    const isRequired = required.includes(key);
+    lines.push(formatParamLine(key, prop, isRequired, indent));
+    const propObj = prop;
+    if (propObj.type === "object" && propObj.properties) {
+      lines.push(formatSchemaAsPlainText(propObj, indent + "  ", false));
+    }
+  }
+  return lines.join("\n");
+}
+var AbstractGadget;
+var init_gadget = __esm({
+  "src/gadgets/gadget.ts"() {
+    "use strict";
+    init_constants();
+    init_exceptions();
+    init_schema_to_json();
+    init_schema_validator();
+    AbstractGadget = class {
+      /**
+       * The name of the gadget. Used for identification when LLM calls it.
+       * If not provided, defaults to the class name.
+       */
+      name;
+      /**
+       * Optional Zod schema describing the expected input payload. When provided,
+       * it will be validated before execution and transformed into a JSON Schema
+       * representation that is surfaced to the LLM as part of the instructions.
+       */
+      parameterSchema;
+      /**
+       * Optional timeout in milliseconds for gadget execution.
+       * If execution exceeds this timeout, a TimeoutException will be thrown.
+       * If not set, the global defaultGadgetTimeoutMs from runtime options will be used.
+       * Set to 0 or undefined to disable timeout for this gadget.
+       */
+      timeoutMs;
+      /**
+       * Optional usage examples to help LLMs understand proper invocation.
+       * Examples are rendered in getInstruction() alongside the schema.
+       *
+       * Note: Uses broader `unknown` type to allow typed examples from subclasses
+       * while maintaining runtime compatibility.
+       */
+      examples;
+      /**
+       * Maximum number of concurrent executions allowed for this gadget.
+       * Use this to prevent race conditions in gadgets that modify shared state.
+       *
+       * - `1` = Sequential execution (only one instance runs at a time)
+       * - `0` or `undefined` = Unlimited concurrency (default)
+       * - `N > 1` = At most N concurrent executions
+       *
+       * This property sets a safety floor: external configuration (SubagentConfig)
+       * can only make concurrency MORE restrictive, never less. For example, if
+       * a gadget declares `maxConcurrent: 1`, external config cannot override it
+       * to allow parallel execution.
+       *
+       * @example
+       * ```typescript
+       * // File writer that must run sequentially to avoid race conditions
+       * class WriteFile extends Gadget({
+       *   description: 'Writes content to a file',
+       *   schema: z.object({ path: z.string(), content: z.string() }),
+       *   maxConcurrent: 1, // Sequential - prevents race conditions
+       * }) {
+       *   execute(params: this['params']) { ... }
+       * }
+       * ```
+       */
+      maxConcurrent;
+      /**
+       * If true, this gadget must execute alone — no other gadgets in the same
+       * LLM response can run in parallel. When an exclusive gadget arrives and
+       * other gadgets are already in-flight, it is deferred until they complete.
+       *
+       * Use for gadgets that terminate the agent loop (e.g., Finish), where
+       * sibling tool results must be visible to the LLM before the loop ends.
+       *
+       * This is a safety floor: external config cannot weaken it.
+       */
+      exclusive;
+      /**
+       * 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 AbortException if ctx.signal.aborted is true
+       *
+       * @example
+       * ```typescript
+       * class DataProcessor extends Gadget({
+       *   description: 'Processes data in multiple steps',
+       *   schema: z.object({ items: z.array(z.string()) }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const results: string[] = [];
+       *
+       *     for (const item of params.items) {
+       *       // Check before each expensive operation
+       *       this.throwIfAborted(ctx);
+       *
+       *       results.push(await this.processItem(item));
+       *     }
+       *
+       *     return results.join(', ');
+       *   }
+       * }
+       * ```
+       */
+      throwIfAborted(ctx) {
+        if (ctx?.signal?.aborted) {
+          throw new AbortException();
+        }
+      }
+      /**
+       * Register a cleanup function to run when execution is aborted (timeout or cancellation).
+       * The cleanup function is called immediately if the signal is already aborted.
+       * Errors thrown by the cleanup function are silently ignored.
+       *
+       * Use this to clean up resources like browser instances, database connections,
+       * or child processes when the gadget is cancelled due to timeout.
+       *
+       * @param ctx - The execution context containing the abort signal
+       * @param cleanup - Function to run on abort (can be sync or async)
+       *
+       * @example
+       * ```typescript
+       * class BrowserGadget extends Gadget({
+       *   description: 'Fetches web page content',
+       *   schema: z.object({ url: z.string() }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const browser = await chromium.launch();
+       *     this.onAbort(ctx, () => browser.close());
+       *
+       *     const page = await browser.newPage();
+       *     this.onAbort(ctx, () => page.close());
+       *
+       *     await page.goto(params.url);
+       *     const content = await page.content();
+       *
+       *     await browser.close();
+       *     return content;
+       *   }
+       * }
+       * ```
+       */
+      onAbort(ctx, cleanup) {
+        if (!ctx?.signal) return;
+        const safeCleanup = () => {
+          try {
+            const result = cleanup();
+            if (result && typeof result === "object" && "catch" in result) {
+              result.catch(() => {
+              });
+            }
+          } catch {
+          }
+        };
+        if (ctx.signal.aborted) {
+          safeCleanup();
+          return;
+        }
+        ctx.signal.addEventListener("abort", safeCleanup, { once: true });
+      }
+      /**
+       * Create an AbortController linked to the execution context's signal.
+       * When the parent signal aborts, the returned controller also aborts with the same reason.
+       *
+       * Useful for passing abort signals to child operations like fetch() while still
+       * being able to abort them independently if needed.
+       *
+       * @param ctx - The execution context containing the parent abort signal
+       * @returns A new AbortController linked to the parent signal
+       *
+       * @example
+       * ```typescript
+       * class FetchGadget extends Gadget({
+       *   description: 'Fetches data from URL',
+       *   schema: z.object({ url: z.string() }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const controller = this.createLinkedAbortController(ctx);
+       *
+       *     // fetch() will automatically abort when parent times out
+       *     const response = await fetch(params.url, { signal: controller.signal });
+       *     return response.text();
+       *   }
+       * }
+       * ```
+       */
+      createLinkedAbortController(ctx) {
+        const controller = new AbortController();
+        if (ctx?.signal) {
+          if (ctx.signal.aborted) {
+            controller.abort(ctx.signal.reason);
+          } else {
+            ctx.signal.addEventListener(
+              "abort",
+              () => {
+                controller.abort(ctx.signal.reason);
+              },
+              { once: true }
+            );
+          }
+        }
+        return controller;
+      }
+      /**
+       * Generate instruction text for the LLM.
+       * Combines name, description, and parameter schema into a formatted instruction.
+       *
+       * @param optionsOrArgPrefix - Optional custom prefixes for examples, or just argPrefix string for backwards compatibility
+       * @returns Formatted instruction string
+       */
+      getInstruction(optionsOrArgPrefix) {
+        const options = typeof optionsOrArgPrefix === "string" ? { argPrefix: optionsOrArgPrefix } : optionsOrArgPrefix;
+        const parts = [];
+        parts.push(this.description);
+        if (this.parameterSchema) {
+          const gadgetName = this.name ?? this.constructor.name;
+          validateGadgetSchema(this.parameterSchema, gadgetName);
+          const jsonSchema = schemaToJSONSchema(this.parameterSchema, {
+            target: "draft-7"
+          });
+          parts.push("\n\nParameters:");
+          parts.push(formatSchemaAsPlainText(jsonSchema));
+        }
+        if (this.examples && this.examples.length > 0) {
+          parts.push("\n\nExamples:");
+          const effectiveArgPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
+          const effectiveStartPrefix = options?.startPrefix ?? GADGET_START_PREFIX;
+          const effectiveEndPrefix = options?.endPrefix ?? GADGET_END_PREFIX;
+          const gadgetName = this.name || this.constructor.name;
+          this.examples.forEach((example, index) => {
+            if (index > 0) {
+              parts.push("");
+              parts.push("---");
+              parts.push("");
+            }
+            if (example.comment) {
+              parts.push(`# ${example.comment}`);
+            }
+            parts.push(`${effectiveStartPrefix}${gadgetName}`);
+            parts.push(
+              formatParamsForBlockExample(
+                example.params,
+                "",
+                effectiveArgPrefix
+              )
+            );
+            parts.push(effectiveEndPrefix);
+            if (example.output !== void 0) {
+              parts.push("");
+              parts.push("Expected Output:");
+              parts.push(example.output);
+            }
+          });
+        }
+        return parts.join("\n");
+      }
+    };
+  }
+});
+
+// src/gadgets/create-gadget.ts
+function createGadget(config) {
+  class DynamicGadget extends AbstractGadget {
+    name = config.name;
+    description = config.description;
+    parameterSchema = config.schema;
+    timeoutMs = config.timeoutMs;
+    examples = config.examples;
+    maxConcurrent = config.maxConcurrent;
+    execute(params, ctx) {
+      return config.execute(params, ctx);
+    }
+  }
+  return new DynamicGadget();
+}
+var init_create_gadget = __esm({
+  "src/gadgets/create-gadget.ts"() {
+    "use strict";
+    init_gadget();
+  }
+});
+
+// src/mcp/errors.ts
+var McpError, McpUntrustedCommandError, McpConnectError, McpToolCallError, McpTimeoutError, JsonSchemaConversionError;
+var init_errors = __esm({
+  "src/mcp/errors.ts"() {
+    "use strict";
+    McpError = class extends Error {
+      serverName;
+      constructor(message, serverName) {
+        super(message);
+        this.name = "McpError";
+        this.serverName = serverName;
+      }
+    };
+    McpUntrustedCommandError = class extends McpError {
+      command;
+      constructor(command, serverName) {
+        super(
+          `Refusing to spawn MCP stdio command "${command}" because its basename is not in the default allowlist. To opt in, set { trust: true } on the server spec (library), or trust = true in your TOML mcp.servers block, or pass --mcp-trust ${serverName ?? "<name>"} on the CLI. See https://llmist.dev/library/advanced/mcp-security/ for context (CVE-2026-30623).`,
+          serverName
+        );
+        this.name = "McpUntrustedCommandError";
+        this.command = command;
+      }
+    };
+    McpConnectError = class extends McpError {
+      cause;
+      constructor(message, opts) {
+        super(message, opts?.serverName);
+        this.name = "McpConnectError";
+        this.cause = opts?.cause;
+      }
+    };
+    McpToolCallError = class extends McpError {
+      toolName;
+      cause;
+      constructor(toolName, message, opts) {
+        super(message, opts?.serverName);
+        this.name = "McpToolCallError";
+        this.toolName = toolName;
+        this.cause = opts?.cause;
+      }
+    };
+    McpTimeoutError = class extends McpError {
+      operation;
+      timeoutMs;
+      constructor(operation, timeoutMs, serverName) {
+        super(
+          `MCP operation "${operation}" on server "${serverName ?? "<unknown>"}" timed out after ${timeoutMs}ms`,
+          serverName
+        );
+        this.name = "McpTimeoutError";
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+      }
+    };
+    JsonSchemaConversionError = class extends Error {
+      schemaFragment;
+      reason;
+      constructor(reason, schemaFragment) {
+        super(`JSON Schema \u2192 Zod conversion failed: ${reason}`);
+        this.name = "JsonSchemaConversionError";
+        this.reason = reason;
+        this.schemaFragment = schemaFragment;
+      }
+    };
+  }
+});
+
+// src/mcp/allowlist.ts
+import path from "path";
+function assertCommandAllowed(command, trusted, customAllowlist) {
+  if (!command || typeof command !== "string") {
+    throw new McpUntrustedCommandError(String(command));
+  }
+  if (WHITESPACE_OR_META_RE.test(command)) {
+    throw new McpUntrustedCommandError(command);
+  }
+  if (trusted) return;
+  const allowlist = customAllowlist ?? DEFAULT_MCP_COMMAND_ALLOWLIST;
+  const base = path.basename(command);
+  if (!allowlist.has(base)) {
+    throw new McpUntrustedCommandError(command);
+  }
+}
+var DEFAULT_MCP_COMMAND_ALLOWLIST, WHITESPACE_OR_META_RE;
+var init_allowlist = __esm({
+  "src/mcp/allowlist.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_MCP_COMMAND_ALLOWLIST = /* @__PURE__ */ new Set([
+      "npx",
+      "node",
+      "uvx",
+      "uv",
+      "python",
+      "python3",
+      "deno",
+      "bun"
+    ]);
+    WHITESPACE_OR_META_RE = /[\s;|&`$<>()'"\\]/;
+  }
+});
+
+// src/mcp/client.ts
+async function loadSdk() {
+  if (!cachedSdk) {
+    cachedSdk = (async () => {
+      const [client, stdio, http] = await Promise.all([
+        import("@modelcontextprotocol/sdk/client/index.js"),
+        import("@modelcontextprotocol/sdk/client/stdio.js"),
+        import("@modelcontextprotocol/sdk/client/streamableHttp.js")
+      ]);
+      return {
+        Client: client.Client,
+        StdioClientTransport: stdio.StdioClientTransport,
+        StreamableHTTPClientTransport: http.StreamableHTTPClientTransport
+      };
+    })();
+  }
+  return cachedSdk;
+}
+var cachedSdk, DEFAULT_CLIENT_INFO, McpClient;
+var init_client = __esm({
+  "src/mcp/client.ts"() {
+    "use strict";
+    init_allowlist();
+    init_errors();
+    cachedSdk = null;
+    DEFAULT_CLIENT_INFO = { name: "llmist", version: "0.0.0" };
+    McpClient = class {
+      constructor(spec, opts) {
+        this.spec = spec;
+        this.injectedTransport = opts?.transport;
+        this.clientInfo = opts?.clientInfo ?? DEFAULT_CLIENT_INFO;
+      }
+      sdkClient = null;
+      spawnedPid = null;
+      closed = false;
+      injectedTransport;
+      clientInfo;
+      get serverName() {
+        return this.spec.name;
+      }
+      get pid() {
+        return this.spawnedPid;
+      }
+      get serverCapabilities() {
+        if (!this.sdkClient) return null;
+        return this.sdkClient.getServerCapabilities() ?? null;
+      }
+      async connect() {
+        if (this.sdkClient) return;
+        let transport;
+        if (this.injectedTransport) {
+          transport = this.injectedTransport;
+        } else if (this.spec.transport === "stdio") {
+          assertCommandAllowed(this.spec.command, this.spec.trust === true);
+          const { StdioClientTransport } = await loadSdk();
+          const stdioTransport = new StdioClientTransport({
+            command: this.spec.command,
+            args: this.spec.args,
+            env: this.spec.env
+          });
+          transport = stdioTransport;
+          this.spawnedPid = null;
+        } else {
+          const { StreamableHTTPClientTransport } = await loadSdk();
+          let url;
+          try {
+            url = new URL(this.spec.url);
+          } catch (err) {
+            throw new McpConnectError(
+              `MCP server "${this.spec.name}" has an invalid URL: ${err.message}`,
+              { serverName: this.spec.name, cause: err }
+            );
+          }
+          transport = new StreamableHTTPClientTransport(url, {
+            requestInit: this.spec.headers ? { headers: this.spec.headers } : void 0
+          });
+        }
+        const { Client } = await loadSdk();
+        const client = new Client(this.clientInfo, { capabilities: {} });
+        try {
+          await this.withTimeout(() => client.connect(transport), "connect");
+        } catch (err) {
+          throw new McpConnectError(
+            `Failed to connect to MCP server "${this.spec.name}": ${err.message}`,
+            { serverName: this.spec.name, cause: err }
+          );
+        }
+        this.sdkClient = client;
+        const maybePid = transport.pid;
+        if (typeof maybePid === "number") {
+          this.spawnedPid = maybePid;
+        }
+      }
+      async listTools() {
+        const client = this.requireClient();
+        const res = await this.withTimeout(() => client.listTools(), "tools/list");
+        return res.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }));
+      }
+      async callTool(name, args) {
+        const client = this.requireClient();
+        try {
+          const res = await this.withTimeout(
+            () => client.callTool({
+              name,
+              arguments: args ?? {}
+            }),
+            `tools/call ${name}`
+          );
+          return {
+            content: res.content ?? [],
+            isError: res.isError
+          };
+        } catch (err) {
+          throw new McpToolCallError(
+            name,
+            `MCP tool call "${name}" on server "${this.spec.name}" failed: ${err.message}`,
+            { serverName: this.spec.name, cause: err }
+          );
+        }
+      }
+      async listPrompts() {
+        const client = this.requireClient();
+        if (!client.listPrompts) {
+          return [];
+        }
+        const listPrompts = client.listPrompts.bind(client);
+        const res = await this.withTimeout(() => listPrompts(), "prompts/list");
+        return res.prompts.map((p) => ({
+          name: p.name,
+          description: p.description,
+          arguments: p.arguments
+        }));
+      }
+      async getPrompt(name, args) {
+        const client = this.requireClient();
+        if (!client.getPrompt) {
+          throw new McpToolCallError(name, "Server has no getPrompt method", {
+            serverName: this.spec.name
+          });
+        }
+        const getPrompt = client.getPrompt.bind(client);
+        try {
+          const res = await this.withTimeout(
+            () => getPrompt({ name, arguments: args ?? {} }),
+            `prompts/get ${name}`
+          );
+          return {
+            description: res.description,
+            messages: res.messages.map((m) => ({
+              role: m.role,
+              content: m.content
+            }))
+          };
+        } catch (err) {
+          throw new McpToolCallError(
+            name,
+            `MCP prompts/get "${name}" on server "${this.spec.name}" failed: ${err.message}`,
+            { serverName: this.spec.name, cause: err }
+          );
+        }
+      }
+      async close() {
+        if (this.closed) return;
+        this.closed = true;
+        if (this.sdkClient) {
+          try {
+            await this.sdkClient.close();
+          } catch {
+          }
+          this.sdkClient = null;
+        }
+      }
+      requireClient() {
+        if (!this.sdkClient) {
+          throw new McpConnectError(
+            `MCP client for server "${this.spec.name}" is not connected. Call connect() first.`,
+            { serverName: this.spec.name }
+          );
+        }
+        return this.sdkClient;
+      }
+      async withTimeout(fn, operation) {
+        const timeoutMs = this.spec.timeoutMs;
+        if (timeoutMs === void 0 || timeoutMs <= 0) {
+          return fn();
+        }
+        return new Promise((resolve, reject) => {
+          let settled = false;
+          const timeoutId = setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            reject(new McpTimeoutError(operation, timeoutMs, this.spec.name));
+          }, timeoutMs);
+          fn().then((result) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeoutId);
+            resolve(result);
+          }).catch((err) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeoutId);
+            reject(err);
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/mcp/lifecycle.ts
+var McpLifecycle;
+var init_lifecycle = __esm({
+  "src/mcp/lifecycle.ts"() {
+    "use strict";
+    init_logger();
+    McpLifecycle = class {
+      clients = [];
+      closing = null;
+      signalHandlersInstalled = false;
+      sigtermHandler = null;
+      sigintHandler = null;
+      get size() {
+        return this.clients.length;
+      }
+      register(client) {
+        this.clients.push(client);
+      }
+      /**
+       * Attach SIGTERM/SIGINT handlers that close every registered client when
+       * the parent process is asked to exit. Idempotent (double install is a
+       * no-op) and removable via `removeSignalHandlers()`.
+       */
+      installSignalHandlers() {
+        if (this.signalHandlersInstalled) return;
+        this.signalHandlersInstalled = true;
+        this.sigtermHandler = () => {
+          void this.closeAll();
+        };
+        this.sigintHandler = () => {
+          void this.closeAll();
+        };
+        process.on("SIGTERM", this.sigtermHandler);
+        process.on("SIGINT", this.sigintHandler);
+      }
+      removeSignalHandlers() {
+        if (!this.signalHandlersInstalled) return;
+        if (this.sigtermHandler) process.off("SIGTERM", this.sigtermHandler);
+        if (this.sigintHandler) process.off("SIGINT", this.sigintHandler);
+        this.sigtermHandler = null;
+        this.sigintHandler = null;
+        this.signalHandlersInstalled = false;
+      }
+      /**
+       * Close every registered client in parallel. Errors from individual close()
+       * calls are swallowed (logged via console.warn) — a teardown path must not
+       * throw because that would mask the original reason the agent is shutting
+       * down. Idempotent: concurrent calls all return the same in-flight promise.
+       */
+      async closeAll() {
+        if (this.closing) return this.closing;
+        const toClose = this.clients;
+        this.clients = [];
+        this.closing = (async () => {
+          const results = await Promise.allSettled(toClose.map((c) => c.close()));
+          for (const r of results) {
+            if (r.status === "rejected") {
+              defaultLogger.debug("MCP client close failed during teardown:", r.reason);
+            }
+          }
+        })();
+        try {
+          await this.closing;
+        } finally {
+          this.closing = null;
+          this.removeSignalHandlers();
+        }
+      }
+    };
+  }
+});
+
+// src/gadgets/helpers.ts
+function gadgetSuccess(data = {}) {
+  return JSON.stringify({ success: true, ...data });
+}
+function gadgetError(message, details) {
+  return JSON.stringify({ error: message, ...details });
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function withErrorHandling(execute) {
+  return async (params, ctx) => {
+    try {
+      return await execute(params, ctx);
+    } catch (error) {
+      return gadgetError(getErrorMessage(error));
+    }
+  };
+}
+function createMediaOutput(kind, data, mimeType, options) {
+  const buffer = data instanceof Buffer ? data : Buffer.from(data);
+  return {
+    kind,
+    data: buffer.toString("base64"),
+    mimeType,
+    description: options?.description,
+    metadata: options?.metadata,
+    fileName: options?.fileName
+  };
+}
+function resultWithMedia(result, media, cost) {
+  if (media.length === 0) {
+    throw new Error("resultWithMedia: media array cannot be empty");
+  }
+  return {
+    result,
+    media,
+    cost
+  };
+}
+function resultWithImage(result, imageData, options) {
+  const buffer = imageData instanceof Buffer ? imageData : Buffer.from(imageData);
+  const mimeType = options?.mimeType ?? detectImageMimeType(buffer);
+  if (!mimeType) {
+    throw new Error(
+      "Could not detect image MIME type. Please provide mimeType explicitly in options."
+    );
+  }
+  return {
+    result,
+    media: [
+      {
+        kind: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+        description: options?.description,
+        metadata: options?.metadata,
+        fileName: options?.fileName
+      }
+    ],
+    cost: options?.cost
+  };
+}
+function resultWithImages(result, images, cost) {
+  if (images.length === 0) {
+    throw new Error("resultWithImages: images array cannot be empty");
+  }
+  const media = images.map((img, index) => {
+    const buffer = img.data instanceof Buffer ? img.data : Buffer.from(img.data);
+    const mimeType = img.mimeType ?? detectImageMimeType(buffer);
+    if (!mimeType) {
+      throw new Error(
+        `Could not detect MIME type for image at index ${index}. Please provide mimeType explicitly.`
+      );
+    }
+    return {
+      kind: "image",
+      data: buffer.toString("base64"),
+      mimeType,
+      description: img.description,
+      metadata: img.metadata,
+      fileName: img.fileName
+    };
+  });
+  return { result, media, cost };
+}
+function resultWithAudio(result, audioData, options) {
+  const buffer = audioData instanceof Buffer ? audioData : Buffer.from(audioData);
+  const mimeType = options?.mimeType ?? detectAudioMimeType(buffer);
+  if (!mimeType) {
+    throw new Error(
+      "Could not detect audio MIME type. Please provide mimeType explicitly in options."
+    );
+  }
+  const metadata = options?.durationMs ? { durationMs: options.durationMs } : void 0;
+  return {
+    result,
+    media: [
+      {
+        kind: "audio",
+        data: buffer.toString("base64"),
+        mimeType,
+        description: options?.description,
+        metadata,
+        fileName: options?.fileName
+      }
+    ],
+    cost: options?.cost
+  };
+}
+function resultWithFile(result, fileData, mimeType, options) {
+  const buffer = fileData instanceof Buffer ? fileData : Buffer.from(fileData);
+  return {
+    result,
+    media: [
+      {
+        kind: "file",
+        data: buffer.toString("base64"),
+        mimeType,
+        description: options?.description,
+        fileName: options?.fileName
+      }
+    ],
+    cost: options?.cost
+  };
+}
+var init_helpers = __esm({
+  "src/gadgets/helpers.ts"() {
+    "use strict";
+    init_input_content();
+  }
+});
+
+// src/mcp/json-schema-to-zod.ts
+import { z as z3 } from "zod";
+function jsonSchemaToZod(schema) {
+  if (!schema || typeof schema !== "object") {
+    return z3.unknown();
+  }
+  if (schema.$ref) {
+    throw new JsonSchemaConversionError("$ref is not supported in MCP tool schemas", schema);
+  }
+  if (schema.allOf) {
+    throw new JsonSchemaConversionError(
+      "allOf is not supported (MCP tools should use a single composed schema)",
+      schema
+    );
+  }
+  const union = schema.oneOf ?? schema.anyOf;
+  if (union) {
+    if (!Array.isArray(union) || union.length < 2) {
+      throw new JsonSchemaConversionError("oneOf/anyOf must have at least two members", schema);
+    }
+    const branches = union.map((m) => jsonSchemaToZod(m));
+    return applyDecorators(z3.union(branches), schema);
+  }
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type === void 0 && schema.enum && Array.isArray(schema.enum)) {
+    return applyDecorators(buildEnum(schema.enum), schema);
+  }
+  if (type === void 0) {
+    return applyDecorators(z3.unknown(), schema);
+  }
+  switch (type) {
+    case "string": {
+      let s;
+      if (schema.enum && Array.isArray(schema.enum)) {
+        s = buildEnum(schema.enum);
+      } else {
+        s = z3.string();
+      }
+      return applyDecorators(s, schema);
+    }
+    case "number":
+      return applyDecorators(z3.number(), schema);
+    case "integer":
+      return applyDecorators(z3.number().int(), schema);
+    case "boolean":
+      return applyDecorators(z3.boolean(), schema);
+    case "null":
+      return applyDecorators(z3.null(), schema);
+    case "array": {
+      const items = schema.items;
+      if (Array.isArray(items)) {
+        throw new JsonSchemaConversionError("tuple-style items arrays are not supported", schema);
+      }
+      const inner = items ? jsonSchemaToZod(items) : z3.unknown();
+      return applyDecorators(z3.array(inner), schema);
+    }
+    case "object": {
+      const props = schema.properties ?? {};
+      const required = new Set(schema.required ?? []);
+      const keys = Object.keys(props);
+      if (keys.length === 0) {
+        return applyDecorators(z3.record(z3.string(), z3.unknown()), schema);
+      }
+      const shape = {};
+      for (const key of keys) {
+        const inner = jsonSchemaToZod(props[key]);
+        shape[key] = required.has(key) ? inner : inner.optional();
+      }
+      return applyDecorators(z3.object(shape), schema);
+    }
+    default:
+      throw new JsonSchemaConversionError(`unknown JSON Schema type "${type}"`, schema);
+  }
+}
+function buildEnum(values) {
+  if (values.every((v) => typeof v === "string")) {
+    const literals2 = values;
+    if (literals2.length === 0) {
+      throw new JsonSchemaConversionError("enum cannot be empty", values);
+    }
+    return z3.enum(literals2);
+  }
+  const literals = values.map((v) => z3.literal(v));
+  if (literals.length === 0) {
+    throw new JsonSchemaConversionError("enum cannot be empty", values);
+  }
+  if (literals.length === 1) {
+    return literals[0];
+  }
+  return z3.union(literals);
+}
+function applyDecorators(base, schema) {
+  let s = base;
+  if (schema.nullable === true) {
+    s = s.nullable();
+  }
+  if (schema.description) {
+    s = s.describe(schema.description);
+  }
+  if (schema.default !== void 0) {
+    s = s.default(schema.default);
+  }
+  return s;
+}
+var init_json_schema_to_zod = __esm({
+  "src/mcp/json-schema-to-zod.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/mcp/tool-adapter.ts
+import { z as z4 } from "zod";
+function mcpToolToGadget(tool, client, opts) {
+  const gadgetName = (opts?.prefix ?? "") + tool.name;
+  const schema = buildSchema(tool.inputSchema);
+  const description = tool.description ?? `MCP tool "${tool.name}" from server "${client.serverName}"`;
+  return createGadget({
+    name: gadgetName,
+    description,
+    schema,
+    execute: async (params) => {
+      const result = await client.callTool(tool.name, params);
+      return mcpResultToGadgetReturn(result, tool.name);
+    }
+  });
+}
+function buildSchema(inputSchema) {
+  if (!inputSchema) {
+    return z4.object({});
+  }
+  const converted = jsonSchemaToZod(inputSchema);
+  if (!(converted instanceof z4.ZodObject) && !(converted instanceof z4.ZodRecord)) {
+    return z4.object({}).passthrough();
+  }
+  return converted;
+}
+function mcpResultToGadgetReturn(result, toolName) {
+  const blocks = result.content ?? [];
+  const textParts = [];
+  const media = [];
+  for (const block of blocks) {
+    const kind = block.type;
+    if (kind === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    } else if (kind === "image") {
+      const b = block;
+      media.push({ kind: "image", data: b.data, mimeType: b.mimeType });
+    } else if (kind === "audio") {
+      const b = block;
+      media.push({ kind: "audio", data: b.data, mimeType: b.mimeType });
+    } else {
+      try {
+        textParts.push(JSON.stringify(block));
+      } catch {
+        textParts.push(String(block));
+      }
+    }
+  }
+  const text2 = textParts.join("\n");
+  if (result.isError) {
+    throw new Error(
+      text2 ? text2 : `MCP tool "${toolName}" returned an error result with no text content`
+    );
+  }
+  if (media.length === 0) {
+    return text2;
+  }
+  if (media.length === 1 && media[0].kind === "image") {
+    const img = media[0];
+    return resultWithImage(text2, Buffer.from(img.data, "base64"), {
+      mimeType: img.mimeType
+    });
+  }
+  return {
+    result: text2,
+    media: media.map((m) => ({
+      kind: m.kind,
+      data: m.data,
+      mimeType: m.mimeType
+    }))
+  };
+}
+var init_tool_adapter = __esm({
+  "src/mcp/tool-adapter.ts"() {
+    "use strict";
+    init_create_gadget();
+    init_helpers();
+    init_json_schema_to_zod();
+  }
+});
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS,
+  GADGET_START_PREFIX,
+  GADGET_END_PREFIX,
+  GADGET_ARG_PREFIX,
+  DEFAULT_GADGET_OUTPUT_LIMIT,
+  DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT,
+  CHARS_PER_TOKEN,
+  FALLBACK_CONTEXT_WINDOW,
+  init_constants,
+  isTextPart,
+  isImagePart,
+  isAudioPart,
+  text,
+  imageFromBase64,
+  imageFromUrl,
+  detectImageMimeType,
+  detectAudioMimeType,
+  toBase64,
+  imageFromBuffer,
+  audioFromBase64,
+  audioFromBuffer,
+  isDataUrl,
+  parseDataUrl,
+  init_input_content,
+  DEFAULT_HINTS,
+  DEFAULT_PROMPTS,
+  resolvePromptTemplate,
+  resolveRulesTemplate,
+  resolveHintTemplate,
+  init_prompt_config,
+  normalizeMessageContent,
+  extractMessageText,
+  LLMMessageBuilder,
+  init_messages,
+  TaskCompletionSignal,
+  HumanInputRequiredException,
+  TimeoutException,
+  AbortException,
+  BudgetPricingUnavailableError,
+  init_exceptions,
+  createLogger,
+  defaultLogger,
+  init_logger,
+  schemaToJSONSchema,
+  init_schema_to_json,
+  validateGadgetSchema,
+  init_schema_validator,
+  AbstractGadget,
+  init_gadget,
+  createGadget,
+  init_create_gadget,
+  McpError,
+  McpUntrustedCommandError,
+  McpConnectError,
+  McpToolCallError,
+  JsonSchemaConversionError,
+  init_errors,
+  DEFAULT_MCP_COMMAND_ALLOWLIST,
+  assertCommandAllowed,
+  init_allowlist,
+  McpClient,
+  init_client,
+  McpLifecycle,
+  init_lifecycle,
+  gadgetSuccess,
+  gadgetError,
+  getErrorMessage,
+  withErrorHandling,
+  createMediaOutput,
+  resultWithMedia,
+  resultWithImage,
+  resultWithImages,
+  resultWithAudio,
+  resultWithFile,
+  init_helpers,
+  jsonSchemaToZod,
+  init_json_schema_to_zod,
+  mcpToolToGadget,
+  init_tool_adapter
+};
+//# sourceMappingURL=chunk-HM7PUGPA.js.map