llmist 0.1.1

package/dist/chunk-TP7HE3MN.js

@@ -0,0 +1,4450 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/model-shortcuts.ts
+function isKnownModelPattern(model) {
+  const normalized = model.toLowerCase();
+  if (MODEL_ALIASES[normalized]) {
+    return true;
+  }
+  return KNOWN_MODEL_PATTERNS.some((pattern) => pattern.test(model));
+}
+function resolveModel(model, options = {}) {
+  if (model.includes(":")) {
+    return model;
+  }
+  const normalized = model.toLowerCase();
+  if (MODEL_ALIASES[normalized]) {
+    return MODEL_ALIASES[normalized];
+  }
+  const modelLower = model.toLowerCase();
+  if (modelLower.startsWith("gpt")) {
+    return `openai:${model}`;
+  }
+  if (modelLower.startsWith("claude")) {
+    return `anthropic:${model}`;
+  }
+  if (modelLower.startsWith("gemini")) {
+    return `gemini:${model}`;
+  }
+  if (modelLower.match(/^o\d/)) {
+    return `openai:${model}`;
+  }
+  if (!isKnownModelPattern(model)) {
+    if (options.strict) {
+      throw new Error(
+        `Unknown model '${model}'. Did you mean one of: gpt4, sonnet, haiku, flash? Use explicit provider prefix like 'openai:${model}' to bypass this check.`
+      );
+    }
+    if (!options.silent) {
+      console.warn(
+        `\u26A0\uFE0F  Unknown model '${model}', falling back to 'openai:${model}'. This might be a typo. Did you mean: gpt4, gpt5, gpt5-nano, sonnet, haiku, flash? Use { strict: true } to error on unknown models, or { silent: true } to suppress this warning.`
+      );
+    }
+  }
+  return `openai:${model}`;
+}
+function hasProviderPrefix(model) {
+  return model.includes(":");
+}
+function getProvider(model) {
+  const separatorIndex = model.indexOf(":");
+  if (separatorIndex === -1) {
+    return void 0;
+  }
+  return model.slice(0, separatorIndex);
+}
+function getModelId(model) {
+  const separatorIndex = model.indexOf(":");
+  if (separatorIndex === -1) {
+    return model;
+  }
+  return model.slice(separatorIndex + 1);
+}
+var MODEL_ALIASES, KNOWN_MODEL_PATTERNS;
+var init_model_shortcuts = __esm({
+  "src/core/model-shortcuts.ts"() {
+    "use strict";
+    MODEL_ALIASES = {
+      // OpenAI aliases
+      gpt4: "openai:gpt-4o",
+      gpt4o: "openai:gpt-4o",
+      gpt5: "openai:gpt-5",
+      "gpt5-mini": "openai:gpt-5-mini",
+      "gpt5-nano": "openai:gpt-5-nano",
+      // Anthropic aliases
+      sonnet: "anthropic:claude-3-5-sonnet-latest",
+      "claude-sonnet": "anthropic:claude-3-5-sonnet-latest",
+      haiku: "anthropic:claude-3-5-haiku-latest",
+      "claude-haiku": "anthropic:claude-3-5-haiku-latest",
+      opus: "anthropic:claude-3-opus-latest",
+      "claude-opus": "anthropic:claude-3-opus-latest",
+      // Gemini aliases
+      flash: "gemini:gemini-2.0-flash",
+      "gemini-flash": "gemini:gemini-2.0-flash",
+      "gemini-pro": "gemini:gemini-2.0-pro",
+      pro: "gemini:gemini-2.0-pro"
+    };
+    KNOWN_MODEL_PATTERNS = [
+      /^gpt-?\d/i,
+      // gpt-4, gpt-3.5, gpt4, etc.
+      /^claude-?\d/i,
+      // claude-3, claude-2, etc.
+      /^gemini-?(\d|pro|flash)/i,
+      // gemini-2.0, gemini-pro, gemini-flash, etc.
+      /^o\d/i
+      // OpenAI o1, o3, etc.
+    ];
+  }
+});
+
+// src/gadgets/schema-validator.ts
+import * as z from "zod";
+function validateGadgetSchema(schema, gadgetName) {
+  let jsonSchema;
+  try {
+    jsonSchema = z.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, path = []) {
+  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 = [...path, propName];
+      if (hasNoType(propSchema)) {
+        issues.push(propPath.join(".") || propName);
+      }
+      issues.push(...findUnknownTypes(propSchema, propPath));
+    }
+  }
+  if (schema.items) {
+    const itemPath = [...path, "[]"];
+    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, [...path, `anyOf[${index}]`]));
+    });
+  }
+  if (schema.oneOf) {
+    schema.oneOf.forEach((subSchema, index) => {
+      issues.push(...findUnknownTypes(subSchema, [...path, `oneOf[${index}]`]));
+    });
+  }
+  if (schema.allOf) {
+    schema.allOf.forEach((subSchema, index) => {
+      issues.push(...findUnknownTypes(subSchema, [...path, `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/registry.ts
+var GadgetRegistry;
+var init_registry = __esm({
+  "src/gadgets/registry.ts"() {
+    "use strict";
+    init_schema_validator();
+    GadgetRegistry = class _GadgetRegistry {
+      gadgets = /* @__PURE__ */ new Map();
+      /**
+       * Creates a registry from an array of gadget classes or instances,
+       * or an object mapping names to gadgets.
+       *
+       * @param gadgets - Array of gadgets/classes or object with custom names
+       * @returns New GadgetRegistry with all gadgets registered
+       *
+       * @example
+       * ```typescript
+       * // From array of classes
+       * const registry = GadgetRegistry.from([Calculator, Weather]);
+       *
+       * // From array of instances
+       * const registry = GadgetRegistry.from([new Calculator(), new Weather()]);
+       *
+       * // From object with custom names
+       * const registry = GadgetRegistry.from({
+       *   calc: Calculator,
+       *   weather: new Weather({ apiKey: "..." })
+       * });
+       * ```
+       */
+      static from(gadgets) {
+        const registry = new _GadgetRegistry();
+        if (Array.isArray(gadgets)) {
+          registry.registerMany(gadgets);
+        } else {
+          for (const [name, gadget] of Object.entries(gadgets)) {
+            const instance = typeof gadget === "function" ? new gadget() : gadget;
+            registry.register(name, instance);
+          }
+        }
+        return registry;
+      }
+      /**
+       * Registers multiple gadgets at once from an array.
+       *
+       * @param gadgets - Array of gadget instances or classes
+       * @returns This registry for chaining
+       *
+       * @example
+       * ```typescript
+       * registry.registerMany([Calculator, Weather, Email]);
+       * registry.registerMany([new Calculator(), new Weather()]);
+       * ```
+       */
+      registerMany(gadgets) {
+        for (const gadget of gadgets) {
+          const instance = typeof gadget === "function" ? new gadget() : gadget;
+          this.registerByClass(instance);
+        }
+        return this;
+      }
+      // Register a gadget by name
+      register(name, gadget) {
+        const normalizedName = name.toLowerCase();
+        if (this.gadgets.has(normalizedName)) {
+          throw new Error(`Gadget '${name}' is already registered`);
+        }
+        if (gadget.parameterSchema) {
+          validateGadgetSchema(gadget.parameterSchema, name);
+        }
+        this.gadgets.set(normalizedName, gadget);
+      }
+      // Register a gadget using its name property or class name
+      registerByClass(gadget) {
+        const name = gadget.name ?? gadget.constructor.name;
+        this.register(name, gadget);
+      }
+      // Get gadget by name (case-insensitive)
+      get(name) {
+        return this.gadgets.get(name.toLowerCase());
+      }
+      // Check if gadget exists (case-insensitive)
+      has(name) {
+        return this.gadgets.has(name.toLowerCase());
+      }
+      // Get all registered gadget names
+      getNames() {
+        return Array.from(this.gadgets.keys());
+      }
+      // Get all gadgets for instruction generation
+      getAll() {
+        return Array.from(this.gadgets.values());
+      }
+      // Unregister gadget (useful for testing, case-insensitive)
+      unregister(name) {
+        return this.gadgets.delete(name.toLowerCase());
+      }
+      // Clear all gadgets (useful for testing)
+      clear() {
+        this.gadgets.clear();
+      }
+    };
+  }
+});
+
+// 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];
+}
+var DEFAULT_PROMPTS;
+var init_prompt_config = __esm({
+  "src/core/prompt-config.ts"() {
+    "use strict";
+    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.",
+      formatDescriptionYaml: "Parameters in YAML format (one per line)",
+      formatDescriptionJson: "Parameters in JSON format (valid JSON object)",
+      rules: () => [
+        "Output ONLY plain text with the exact markers - never use function/tool calling",
+        "You can invoke multiple gadgets in a single response",
+        "For dependent gadgets, invoke the first one and wait for the result"
+      ],
+      schemaLabelJson: "\n\nInput Schema (JSON):",
+      schemaLabelYaml: "\n\nInput Schema (YAML):",
+      customExamples: null
+    };
+  }
+});
+
+// src/core/constants.ts
+var GADGET_START_PREFIX, GADGET_END_PREFIX;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    "use strict";
+    GADGET_START_PREFIX = "!!!GADGET_START:";
+    GADGET_END_PREFIX = "!!!GADGET_END";
+  }
+});
+
+// src/core/messages.ts
+var LLMMessageBuilder;
+var init_messages = __esm({
+  "src/core/messages.ts"() {
+    "use strict";
+    init_constants();
+    init_prompt_config();
+    LLMMessageBuilder = class {
+      messages = [];
+      startPrefix = GADGET_START_PREFIX;
+      endPrefix = GADGET_END_PREFIX;
+      promptConfig;
+      constructor(promptConfig) {
+        this.promptConfig = promptConfig ?? {};
+      }
+      addSystem(content, metadata) {
+        this.messages.push({ role: "system", content, metadata });
+        return this;
+      }
+      addGadgets(gadgets, parameterFormat = "json", options) {
+        if (options?.startPrefix) {
+          this.startPrefix = options.startPrefix;
+        }
+        if (options?.endPrefix) {
+          this.endPrefix = options.endPrefix;
+        }
+        const context = {
+          parameterFormat,
+          startPrefix: this.startPrefix,
+          endPrefix: this.endPrefix,
+          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.buildGadgetsXmlSection(gadgets, parameterFormat));
+        parts.push(this.buildUsageSection(parameterFormat, context));
+        this.messages.push({ role: "system", content: parts.join("") });
+        return this;
+      }
+      buildGadgetsXmlSection(gadgets, parameterFormat) {
+        const parts = [];
+        parts.push("<GADGETS>");
+        for (const gadget of gadgets) {
+          const gadgetName = gadget.name ?? gadget.constructor.name;
+          const instruction = gadget.getInstruction(parameterFormat);
+          const schemaMarker = parameterFormat === "yaml" ? "\n\nInput Schema (YAML):" : "\n\nInput Schema (JSON):";
+          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("\n  <gadget>");
+          parts.push(`
+    <name>${gadgetName}</name>`);
+          parts.push(`
+    <description>${description}</description>`);
+          if (schema) {
+            parts.push(`
+    <schema format="${parameterFormat}">
+${schema}
+    </schema>`);
+          }
+          parts.push("\n  </gadget>");
+        }
+        return parts.join("");
+      }
+      buildUsageSection(parameterFormat, context) {
+        const parts = [];
+        const formatDescription = parameterFormat === "yaml" ? resolvePromptTemplate(
+          this.promptConfig.formatDescriptionYaml,
+          DEFAULT_PROMPTS.formatDescriptionYaml,
+          context
+        ) : resolvePromptTemplate(
+          this.promptConfig.formatDescriptionJson,
+          DEFAULT_PROMPTS.formatDescriptionJson,
+          context
+        );
+        parts.push("<usage>");
+        const criticalUsage = resolvePromptTemplate(
+          this.promptConfig.criticalUsage,
+          DEFAULT_PROMPTS.criticalUsage,
+          context
+        );
+        parts.push(`
+  <critical>${criticalUsage}</critical>`);
+        parts.push("\n  <format>");
+        parts.push(`
+    <step>Start marker: ${this.startPrefix}gadget_name</step>`);
+        parts.push(`
+    <step>${formatDescription}</step>`);
+        parts.push(`
+    <step>End marker: ${this.endPrefix}</step>`);
+        parts.push("\n  </format>");
+        parts.push(this.buildExamplesSection(parameterFormat, context));
+        parts.push(this.buildRulesSection(context));
+        parts.push("\n</usage>");
+        parts.push("\n</GADGETS>\n\n");
+        return parts.join("");
+      }
+      buildExamplesSection(parameterFormat, context) {
+        if (this.promptConfig.customExamples) {
+          return this.promptConfig.customExamples(context);
+        }
+        const parts = [];
+        parts.push("\n  <examples>");
+        const singleExample = parameterFormat === "yaml" ? `${this.startPrefix}translate
+from: English
+to: Polish
+content: Paris is the capital of France.
+${this.endPrefix}` : `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France."}
+${this.endPrefix}`;
+        parts.push(`
+    <example title="Single Gadget">
+${singleExample}
+    </example>`);
+        const multipleExample = parameterFormat === "yaml" ? `${this.startPrefix}translate
+from: English
+to: Polish
+content: Paris is the capital of France.
+${this.endPrefix}
+${this.startPrefix}analyze
+type: economic_analysis
+matter: "Polish Economy"
+question: Polish arms exports 2025.
+${this.endPrefix}` : `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France."}
+${this.endPrefix}
+${this.startPrefix}analyze
+{"type": "economic_analysis", "matter": "Polish Economy", "question": "Polish arms exports 2025."}
+${this.endPrefix}`;
+        parts.push(`
+    <example title="Multiple Gadgets">
+${multipleExample}
+    </example>`);
+        parts.push("\n  </examples>");
+        return parts.join("");
+      }
+      buildRulesSection(context) {
+        const parts = [];
+        parts.push("\n  <rules>");
+        const rules = resolveRulesTemplate(this.promptConfig.rules, context);
+        for (const rule of rules) {
+          parts.push(`
+    <rule>${rule}</rule>`);
+        }
+        parts.push("\n  </rules>");
+        return parts.join("");
+      }
+      addUser(content, metadata) {
+        this.messages.push({ role: "user", content, metadata });
+        return this;
+      }
+      addAssistant(content, metadata) {
+        this.messages.push({ role: "assistant", content, metadata });
+        return this;
+      }
+      addGadgetCall(gadget, parameters, result, parameterFormat = "json") {
+        const paramStr = this.formatParameters(parameters, parameterFormat);
+        this.messages.push({
+          role: "assistant",
+          content: `${this.startPrefix}${gadget}
+${paramStr}
+${this.endPrefix}`
+        });
+        this.messages.push({
+          role: "user",
+          content: `Result: ${result}`
+        });
+        return this;
+      }
+      formatParameters(parameters, format) {
+        if (format === "yaml") {
+          return Object.entries(parameters).map(([key, value]) => {
+            if (typeof value === "string") {
+              return `${key}: ${value}`;
+            }
+            return `${key}: ${JSON.stringify(value)}`;
+          }).join("\n");
+        }
+        return JSON.stringify(parameters);
+      }
+      build() {
+        return [...this.messages];
+      }
+    };
+  }
+});
+
+// src/logging/logger.ts
+import { createWriteStream, mkdirSync } from "node:fs";
+import { dirname } from "node: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 createLogger(options = {}) {
+  const envMinLevel = parseLogLevel(process.env.LLMIST_LOG_LEVEL);
+  const envLogFile = process.env.LLMIST_LOG_FILE?.trim() ?? "";
+  const minLevel = options.minLevel ?? envMinLevel ?? 4;
+  const defaultType = options.type ?? "pretty";
+  const name = options.name ?? "llmist";
+  let logFileStream;
+  let finalType = defaultType;
+  if (envLogFile) {
+    try {
+      mkdirSync(dirname(envLogFile), { recursive: true });
+      logFileStream = createWriteStream(envLogFile, { flags: "a" });
+      finalType = "hidden";
+    } catch (error) {
+      console.error("Failed to initialize LLMIST_LOG_FILE output:", error);
+    }
+  }
+  const logger = new Logger({
+    name,
+    minLevel,
+    type: finalType,
+    // Optimize for production
+    hideLogPositionForProduction: finalType !== "pretty",
+    // Pretty output settings
+    prettyLogTemplate: finalType === "pretty" ? "{{yyyy}}-{{mm}}-{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}} {{logLevelName}} [{{name}}] " : void 0
+  });
+  if (logFileStream) {
+    logger.attachTransport((logObj) => {
+      logFileStream?.write(`${JSON.stringify(logObj)}
+`);
+    });
+  }
+  return logger;
+}
+var LEVEL_NAME_TO_ID, 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
+    };
+    defaultLogger = createLogger();
+  }
+});
+
+// src/agent/conversation-manager.ts
+var ConversationManager;
+var init_conversation_manager = __esm({
+  "src/agent/conversation-manager.ts"() {
+    "use strict";
+    init_messages();
+    ConversationManager = class {
+      baseMessages;
+      initialMessages;
+      historyBuilder;
+      parameterFormat;
+      constructor(baseMessages, initialMessages, parameterFormat = "json") {
+        this.baseMessages = baseMessages;
+        this.initialMessages = initialMessages;
+        this.parameterFormat = parameterFormat;
+        this.historyBuilder = new LLMMessageBuilder();
+      }
+      addUserMessage(content) {
+        this.historyBuilder.addUser(content);
+      }
+      addAssistantMessage(content) {
+        this.historyBuilder.addAssistant(content);
+      }
+      addGadgetCall(gadgetName, parameters, result) {
+        this.historyBuilder.addGadgetCall(gadgetName, parameters, result, this.parameterFormat);
+      }
+      getMessages() {
+        return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
+      }
+    };
+  }
+});
+
+// src/agent/event-handlers.ts
+async function runWithHandlers(agentGenerator, handlers) {
+  for await (const event of agentGenerator) {
+    switch (event.type) {
+      case "text":
+        if (handlers.onText) {
+          await handlers.onText(event.content);
+        }
+        break;
+      case "gadget_call":
+        if (handlers.onGadgetCall) {
+          await handlers.onGadgetCall({
+            gadgetName: event.call.gadgetName,
+            parameters: event.call.parameters,
+            parametersYaml: event.call.parametersYaml
+          });
+        }
+        break;
+      case "gadget_result":
+        if (handlers.onGadgetResult) {
+          await handlers.onGadgetResult(event.result);
+        }
+        break;
+      case "human_input_required":
+        if (handlers.onHumanInputRequired) {
+          await handlers.onHumanInputRequired({
+            question: event.question,
+            gadgetName: event.gadgetName
+          });
+        }
+        break;
+      default:
+        if (handlers.onOther) {
+          await handlers.onOther(event);
+        }
+        break;
+    }
+  }
+}
+async function collectEvents(agentGenerator, collect) {
+  const result = {
+    text: [],
+    gadgetCalls: [],
+    gadgetResults: []
+  };
+  for await (const event of agentGenerator) {
+    switch (event.type) {
+      case "text":
+        if (collect.text) {
+          result.text.push(event.content);
+        }
+        break;
+      case "gadget_call":
+        if (collect.gadgetCalls && event.call.parameters) {
+          result.gadgetCalls.push({
+            gadgetName: event.call.gadgetName,
+            parameters: event.call.parameters
+          });
+        }
+        break;
+      case "gadget_result":
+        if (collect.gadgetResults) {
+          result.gadgetResults.push(event.result);
+        }
+        break;
+    }
+  }
+  return result;
+}
+async function collectText(agentGenerator) {
+  const chunks = [];
+  for await (const event of agentGenerator) {
+    if (event.type === "text") {
+      chunks.push(event.content);
+    }
+  }
+  return chunks.join("");
+}
+var init_event_handlers = __esm({
+  "src/agent/event-handlers.ts"() {
+    "use strict";
+  }
+});
+
+// src/gadgets/exceptions.ts
+var BreakLoopException, HumanInputException, TimeoutException;
+var init_exceptions = __esm({
+  "src/gadgets/exceptions.ts"() {
+    "use strict";
+    BreakLoopException = class extends Error {
+      constructor(message) {
+        super(message ?? "Agent loop terminated by gadget");
+        this.name = "BreakLoopException";
+      }
+    };
+    HumanInputException = class extends Error {
+      question;
+      constructor(question) {
+        super(`Human input required: ${question}`);
+        this.name = "HumanInputException";
+        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;
+      }
+    };
+  }
+});
+
+// src/gadgets/executor.ts
+var GadgetExecutor;
+var init_executor = __esm({
+  "src/gadgets/executor.ts"() {
+    "use strict";
+    init_logger();
+    init_exceptions();
+    GadgetExecutor = class {
+      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs) {
+        this.registry = registry;
+        this.onHumanInputRequired = onHumanInputRequired;
+        this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
+        this.logger = logger ?? createLogger({ name: "llmist:executor" });
+      }
+      logger;
+      /**
+       * Creates a promise that rejects with a TimeoutException after the specified timeout.
+       */
+      createTimeoutPromise(gadgetName, timeoutMs) {
+        return new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new TimeoutException(gadgetName, timeoutMs));
+          }, timeoutMs);
+        });
+      }
+      // Execute a gadget call asynchronously
+      async execute(call) {
+        const startTime = Date.now();
+        this.logger.debug("Executing gadget", {
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          parameters: call.parameters
+        });
+        const rawParameters = call.parameters ?? {};
+        let validatedParameters = rawParameters;
+        try {
+          const gadget = this.registry.get(call.gadgetName);
+          if (!gadget) {
+            this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              error: `Gadget '${call.gadgetName}' not found in registry`,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (call.parseError || !call.parameters) {
+            this.logger.error("Gadget parameter parse error", {
+              gadgetName: call.gadgetName,
+              parseError: call.parseError
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: {},
+              error: call.parseError ?? "Failed to parse parameters",
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (gadget.parameterSchema) {
+            const validationResult = gadget.parameterSchema.safeParse(rawParameters);
+            if (!validationResult.success) {
+              const formattedIssues = validationResult.error.issues.map((issue) => {
+                const path = issue.path.join(".") || "root";
+                return `${path}: ${issue.message}`;
+              }).join("; ");
+              const validationError = `Invalid parameters: ${formattedIssues}`;
+              this.logger.error("Gadget parameter validation failed", {
+                gadgetName: call.gadgetName,
+                error: validationError
+              });
+              return {
+                gadgetName: call.gadgetName,
+                invocationId: call.invocationId,
+                parameters: rawParameters,
+                error: validationError,
+                executionTimeMs: Date.now() - startTime
+              };
+            }
+            validatedParameters = validationResult.data;
+          }
+          const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
+          let result;
+          if (timeoutMs && timeoutMs > 0) {
+            this.logger.debug("Executing gadget with timeout", {
+              gadgetName: call.gadgetName,
+              timeoutMs
+            });
+            result = await Promise.race([
+              Promise.resolve(gadget.execute(validatedParameters)),
+              this.createTimeoutPromise(call.gadgetName, timeoutMs)
+            ]);
+          } else {
+            result = await Promise.resolve(gadget.execute(validatedParameters));
+          }
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.info("Gadget executed successfully", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            executionTimeMs
+          });
+          this.logger.debug("Gadget result", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
+          };
+        } catch (error) {
+          if (error instanceof BreakLoopException) {
+            this.logger.info("Gadget requested loop termination", {
+              gadgetName: call.gadgetName,
+              message: error.message
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              result: error.message,
+              breaksLoop: true,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (error instanceof TimeoutException) {
+            this.logger.error("Gadget execution timed out", {
+              gadgetName: call.gadgetName,
+              timeoutMs: error.timeoutMs,
+              executionTimeMs: Date.now() - startTime
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: error.message,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (error instanceof HumanInputException) {
+            this.logger.info("Gadget requested human input", {
+              gadgetName: call.gadgetName,
+              question: error.question
+            });
+            if (this.onHumanInputRequired) {
+              try {
+                const answer = await this.onHumanInputRequired(error.question);
+                this.logger.debug("Human input received", {
+                  gadgetName: call.gadgetName,
+                  answerLength: answer.length
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  result: answer,
+                  executionTimeMs: Date.now() - startTime
+                };
+              } catch (inputError) {
+                this.logger.error("Human input callback error", {
+                  gadgetName: call.gadgetName,
+                  error: inputError instanceof Error ? inputError.message : String(inputError)
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  error: inputError instanceof Error ? inputError.message : String(inputError),
+                  executionTimeMs: Date.now() - startTime
+                };
+              }
+            }
+            this.logger.warn("Human input required but no callback provided", {
+              gadgetName: call.gadgetName
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: "Human input required but not available (stdin is not interactive)",
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.error("Gadget execution failed", {
+            gadgetName: call.gadgetName,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          };
+        }
+      }
+      // Execute multiple gadget calls in parallel
+      async executeAll(calls) {
+        return Promise.all(calls.map((call) => this.execute(call)));
+      }
+    };
+  }
+});
+
+// src/gadgets/parser.ts
+import * as yaml from "js-yaml";
+var StreamParser;
+var init_parser = __esm({
+  "src/gadgets/parser.ts"() {
+    "use strict";
+    init_constants();
+    StreamParser = class {
+      buffer = "";
+      lastReportedTextLength = 0;
+      startPrefix;
+      endPrefix;
+      parameterFormat;
+      invocationCounter = 0;
+      constructor(options = {}) {
+        this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
+        this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
+        this.parameterFormat = options.parameterFormat ?? "json";
+      }
+      takeTextUntil(index) {
+        if (index <= this.lastReportedTextLength) {
+          return void 0;
+        }
+        const segment = this.buffer.slice(this.lastReportedTextLength, index);
+        this.lastReportedTextLength = index;
+        return segment.trim().length > 0 ? segment : void 0;
+      }
+      /**
+       * Parse parameter string according to configured format
+       */
+      parseParameters(raw) {
+        if (this.parameterFormat === "json") {
+          try {
+            return { parameters: JSON.parse(raw) };
+          } catch (error) {
+            return { parseError: error instanceof Error ? error.message : "Failed to parse JSON" };
+          }
+        }
+        if (this.parameterFormat === "yaml") {
+          try {
+            return { parameters: yaml.load(raw) };
+          } catch (error) {
+            return { parseError: error instanceof Error ? error.message : "Failed to parse YAML" };
+          }
+        }
+        try {
+          return { parameters: JSON.parse(raw) };
+        } catch {
+          try {
+            return { parameters: yaml.load(raw) };
+          } catch (error) {
+            return {
+              parseError: error instanceof Error ? error.message : "Failed to parse as JSON or YAML"
+            };
+          }
+        }
+      }
+      // Feed a chunk of text and get parsed events
+      *feed(chunk) {
+        this.buffer += chunk;
+        let startIndex = 0;
+        while (true) {
+          const partStartIndex = this.buffer.indexOf(this.startPrefix, startIndex);
+          if (partStartIndex === -1) break;
+          const textBefore = this.takeTextUntil(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();
+          let invocationId;
+          let actualGadgetName;
+          if (gadgetName.includes(":")) {
+            const parts = gadgetName.split(":");
+            actualGadgetName = parts[0];
+            invocationId = parts[1];
+          } else {
+            actualGadgetName = gadgetName;
+            invocationId = `auto_${++this.invocationCounter}`;
+          }
+          const contentStartIndex = metadataEndIndex + 1;
+          let partEndIndex;
+          let endMarkerLength = 0;
+          if (gadgetName.includes(":")) {
+            const oldEndMarker = `${this.endPrefix + actualGadgetName}:${invocationId}`;
+            partEndIndex = this.buffer.indexOf(oldEndMarker, contentStartIndex);
+            if (partEndIndex === -1) break;
+            endMarkerLength = oldEndMarker.length;
+          } else {
+            partEndIndex = contentStartIndex;
+            while (true) {
+              const endPos = this.buffer.indexOf(this.endPrefix, partEndIndex);
+              if (endPos === -1) {
+                partEndIndex = -1;
+                break;
+              }
+              const afterEnd = this.buffer.substring(endPos + this.endPrefix.length);
+              if (afterEnd.startsWith("\n") || afterEnd.startsWith("\r") || afterEnd.startsWith(this.startPrefix) || afterEnd.length === 0) {
+                partEndIndex = endPos;
+                endMarkerLength = this.endPrefix.length;
+                break;
+              } else {
+                partEndIndex = endPos + this.endPrefix.length;
+              }
+            }
+            if (partEndIndex === -1) break;
+          }
+          const parametersRaw = this.buffer.substring(contentStartIndex, partEndIndex).trim();
+          const { parameters, parseError } = this.parseParameters(parametersRaw);
+          yield {
+            type: "gadget_call",
+            call: {
+              gadgetName: actualGadgetName,
+              invocationId,
+              parametersYaml: parametersRaw,
+              // Keep property name for backward compatibility
+              parameters,
+              parseError
+            }
+          };
+          startIndex = partEndIndex + endMarkerLength;
+          this.lastReportedTextLength = startIndex;
+        }
+        if (startIndex > 0) {
+          this.buffer = this.buffer.substring(startIndex);
+          this.lastReportedTextLength = 0;
+        }
+      }
+      // Finalize parsing and return remaining text
+      *finalize() {
+        const remainingText = this.takeTextUntil(this.buffer.length);
+        if (remainingText !== void 0) {
+          yield { type: "text", content: remainingText };
+        }
+      }
+      // Reset parser state
+      reset() {
+        this.buffer = "";
+        this.lastReportedTextLength = 0;
+        this.invocationCounter = 0;
+      }
+    };
+  }
+});
+
+// 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) {
+        throw new HookValidationError(
+          "afterLLMCall",
+          `Message at index ${i} must have 'role' and 'content' fields`
+        );
+      }
+      if (!["system", "user", "assistant"].includes(msg.role)) {
+        throw new HookValidationError(
+          "afterLLMCall",
+          `Message at index ${i} has invalid role: ${msg.role}`
+        );
+      }
+    }
+  }
+  if (actionType === "modify_and_continue" || actionType === "append_and_modify") {
+    if (!("modifiedMessage" in action) || !action.modifiedMessage) {
+      throw new HookValidationError(
+        "afterLLMCall",
+        `When action is '${actionType}', modifiedMessage is required`
+      );
+    }
+  }
+}
+function validateAfterLLMErrorAction(action) {
+  if (!action || typeof action !== "object" || !("action" in action)) {
+    throw new HookValidationError(
+      "afterLLMError",
+      "Must return an action object with an 'action' field"
+    );
+  }
+  const actionType = action.action;
+  if (actionType !== "rethrow" && actionType !== "recover") {
+    throw new HookValidationError(
+      "afterLLMError",
+      `Invalid action type: ${actionType}. Must be 'rethrow' or 'recover'`
+    );
+  }
+  if (actionType === "recover" && !action.fallbackResponse) {
+    throw new HookValidationError(
+      "afterLLMError",
+      "When action is 'recover', fallbackResponse is required"
+    );
+  }
+}
+function validateBeforeGadgetExecutionAction(action) {
+  if (!action || typeof action !== "object" || !("action" in action)) {
+    throw new HookValidationError(
+      "beforeGadgetExecution",
+      "Must return an action object with an 'action' field"
+    );
+  }
+  const actionType = action.action;
+  if (actionType !== "proceed" && actionType !== "skip") {
+    throw new HookValidationError(
+      "beforeGadgetExecution",
+      `Invalid action type: ${actionType}. Must be 'proceed' or 'skip'`
+    );
+  }
+  if (actionType === "skip" && !action.syntheticResult) {
+    throw new HookValidationError(
+      "beforeGadgetExecution",
+      "When action is 'skip', syntheticResult is required"
+    );
+  }
+}
+function validateAfterGadgetExecutionAction(action) {
+  if (!action || typeof action !== "object" || !("action" in action)) {
+    throw new HookValidationError(
+      "afterGadgetExecution",
+      "Must return an action object with an 'action' field"
+    );
+  }
+  const actionType = action.action;
+  if (actionType !== "continue" && actionType !== "recover") {
+    throw new HookValidationError(
+      "afterGadgetExecution",
+      `Invalid action type: ${actionType}. Must be 'continue' or 'recover'`
+    );
+  }
+  if (actionType === "recover" && !action.fallbackResult) {
+    throw new HookValidationError(
+      "afterGadgetExecution",
+      "When action is 'recover', fallbackResult is required"
+    );
+  }
+}
+var HookValidationError;
+var init_hook_validators = __esm({
+  "src/agent/hook-validators.ts"() {
+    "use strict";
+    HookValidationError = class extends Error {
+      constructor(hookName, message) {
+        super(`Invalid action from ${hookName}: ${message}`);
+        this.name = "HookValidationError";
+      }
+    };
+  }
+});
+
+// src/agent/stream-processor.ts
+var StreamProcessor;
+var init_stream_processor = __esm({
+  "src/agent/stream-processor.ts"() {
+    "use strict";
+    init_executor();
+    init_parser();
+    init_logger();
+    init_hook_validators();
+    StreamProcessor = class {
+      iteration;
+      registry;
+      hooks;
+      logger;
+      parser;
+      executor;
+      stopOnGadgetError;
+      shouldContinueAfterError;
+      accumulatedText = "";
+      shouldStopExecution = false;
+      observerFailureCount = 0;
+      constructor(options) {
+        this.iteration = options.iteration;
+        this.registry = options.registry;
+        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({
+          parameterFormat: options.parameterFormat,
+          startPrefix: options.gadgetStartPrefix,
+          endPrefix: options.gadgetEndPrefix
+        });
+        this.executor = new GadgetExecutor(
+          options.registry,
+          options.onHumanInputRequired,
+          this.logger.getSubLogger({ name: "executor" }),
+          options.defaultGadgetTimeoutMs
+        );
+      }
+      /**
+       * Process an LLM stream and return structured results.
+       */
+      async process(stream2) {
+        const outputs = [];
+        let finishReason = null;
+        let usage;
+        let didExecuteGadgets = false;
+        let shouldBreakLoop = false;
+        for await (const chunk of stream2) {
+          if (chunk.finishReason) finishReason = chunk.finishReason;
+          if (chunk.usage) usage = chunk.usage;
+          let processedChunk = "";
+          if (chunk.text) {
+            processedChunk = chunk.text;
+            if (this.hooks.interceptors?.interceptRawChunk) {
+              const context = {
+                iteration: this.iteration,
+                accumulatedText: this.accumulatedText,
+                logger: this.logger
+              };
+              const intercepted = this.hooks.interceptors.interceptRawChunk(processedChunk, context);
+              if (intercepted === null) {
+                processedChunk = "";
+              } else {
+                processedChunk = intercepted;
+              }
+            }
+            if (processedChunk) {
+              this.accumulatedText += processedChunk;
+            }
+          }
+          if (this.hooks.observers?.onStreamChunk && (processedChunk || chunk.usage)) {
+            const chunkObservers = [];
+            chunkObservers.push(async () => {
+              const context = {
+                iteration: this.iteration,
+                rawChunk: processedChunk,
+                accumulatedText: this.accumulatedText,
+                usage,
+                logger: this.logger
+              };
+              await this.hooks.observers.onStreamChunk(context);
+            });
+            await this.runObserversInParallel(chunkObservers);
+          }
+          if (!processedChunk) {
+            continue;
+          }
+          for (const event of this.parser.feed(processedChunk)) {
+            const processedEvents = await this.processEvent(event);
+            outputs.push(...processedEvents);
+            if (processedEvents.some((e) => e.type === "gadget_result")) {
+              didExecuteGadgets = true;
+            }
+            for (const evt of processedEvents) {
+              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
+                shouldBreakLoop = true;
+              }
+            }
+          }
+          if (this.shouldStopExecution) {
+            this.logger.info("Breaking from LLM stream due to gadget error");
+            break;
+          }
+        }
+        if (!this.shouldStopExecution) {
+          for (const event of this.parser.finalize()) {
+            const processedEvents = await this.processEvent(event);
+            outputs.push(...processedEvents);
+            if (processedEvents.some((e) => e.type === "gadget_result")) {
+              didExecuteGadgets = true;
+            }
+            for (const evt of processedEvents) {
+              if (evt.type === "gadget_result" && evt.result.breaksLoop) {
+                shouldBreakLoop = true;
+              }
+            }
+          }
+        }
+        let finalMessage = this.accumulatedText;
+        if (this.hooks.interceptors?.interceptAssistantMessage) {
+          const context = {
+            iteration: this.iteration,
+            rawResponse: this.accumulatedText,
+            logger: this.logger
+          };
+          finalMessage = this.hooks.interceptors.interceptAssistantMessage(finalMessage, context);
+        }
+        return {
+          outputs,
+          shouldBreakLoop,
+          didExecuteGadgets,
+          finishReason,
+          usage,
+          rawResponse: this.accumulatedText,
+          finalMessage
+        };
+      }
+      /**
+       * Process a single parsed event (text or gadget call).
+       */
+      async processEvent(event) {
+        if (event.type === "text") {
+          return this.processTextEvent(event);
+        } else if (event.type === "gadget_call") {
+          return this.processGadgetCall(event.call);
+        }
+        return [event];
+      }
+      /**
+       * Process a text event through interceptors.
+       */
+      async processTextEvent(event) {
+        let content = event.content;
+        if (this.hooks.interceptors?.interceptTextChunk) {
+          const context = {
+            iteration: this.iteration,
+            accumulatedText: this.accumulatedText,
+            logger: this.logger
+          };
+          const intercepted = this.hooks.interceptors.interceptTextChunk(content, context);
+          if (intercepted === null) {
+            return [];
+          }
+          content = intercepted;
+        }
+        return [{ type: "text", content }];
+      }
+      /**
+       * Process a gadget call through the full lifecycle.
+       */
+      async processGadgetCall(call) {
+        if (this.shouldStopExecution) {
+          this.logger.debug("Skipping gadget execution due to previous error", {
+            gadgetName: call.gadgetName
+          });
+          return [];
+        }
+        const events = [];
+        events.push({ type: "gadget_call", call });
+        if (call.parseError) {
+          this.logger.warn("Gadget has parse error", {
+            gadgetName: call.gadgetName,
+            error: call.parseError
+          });
+          const shouldContinue = await this.checkContinueAfterError(
+            call.parseError,
+            call.gadgetName,
+            "parse",
+            call.parameters
+          );
+          if (!shouldContinue) {
+            this.shouldStopExecution = true;
+          }
+        }
+        let parameters = call.parameters ?? {};
+        if (this.hooks.interceptors?.interceptGadgetParameters) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            logger: this.logger
+          };
+          parameters = this.hooks.interceptors.interceptGadgetParameters(parameters, context);
+        }
+        call.parameters = parameters;
+        let shouldSkip = false;
+        let syntheticResult;
+        if (this.hooks.controllers?.beforeGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.beforeGadgetExecution(context);
+          validateBeforeGadgetExecutionAction(action);
+          if (action.action === "skip") {
+            shouldSkip = true;
+            syntheticResult = action.syntheticResult;
+            this.logger.info("Controller skipped gadget execution", {
+              gadgetName: call.gadgetName
+            });
+          }
+        }
+        const startObservers = [];
+        if (this.hooks.observers?.onGadgetExecutionStart) {
+          startObservers.push(async () => {
+            const context = {
+              iteration: this.iteration,
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters,
+              logger: this.logger
+            };
+            await this.hooks.observers.onGadgetExecutionStart(context);
+          });
+        }
+        await this.runObserversInParallel(startObservers);
+        let result;
+        if (shouldSkip) {
+          result = {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters,
+            result: syntheticResult ?? "Execution skipped",
+            executionTimeMs: 0
+          };
+        } else {
+          result = await this.executor.execute(call);
+        }
+        const originalResult = result.result;
+        if (result.result && this.hooks.interceptors?.interceptGadgetResult) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          result.result = this.hooks.interceptors.interceptGadgetResult(result.result, context);
+        }
+        if (this.hooks.controllers?.afterGadgetExecution) {
+          const context = {
+            iteration: this.iteration,
+            gadgetName: result.gadgetName,
+            invocationId: result.invocationId,
+            parameters,
+            result: result.result,
+            error: result.error,
+            executionTimeMs: result.executionTimeMs,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.afterGadgetExecution(context);
+          validateAfterGadgetExecutionAction(action);
+          if (action.action === "recover" && result.error) {
+            this.logger.info("Controller recovered from gadget error", {
+              gadgetName: result.gadgetName,
+              originalError: result.error
+            });
+            result = {
+              ...result,
+              error: void 0,
+              result: action.fallbackResult
+            };
+          }
+        }
+        const completeObservers = [];
+        if (this.hooks.observers?.onGadgetExecutionComplete) {
+          completeObservers.push(async () => {
+            const context = {
+              iteration: this.iteration,
+              gadgetName: result.gadgetName,
+              invocationId: result.invocationId,
+              parameters,
+              originalResult,
+              finalResult: result.result,
+              error: result.error,
+              executionTimeMs: result.executionTimeMs,
+              breaksLoop: result.breaksLoop,
+              logger: this.logger
+            };
+            await this.hooks.observers.onGadgetExecutionComplete(context);
+          });
+        }
+        await this.runObserversInParallel(completeObservers);
+        events.push({ type: "gadget_result", result });
+        if (result.error) {
+          const errorType = this.determineErrorType(call, result);
+          const shouldContinue = await this.checkContinueAfterError(
+            result.error,
+            result.gadgetName,
+            errorType,
+            result.parameters
+          );
+          if (!shouldContinue) {
+            this.shouldStopExecution = true;
+          }
+        }
+        return events;
+      }
+      /**
+       * Safely execute an observer, catching and logging any errors.
+       * Observers are non-critical, so errors are logged but don't crash the system.
+       */
+      async safeObserve(fn) {
+        try {
+          await fn();
+        } catch (error) {
+          this.observerFailureCount++;
+          this.logger.error("Observer threw error (ignoring)", {
+            error: error instanceof Error ? error.message : String(error),
+            failureCount: this.observerFailureCount
+          });
+        }
+      }
+      /**
+       * Execute multiple observers in parallel.
+       * All observers run concurrently and failures are tracked but don't crash.
+       */
+      async runObserversInParallel(observers) {
+        if (observers.length === 0) return;
+        const results = await Promise.allSettled(
+          observers.map((observer) => this.safeObserve(observer))
+        );
+      }
+      /**
+       * Check if execution should continue after an error.
+       *
+       * Returns true if we should continue processing subsequent gadgets, false if we should stop.
+       *
+       * Logic:
+       * - If custom shouldContinueAfterError 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({
+            error,
+            gadgetName,
+            errorType,
+            parameters
+          });
+        }
+        const shouldContinue = !this.stopOnGadgetError;
+        this.logger.debug("Checking if should continue after error", {
+          error,
+          gadgetName,
+          errorType,
+          stopOnGadgetError: this.stopOnGadgetError,
+          shouldContinue
+        });
+        return shouldContinue;
+      }
+      /**
+       * Determine the type of error from a gadget execution.
+       */
+      determineErrorType(call, result) {
+        if (call.parseError) {
+          return "parse";
+        }
+        if (result.error?.includes("Invalid parameters:")) {
+          return "validation";
+        }
+        return "execution";
+      }
+    };
+  }
+});
+
+// src/providers/anthropic-models.ts
+var ANTHROPIC_MODELS;
+var init_anthropic_models = __esm({
+  "src/providers/anthropic-models.ts"() {
+    "use strict";
+    ANTHROPIC_MODELS = [
+      {
+        provider: "anthropic",
+        modelId: "claude-opus-4-5-20251124",
+        displayName: "Claude Opus 4.5",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 5,
+          output: 25,
+          cachedInput: 0.5
+        },
+        knowledgeCutoff: "2025-03",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-11-24",
+          notes: "Most powerful model. 80.9% SWE-bench Verified, 66.3% OSWorld. Best for coding and computer use."
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-sonnet-4-5-20250929",
+        displayName: "Claude Sonnet 4.5",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 3,
+          output: 15,
+          cachedInput: 0.3
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-09-29",
+          notes: "Smartest model for complex agents and coding. Extended thinking. 1M context in beta."
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-haiku-4-5-20251001",
+        displayName: "Claude Haiku 4.5",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 1,
+          output: 5,
+          cachedInput: 0.1
+        },
+        knowledgeCutoff: "2025-02",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-10-01",
+          notes: "Fastest model with near-frontier intelligence. Excellent for coding (73.3% SWE-bench)."
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-sonnet-4-20250514",
+        displayName: "Claude Sonnet 4",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 3,
+          output: 15,
+          cachedInput: 0.3
+        },
+        knowledgeCutoff: "2025-03",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-05-14",
+          notes: "High performance with vision and extended thinking"
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-3-7-sonnet-20250219",
+        displayName: "Claude Sonnet 3.7",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 3,
+          output: 15,
+          cachedInput: 0.3
+        },
+        knowledgeCutoff: "2024-11",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 3",
+          releaseDate: "2025-02-19",
+          notes: "Legacy model - consider upgrading to Claude 4 family"
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-opus-4-1-20250805",
+        displayName: "Claude Opus 4.1",
+        contextWindow: 2e5,
+        maxOutputTokens: 32e3,
+        pricing: {
+          input: 15,
+          output: 75,
+          cachedInput: 1.5
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-08-05",
+          notes: "Exceptional for specialized reasoning tasks. Extended thinking support."
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-opus-4-20250514",
+        displayName: "Claude Opus 4",
+        contextWindow: 2e5,
+        maxOutputTokens: 32e3,
+        pricing: {
+          input: 15,
+          output: 75,
+          cachedInput: 1.5
+        },
+        knowledgeCutoff: "2025-03",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "Claude 4",
+          releaseDate: "2025-05-14",
+          notes: "Legacy Opus model - consider Opus 4.1 for improved reasoning"
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-3-5-haiku-20241022",
+        displayName: "Claude Haiku 3.5",
+        contextWindow: 2e5,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.8,
+          output: 4,
+          cachedInput: 0.08
+        },
+        knowledgeCutoff: "2024-07",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "Claude 3",
+          releaseDate: "2024-10-22",
+          notes: "Legacy model - upgrade to Haiku 4.5 for better performance"
+        }
+      },
+      {
+        provider: "anthropic",
+        modelId: "claude-3-haiku-20240307",
+        displayName: "Claude Haiku 3",
+        contextWindow: 2e5,
+        maxOutputTokens: 4096,
+        pricing: {
+          input: 0.25,
+          output: 1.25,
+          cachedInput: 0.025
+        },
+        knowledgeCutoff: "2023-08",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "Claude 3",
+          releaseDate: "2024-03-07",
+          notes: "Legacy model - upgrade to Haiku 4.5 for better performance"
+        }
+      }
+    ];
+  }
+});
+
+// src/providers/base-provider.ts
+var BaseProviderAdapter;
+var init_base_provider = __esm({
+  "src/providers/base-provider.ts"() {
+    "use strict";
+    BaseProviderAdapter = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Template method that defines the skeleton of the streaming algorithm.
+       * This orchestrates the four-step process without dictating provider-specific details.
+       */
+      async *stream(options, descriptor, spec) {
+        const preparedMessages = this.prepareMessages(options.messages);
+        const payload = this.buildRequestPayload(options, descriptor, spec, preparedMessages);
+        const rawStream = await this.executeStreamRequest(payload);
+        yield* this.wrapStream(rawStream);
+      }
+      /**
+       * Prepare messages for the request.
+       * Default implementation returns messages unchanged.
+       * Override this to implement provider-specific message transformations
+       * (e.g., Gemini's consecutive message merging, Anthropic's system message extraction).
+       *
+       * @param messages - The input messages
+       * @returns Prepared messages
+       */
+      prepareMessages(messages) {
+        return messages;
+      }
+    };
+  }
+});
+
+// src/providers/constants.ts
+var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS, FALLBACK_CHARS_PER_TOKEN, OPENAI_MESSAGE_OVERHEAD_TOKENS, OPENAI_REPLY_PRIMING_TOKENS, OPENAI_NAME_FIELD_OVERHEAD_TOKENS;
+var init_constants2 = __esm({
+  "src/providers/constants.ts"() {
+    "use strict";
+    ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+    FALLBACK_CHARS_PER_TOKEN = 4;
+    OPENAI_MESSAGE_OVERHEAD_TOKENS = 4;
+    OPENAI_REPLY_PRIMING_TOKENS = 2;
+    OPENAI_NAME_FIELD_OVERHEAD_TOKENS = 1;
+  }
+});
+
+// src/providers/utils.ts
+function readEnvVar(key) {
+  if (typeof process === "undefined" || typeof process.env === "undefined") {
+    return void 0;
+  }
+  const value = process.env[key];
+  return typeof value === "string" ? value : void 0;
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function createProviderFromEnv(envVarName, ClientClass, ProviderClass, clientOptions) {
+  const apiKey = readEnvVar(envVarName);
+  if (!isNonEmpty(apiKey)) {
+    return null;
+  }
+  const client = new ClientClass({ apiKey: apiKey.trim(), ...clientOptions });
+  return new ProviderClass(client);
+}
+var init_utils = __esm({
+  "src/providers/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+function createAnthropicProviderFromEnv() {
+  return createProviderFromEnv("ANTHROPIC_API_KEY", Anthropic, AnthropicMessagesProvider);
+}
+var AnthropicMessagesProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    init_anthropic_models();
+    init_base_provider();
+    init_constants2();
+    init_utils();
+    AnthropicMessagesProvider = class extends BaseProviderAdapter {
+      providerId = "anthropic";
+      supports(descriptor) {
+        return descriptor.provider === this.providerId;
+      }
+      getModelSpecs() {
+        return ANTHROPIC_MODELS;
+      }
+      buildRequestPayload(options, descriptor, spec, messages) {
+        const systemMessages = messages.filter((message) => message.role === "system");
+        const system = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n\n") : void 0;
+        const conversation = messages.filter(
+          (message) => message.role !== "system"
+        ).map((message) => ({
+          role: message.role,
+          content: [
+            {
+              type: "text",
+              text: message.content
+            }
+          ]
+        }));
+        const defaultMaxTokens = spec?.maxOutputTokens ?? ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS;
+        const payload = {
+          model: descriptor.name,
+          system,
+          messages: conversation,
+          max_tokens: options.maxTokens ?? defaultMaxTokens,
+          temperature: options.temperature,
+          top_p: options.topP,
+          stop_sequences: options.stopSequences,
+          stream: true,
+          ...options.extra
+        };
+        return payload;
+      }
+      async executeStreamRequest(payload) {
+        const client = this.client;
+        const stream2 = await client.messages.create(payload);
+        return stream2;
+      }
+      async *wrapStream(iterable) {
+        const stream2 = iterable;
+        let inputTokens = 0;
+        for await (const event of stream2) {
+          if (event.type === "message_start") {
+            inputTokens = event.message.usage.input_tokens;
+            yield {
+              text: "",
+              usage: {
+                inputTokens,
+                outputTokens: 0,
+                totalTokens: inputTokens
+              },
+              rawEvent: event
+            };
+            continue;
+          }
+          if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+            yield { text: event.delta.text ?? "", rawEvent: event };
+            continue;
+          }
+          if (event.type === "message_delta") {
+            const usage = event.usage ? {
+              inputTokens,
+              outputTokens: event.usage.output_tokens,
+              totalTokens: inputTokens + event.usage.output_tokens
+            } : void 0;
+            if (event.delta.stop_reason || usage) {
+              yield {
+                text: "",
+                finishReason: event.delta.stop_reason ?? void 0,
+                usage,
+                rawEvent: event
+              };
+            }
+            continue;
+          }
+          if (event.type === "message_stop") {
+            yield { text: "", finishReason: "stop", rawEvent: event };
+          }
+        }
+      }
+      /**
+       * Count tokens in messages using Anthropic's native token counting API.
+       *
+       * This method provides accurate token estimation for Anthropic models by:
+       * - Using the native messages.countTokens() API
+       * - Properly handling system messages and conversation structure
+       * - Transforming messages to Anthropic's expected format
+       *
+       * @param messages - The messages to count tokens for
+       * @param descriptor - Model descriptor containing the model name
+       * @param _spec - Optional model specification (currently unused)
+       * @returns Promise resolving to the estimated input token count
+       *
+       * @throws Never throws - falls back to character-based estimation (4 chars/token) on error
+       *
+       * @example
+       * ```typescript
+       * const count = await provider.countTokens(
+       *   [{ role: "user", content: "Hello!" }],
+       *   { provider: "anthropic", name: "claude-3-5-sonnet-20241022" }
+       * );
+       * ```
+       */
+      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) => m.content).join("\n\n") : void 0;
+        const conversation = messages.filter(
+          (message) => message.role !== "system"
+        ).map((message) => ({
+          role: message.role,
+          content: [
+            {
+              type: "text",
+              text: message.content
+            }
+          ]
+        }));
+        try {
+          const response = await client.messages.countTokens({
+            model: descriptor.name,
+            messages: conversation,
+            ...system ? { system } : {}
+          });
+          return response.input_tokens;
+        } catch (error) {
+          console.warn(
+            `Token counting failed for ${descriptor.name}, using fallback estimation:`,
+            error
+          );
+          const totalChars = messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0);
+          return Math.ceil(totalChars / FALLBACK_CHARS_PER_TOKEN);
+        }
+      }
+    };
+  }
+});
+
+// src/providers/gemini-models.ts
+var GEMINI_MODELS;
+var init_gemini_models = __esm({
+  "src/providers/gemini-models.ts"() {
+    "use strict";
+    GEMINI_MODELS = [
+      {
+        provider: "gemini",
+        modelId: "gemini-3-pro-preview",
+        displayName: "Gemini 3 Pro (Preview)",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 2,
+          output: 12,
+          cachedInput: 0.2
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 3",
+          releaseDate: "2025-11-18",
+          notes: "Most advanced model. 1501 Elo LMArena, 91.9% GPQA Diamond, 76.2% SWE-bench. Deep Think mode available."
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-pro",
+        displayName: "Gemini 2.5 Pro",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 1.25,
+          output: 10,
+          cachedInput: 0.125
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 2.5",
+          releaseDate: "2025-06",
+          notes: "Balanced multimodal model with 1M context. Best for complex agents and reasoning."
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-flash",
+        displayName: "Gemini 2.5 Flash",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 0.3,
+          output: 2.5,
+          cachedInput: 0.03
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 2.5",
+          releaseDate: "2025-06",
+          notes: "Best price-performance ratio with thinking enabled by default"
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-flash-lite",
+        displayName: "Gemini 2.5 Flash-Lite",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 0.1,
+          output: 0.4,
+          cachedInput: 0.01
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 2.5",
+          releaseDate: "2025-06",
+          notes: "Fastest and most cost-efficient model for high-volume, low-latency tasks"
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.0-flash",
+        displayName: "Gemini 2.0 Flash",
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.1,
+          output: 0.4,
+          cachedInput: 0.01
+        },
+        knowledgeCutoff: "2024-08",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 2.0",
+          notes: "Previous generation with 1M context and multimodal capabilities"
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.0-flash-lite",
+        displayName: "Gemini 2.0 Flash-Lite",
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.075,
+          output: 0.3,
+          cachedInput: 75e-4
+        },
+        knowledgeCutoff: "2024-08",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          structuredOutputs: true
+        },
+        metadata: {
+          family: "Gemini 2.0",
+          notes: "Lightweight previous generation model for cost-sensitive applications"
+        }
+      }
+    ];
+  }
+});
+
+// src/providers/gemini.ts
+import { FunctionCallingConfigMode, GoogleGenAI } from "@google/genai";
+function createGeminiProviderFromEnv() {
+  return createProviderFromEnv("GEMINI_API_KEY", GoogleGenAI, GeminiGenerativeProvider);
+}
+var GEMINI_ROLE_MAP, GeminiGenerativeProvider;
+var init_gemini = __esm({
+  "src/providers/gemini.ts"() {
+    "use strict";
+    init_base_provider();
+    init_constants2();
+    init_gemini_models();
+    init_utils();
+    GEMINI_ROLE_MAP = {
+      system: "user",
+      user: "user",
+      assistant: "model"
+    };
+    GeminiGenerativeProvider = class extends BaseProviderAdapter {
+      providerId = "gemini";
+      supports(descriptor) {
+        return descriptor.provider === this.providerId;
+      }
+      getModelSpecs() {
+        return GEMINI_MODELS;
+      }
+      buildRequestPayload(options, descriptor, _spec, messages) {
+        const { systemInstruction, contents } = this.extractSystemAndContents(messages);
+        const generationConfig = this.buildGenerationConfig(options);
+        const config = {
+          ...systemInstruction ? { systemInstruction: systemInstruction.parts.map((p) => p.text).join("\n") } : {},
+          ...generationConfig ? { ...generationConfig } : {},
+          // Explicitly disable function calling to prevent UNEXPECTED_TOOL_CALL errors
+          toolConfig: {
+            functionCallingConfig: {
+              mode: FunctionCallingConfigMode.NONE
+            }
+          },
+          ...options.extra
+        };
+        return {
+          model: descriptor.name,
+          contents: this.convertContentsForNewSDK(contents),
+          config
+        };
+      }
+      async executeStreamRequest(payload) {
+        const client = this.client;
+        const streamResponse = await client.models.generateContentStream(payload);
+        return streamResponse;
+      }
+      extractSystemAndContents(messages) {
+        const firstSystemIndex = messages.findIndex((message) => message.role === "system");
+        if (firstSystemIndex === -1) {
+          return {
+            systemInstruction: null,
+            contents: this.mergeConsecutiveMessages(messages)
+          };
+        }
+        let systemBlockEnd = firstSystemIndex;
+        while (systemBlockEnd < messages.length && messages[systemBlockEnd].role === "system") {
+          systemBlockEnd++;
+        }
+        const systemMessages = messages.slice(firstSystemIndex, systemBlockEnd);
+        const nonSystemMessages = [
+          ...messages.slice(0, firstSystemIndex),
+          ...messages.slice(systemBlockEnd)
+        ];
+        const systemInstruction = {
+          role: "system",
+          parts: systemMessages.map((message) => ({ text: message.content }))
+        };
+        return {
+          systemInstruction,
+          contents: this.mergeConsecutiveMessages(nonSystemMessages)
+        };
+      }
+      mergeConsecutiveMessages(messages) {
+        if (messages.length === 0) {
+          return [];
+        }
+        const result = [];
+        let currentGroup = null;
+        for (const message of messages) {
+          const geminiRole = GEMINI_ROLE_MAP[message.role];
+          if (currentGroup && currentGroup.role === geminiRole) {
+            currentGroup.parts.push({ text: message.content });
+          } else {
+            if (currentGroup) {
+              result.push(currentGroup);
+            }
+            currentGroup = {
+              role: geminiRole,
+              parts: [{ text: message.content }]
+            };
+          }
+        }
+        if (currentGroup) {
+          result.push(currentGroup);
+        }
+        return result;
+      }
+      convertContentsForNewSDK(contents) {
+        return contents.map((content) => ({
+          role: content.role,
+          parts: content.parts.map((part) => ({ text: part.text }))
+        }));
+      }
+      buildGenerationConfig(options) {
+        const config = {};
+        if (typeof options.maxTokens === "number") {
+          config.maxOutputTokens = options.maxTokens;
+        }
+        if (typeof options.temperature === "number") {
+          config.temperature = options.temperature;
+        }
+        if (typeof options.topP === "number") {
+          config.topP = options.topP;
+        }
+        if (options.stopSequences?.length) {
+          config.stopSequences = options.stopSequences;
+        }
+        return Object.keys(config).length > 0 ? config : null;
+      }
+      async *wrapStream(iterable) {
+        const stream2 = iterable;
+        for await (const chunk of stream2) {
+          const text = this.extractText(chunk);
+          if (text) {
+            yield { text, rawEvent: chunk };
+          }
+          const finishReason = this.extractFinishReason(chunk);
+          const usage = this.extractUsage(chunk);
+          if (finishReason || usage) {
+            yield { text: "", finishReason, usage, rawEvent: chunk };
+          }
+        }
+      }
+      extractText(chunk) {
+        if (!chunk?.candidates) {
+          return "";
+        }
+        return chunk.candidates.flatMap((candidate) => candidate.content?.parts ?? []).map((part) => part.text ?? "").join("");
+      }
+      extractFinishReason(chunk) {
+        const candidate = chunk?.candidates?.find((item) => item.finishReason);
+        return candidate?.finishReason ?? null;
+      }
+      extractUsage(chunk) {
+        const usageMetadata = chunk?.usageMetadata;
+        if (!usageMetadata) {
+          return void 0;
+        }
+        return {
+          inputTokens: usageMetadata.promptTokenCount ?? 0,
+          outputTokens: usageMetadata.candidatesTokenCount ?? 0,
+          totalTokens: usageMetadata.totalTokenCount ?? 0
+        };
+      }
+      /**
+       * Count tokens in messages using Gemini's native token counting API.
+       *
+       * This method provides accurate token estimation for Gemini models by:
+       * - Using the SDK's countTokens() method
+       * - Properly extracting and handling system instructions
+       * - Transforming messages to Gemini's expected format
+       *
+       * @param messages - The messages to count tokens for
+       * @param descriptor - Model descriptor containing the model name
+       * @param _spec - Optional model specification (currently unused)
+       * @returns Promise resolving to the estimated input token count
+       *
+       * @throws Never throws - falls back to character-based estimation (4 chars/token) on error
+       *
+       * @example
+       * ```typescript
+       * const count = await provider.countTokens(
+       *   [{ role: "user", content: "Hello!" }],
+       *   { provider: "gemini", name: "gemini-1.5-pro" }
+       * );
+       * ```
+       */
+      async countTokens(messages, descriptor, _spec) {
+        const client = this.client;
+        const { systemInstruction, contents } = this.extractSystemAndContents(messages);
+        const request = {
+          model: descriptor.name,
+          contents: this.convertContentsForNewSDK(contents)
+        };
+        if (systemInstruction) {
+          request.systemInstruction = systemInstruction.parts.map((p) => p.text).join("\n");
+        }
+        try {
+          const response = await client.models.countTokens(request);
+          return response.totalTokens ?? 0;
+        } catch (error) {
+          console.warn(
+            `Token counting failed for ${descriptor.name}, using fallback estimation:`,
+            error
+          );
+          const totalChars = messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0);
+          return Math.ceil(totalChars / FALLBACK_CHARS_PER_TOKEN);
+        }
+      }
+    };
+  }
+});
+
+// src/providers/openai-models.ts
+var OPENAI_MODELS;
+var init_openai_models = __esm({
+  "src/providers/openai-models.ts"() {
+    "use strict";
+    OPENAI_MODELS = [
+      {
+        provider: "openai",
+        modelId: "gpt-5.1",
+        displayName: "GPT-5.1 Instant",
+        contextWindow: 128e3,
+        maxOutputTokens: 32768,
+        pricing: {
+          input: 1.25,
+          output: 10,
+          cachedInput: 0.125
+        },
+        knowledgeCutoff: "2024-09-30",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true,
+          fineTuning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          releaseDate: "2025-11-12",
+          notes: "Warmer, more intelligent, better instruction following. 2-3x faster than GPT-5.",
+          supportsTemperature: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "gpt-5.1-thinking",
+        displayName: "GPT-5.1 Thinking",
+        contextWindow: 196e3,
+        maxOutputTokens: 32768,
+        pricing: {
+          input: 1.25,
+          output: 10,
+          cachedInput: 0.125
+        },
+        knowledgeCutoff: "2024-09-30",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true,
+          fineTuning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          releaseDate: "2025-11-12",
+          notes: "Advanced reasoning with thinking levels: Light, Standard, Extended, Heavy. Best for complex tasks.",
+          supportsTemperature: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "gpt-5",
+        displayName: "GPT-5",
+        contextWindow: 272e3,
+        maxOutputTokens: 128e3,
+        pricing: {
+          input: 1.25,
+          output: 10,
+          cachedInput: 0.125
+        },
+        knowledgeCutoff: "2024-09-30",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true,
+          structuredOutputs: true,
+          fineTuning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          releaseDate: "2025-08-07",
+          notes: "Best model for coding and agentic tasks. Adaptive reasoning with 90% caching discount.",
+          supportsTemperature: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "gpt-5-mini",
+        displayName: "GPT-5 Mini",
+        contextWindow: 272e3,
+        maxOutputTokens: 32768,
+        pricing: {
+          input: 0.25,
+          output: 2,
+          cachedInput: 0.025
+        },
+        knowledgeCutoff: "2024-06-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          structuredOutputs: true,
+          fineTuning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          notes: "Fast and cost-efficient with adaptive reasoning",
+          supportsTemperature: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "gpt-5-nano",
+        displayName: "GPT-5 Nano",
+        contextWindow: 272e3,
+        maxOutputTokens: 32768,
+        pricing: {
+          input: 0.05,
+          output: 0.4,
+          cachedInput: 5e-3
+        },
+        knowledgeCutoff: "2024-05-31",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          structuredOutputs: true,
+          fineTuning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          notes: "Fastest, most cost-efficient version for well-defined tasks",
+          supportsTemperature: false
+        }
+      }
+    ];
+  }
+});
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+import { encoding_for_model } from "tiktoken";
+function sanitizeExtra(extra, allowTemperature) {
+  if (!extra) {
+    return void 0;
+  }
+  if (allowTemperature || !Object.hasOwn(extra, "temperature")) {
+    return extra;
+  }
+  return Object.fromEntries(Object.entries(extra).filter(([key]) => key !== "temperature"));
+}
+function createOpenAIProviderFromEnv() {
+  return createProviderFromEnv("OPENAI_API_KEY", OpenAI, OpenAIChatProvider);
+}
+var ROLE_MAP, OpenAIChatProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    init_base_provider();
+    init_constants2();
+    init_openai_models();
+    init_utils();
+    ROLE_MAP = {
+      system: "system",
+      user: "user",
+      assistant: "assistant"
+    };
+    OpenAIChatProvider = class extends BaseProviderAdapter {
+      providerId = "openai";
+      supports(descriptor) {
+        return descriptor.provider === this.providerId;
+      }
+      getModelSpecs() {
+        return OPENAI_MODELS;
+      }
+      buildRequestPayload(options, descriptor, spec, messages) {
+        const { maxTokens, temperature, topP, stopSequences, extra } = options;
+        const supportsTemperature = spec?.metadata?.supportsTemperature !== false;
+        const shouldIncludeTemperature = typeof temperature === "number" && supportsTemperature;
+        const sanitizedExtra = sanitizeExtra(extra, shouldIncludeTemperature);
+        return {
+          model: descriptor.name,
+          messages: messages.map((message) => ({
+            role: ROLE_MAP[message.role],
+            content: message.content,
+            name: message.name
+          })),
+          // Only set max_completion_tokens if explicitly provided
+          // Otherwise let the API use "as much as fits" in the context window
+          ...maxTokens !== void 0 ? { max_completion_tokens: maxTokens } : {},
+          top_p: topP,
+          stop: stopSequences,
+          stream: true,
+          stream_options: { include_usage: true },
+          ...sanitizedExtra ?? {},
+          ...shouldIncludeTemperature ? { temperature } : {}
+        };
+      }
+      async executeStreamRequest(payload) {
+        const client = this.client;
+        const stream2 = await client.chat.completions.create(payload);
+        return stream2;
+      }
+      async *wrapStream(iterable) {
+        const stream2 = iterable;
+        for await (const chunk of stream2) {
+          const text = chunk.choices.map((choice) => choice.delta?.content ?? "").join("");
+          if (text) {
+            yield { text, rawEvent: chunk };
+          }
+          const finishReason = chunk.choices.find((choice) => choice.finish_reason)?.finish_reason;
+          const usage = chunk.usage ? {
+            inputTokens: chunk.usage.prompt_tokens,
+            outputTokens: chunk.usage.completion_tokens,
+            totalTokens: chunk.usage.total_tokens
+          } : void 0;
+          if (finishReason || usage) {
+            yield { text: "", finishReason, usage, rawEvent: chunk };
+          }
+        }
+      }
+      /**
+       * Count tokens in messages using OpenAI's tiktoken library.
+       *
+       * This method provides accurate token estimation for OpenAI models by:
+       * - Using the model-specific tokenizer encoding
+       * - Accounting for message formatting overhead
+       * - Falling back to gpt-4o encoding for unknown models
+       *
+       * @param messages - The messages to count tokens for
+       * @param descriptor - Model descriptor containing the model name
+       * @param _spec - Optional model specification (currently unused)
+       * @returns Promise resolving to the estimated input token count
+       *
+       * @throws Never throws - falls back to character-based estimation (4 chars/token) on error
+       *
+       * @example
+       * ```typescript
+       * const count = await provider.countTokens(
+       *   [{ role: "user", content: "Hello!" }],
+       *   { provider: "openai", name: "gpt-4" }
+       * );
+       * ```
+       */
+      async countTokens(messages, descriptor, _spec) {
+        try {
+          const modelName = descriptor.name;
+          let encoding;
+          try {
+            encoding = encoding_for_model(modelName);
+          } catch {
+            encoding = encoding_for_model("gpt-4o");
+          }
+          try {
+            let tokenCount = 0;
+            for (const message of messages) {
+              tokenCount += OPENAI_MESSAGE_OVERHEAD_TOKENS;
+              const roleText = ROLE_MAP[message.role];
+              tokenCount += encoding.encode(roleText).length;
+              tokenCount += encoding.encode(message.content ?? "").length;
+              if (message.name) {
+                tokenCount += encoding.encode(message.name).length;
+                tokenCount += OPENAI_NAME_FIELD_OVERHEAD_TOKENS;
+              }
+            }
+            tokenCount += OPENAI_REPLY_PRIMING_TOKENS;
+            return tokenCount;
+          } finally {
+            encoding.free();
+          }
+        } catch (error) {
+          console.warn(
+            `Token counting failed for ${descriptor.name}, using fallback estimation:`,
+            error
+          );
+          const totalChars = messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0);
+          return Math.ceil(totalChars / FALLBACK_CHARS_PER_TOKEN);
+        }
+      }
+    };
+  }
+});
+
+// src/providers/discovery.ts
+function discoverProviderAdapters() {
+  const adapters = [];
+  for (const discover of DISCOVERERS) {
+    const adapter = discover();
+    if (adapter) {
+      adapters.push(adapter);
+    }
+  }
+  return adapters;
+}
+var DISCOVERERS;
+var init_discovery = __esm({
+  "src/providers/discovery.ts"() {
+    "use strict";
+    init_anthropic();
+    init_gemini();
+    init_openai();
+    DISCOVERERS = [
+      createOpenAIProviderFromEnv,
+      createAnthropicProviderFromEnv,
+      createGeminiProviderFromEnv
+    ];
+  }
+});
+
+// src/core/model-registry.ts
+var ModelRegistry;
+var init_model_registry = __esm({
+  "src/core/model-registry.ts"() {
+    "use strict";
+    ModelRegistry = class {
+      modelSpecs = [];
+      providerMap = /* @__PURE__ */ new Map();
+      /**
+       * Register a provider and collect its model specifications
+       */
+      registerProvider(provider) {
+        const specs = provider.getModelSpecs?.() ?? [];
+        if (specs.length > 0) {
+          this.modelSpecs.push(...specs);
+          this.providerMap.set(provider.providerId, specs);
+        }
+      }
+      /**
+       * Register a custom model specification at runtime
+       *
+       * Use this to add models that aren't in the built-in catalog, such as:
+       * - Fine-tuned models with custom pricing
+       * - New models not yet supported by llmist
+       * - Custom deployments with different configurations
+       *
+       * @param spec - Complete model specification
+       * @throws {Error} If spec is missing required fields
+       *
+       * @example
+       * ```ts
+       * client.modelRegistry.registerModel({
+       *   provider: "openai",
+       *   modelId: "ft:gpt-4o-2024-08-06:my-org:custom:abc123",
+       *   displayName: "My Fine-tuned GPT-4o",
+       *   contextWindow: 128_000,
+       *   maxOutputTokens: 16_384,
+       *   pricing: { input: 7.5, output: 30.0 },
+       *   knowledgeCutoff: "2024-08",
+       *   features: { streaming: true, functionCalling: true, vision: true }
+       * });
+       * ```
+       */
+      registerModel(spec) {
+        if (!spec.modelId || !spec.provider) {
+          throw new Error("ModelSpec must have modelId and provider");
+        }
+        const existing = this.getModelSpec(spec.modelId);
+        if (existing) {
+          console.warn(
+            `[llmist] Overwriting existing model spec for "${spec.modelId}". Previous: ${existing.displayName}, New: ${spec.displayName}`
+          );
+          const index = this.modelSpecs.findIndex((m) => m.modelId === spec.modelId);
+          if (index !== -1) {
+            this.modelSpecs.splice(index, 1);
+          }
+          const providerSpecs2 = this.providerMap.get(spec.provider);
+          if (providerSpecs2) {
+            const providerIndex = providerSpecs2.findIndex((m) => m.modelId === spec.modelId);
+            if (providerIndex !== -1) {
+              providerSpecs2.splice(providerIndex, 1);
+            }
+          }
+        }
+        this.modelSpecs.push(spec);
+        const providerSpecs = this.providerMap.get(spec.provider) ?? [];
+        providerSpecs.push(spec);
+        this.providerMap.set(spec.provider, providerSpecs);
+      }
+      /**
+       * Register multiple custom model specifications at once
+       *
+       * @param specs - Array of complete model specifications
+       *
+       * @example
+       * ```ts
+       * client.modelRegistry.registerModels([
+       *   { provider: "openai", modelId: "gpt-5", ... },
+       *   { provider: "openai", modelId: "gpt-5-mini", ... }
+       * ]);
+       * ```
+       */
+      registerModels(specs) {
+        for (const spec of specs) {
+          this.registerModel(spec);
+        }
+      }
+      /**
+       * Get model specification by model ID
+       * @param modelId - Full model identifier (e.g., 'gpt-5', 'claude-sonnet-4-5-20250929')
+       * @returns ModelSpec if found, undefined otherwise
+       */
+      getModelSpec(modelId) {
+        return this.modelSpecs.find((model) => model.modelId === modelId);
+      }
+      /**
+       * List all models, optionally filtered by provider
+       * @param providerId - Optional provider ID to filter by (e.g., 'openai', 'anthropic')
+       * @returns Array of ModelSpec objects
+       */
+      listModels(providerId) {
+        if (!providerId) {
+          return [...this.modelSpecs];
+        }
+        return this.providerMap.get(providerId) ?? [];
+      }
+      /**
+       * Get context window and output limits for a model
+       * @param modelId - Full model identifier
+       * @returns ModelLimits if model found, undefined otherwise
+       */
+      getModelLimits(modelId) {
+        const spec = this.getModelSpec(modelId);
+        if (!spec) return void 0;
+        return {
+          contextWindow: spec.contextWindow,
+          maxOutputTokens: spec.maxOutputTokens
+        };
+      }
+      /**
+       * Estimate API cost for a given model and token usage
+       * @param modelId - Full model identifier
+       * @param inputTokens - Number of input tokens
+       * @param outputTokens - Number of output tokens
+       * @param useCachedInput - Whether to use cached input pricing (if supported by provider)
+       * @returns CostEstimate if model found, undefined otherwise
+       */
+      estimateCost(modelId, inputTokens, outputTokens, useCachedInput = false) {
+        const spec = this.getModelSpec(modelId);
+        if (!spec) return void 0;
+        const inputRate = useCachedInput && spec.pricing.cachedInput !== void 0 ? spec.pricing.cachedInput : spec.pricing.input;
+        const inputCost = inputTokens / 1e6 * inputRate;
+        const outputCost = outputTokens / 1e6 * spec.pricing.output;
+        const totalCost = inputCost + outputCost;
+        return {
+          inputCost,
+          outputCost,
+          totalCost,
+          currency: "USD"
+        };
+      }
+      /**
+       * Validate that requested token count fits within model limits
+       * @param modelId - Full model identifier
+       * @param requestedTokens - Total tokens requested (input + output)
+       * @returns true if valid, false if model not found or exceeds limits
+       */
+      validateModelConfig(modelId, requestedTokens) {
+        const limits = this.getModelLimits(modelId);
+        if (!limits) return false;
+        return requestedTokens <= limits.contextWindow;
+      }
+      /**
+       * Check if a model supports a specific feature
+       * @param modelId - Full model identifier
+       * @param feature - Feature to check ('streaming', 'functionCalling', 'vision', etc.)
+       * @returns true if model supports feature, false otherwise
+       */
+      supportsFeature(modelId, feature) {
+        const spec = this.getModelSpec(modelId);
+        if (!spec) return false;
+        return spec.features[feature] === true;
+      }
+      /**
+       * Get all models that support a specific feature
+       * @param feature - Feature to filter by
+       * @param providerId - Optional provider ID to filter by
+       * @returns Array of ModelSpec objects that support the feature
+       */
+      getModelsByFeature(feature, providerId) {
+        const models = this.listModels(providerId);
+        return models.filter((model) => model.features[feature] === true);
+      }
+      /**
+       * Get the most cost-effective model for a given provider and token budget
+       * @param inputTokens - Expected input tokens
+       * @param outputTokens - Expected output tokens
+       * @param providerId - Optional provider ID to filter by
+       * @returns ModelSpec with lowest total cost, or undefined if no models found
+       */
+      getCheapestModel(inputTokens, outputTokens, providerId) {
+        const models = this.listModels(providerId);
+        if (models.length === 0) return void 0;
+        let cheapest;
+        for (const model of models) {
+          const estimate = this.estimateCost(model.modelId, inputTokens, outputTokens);
+          if (!estimate) continue;
+          if (!cheapest || estimate.totalCost < cheapest.cost) {
+            cheapest = { model, cost: estimate.totalCost };
+          }
+        }
+        return cheapest?.model;
+      }
+    };
+  }
+});
+
+// src/core/options.ts
+var ModelIdentifierParser;
+var init_options = __esm({
+  "src/core/options.ts"() {
+    "use strict";
+    ModelIdentifierParser = class {
+      constructor(defaultProvider = "openai") {
+        this.defaultProvider = defaultProvider;
+      }
+      parse(identifier) {
+        const trimmed = identifier.trim();
+        if (!trimmed) {
+          throw new Error("Model identifier cannot be empty");
+        }
+        const [maybeProvider, ...rest] = trimmed.split(":");
+        if (rest.length === 0) {
+          return { provider: this.defaultProvider, name: maybeProvider };
+        }
+        const provider = maybeProvider;
+        const name = rest.join(":");
+        if (!name) {
+          throw new Error("Model name cannot be empty");
+        }
+        return { provider, name };
+      }
+    };
+  }
+});
+
+// src/core/quick-methods.ts
+async function complete(client, prompt, options = {}) {
+  const model = resolveModel(options.model ?? "gpt-5-nano");
+  const builder = new LLMMessageBuilder();
+  if (options.systemPrompt) {
+    builder.addSystem(options.systemPrompt);
+  }
+  builder.addUser(prompt);
+  let fullResponse = "";
+  for await (const chunk of client.stream({
+    model,
+    messages: builder.build(),
+    temperature: options.temperature,
+    maxTokens: options.maxTokens
+  })) {
+    fullResponse += chunk.text;
+  }
+  return fullResponse.trim();
+}
+async function* stream(client, prompt, options = {}) {
+  const model = resolveModel(options.model ?? "gpt-5-nano");
+  const builder = new LLMMessageBuilder();
+  if (options.systemPrompt) {
+    builder.addSystem(options.systemPrompt);
+  }
+  builder.addUser(prompt);
+  for await (const chunk of client.stream({
+    model,
+    messages: builder.build(),
+    temperature: options.temperature,
+    maxTokens: options.maxTokens
+  })) {
+    yield chunk.text;
+  }
+}
+var init_quick_methods = __esm({
+  "src/core/quick-methods.ts"() {
+    "use strict";
+    init_messages();
+    init_model_shortcuts();
+  }
+});
+
+// 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/agent.ts
+var Agent;
+var init_agent = __esm({
+  "src/agent/agent.ts"() {
+    "use strict";
+    init_messages();
+    init_model_shortcuts();
+    init_logger();
+    init_agent_internal_key();
+    init_conversation_manager();
+    init_event_handlers();
+    init_hook_validators();
+    init_stream_processor();
+    Agent = class {
+      client;
+      model;
+      maxIterations;
+      temperature;
+      logger;
+      hooks;
+      conversation;
+      registry;
+      parameterFormat;
+      gadgetStartPrefix;
+      gadgetEndPrefix;
+      onHumanInputRequired;
+      textOnlyHandler;
+      stopOnGadgetError;
+      shouldContinueAfterError;
+      defaultGadgetTimeoutMs;
+      defaultMaxTokens;
+      userPromptProvided;
+      /**
+       * Creates a new Agent instance.
+       * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
+       */
+      constructor(key, options) {
+        if (!isValidAgentKey(key)) {
+          throw new Error(
+            "Agent cannot be instantiated directly. Use LLMist.createAgent() or new AgentBuilder() instead."
+          );
+        }
+        this.client = options.client;
+        this.model = resolveModel(options.model);
+        this.maxIterations = options.maxIterations ?? 10;
+        this.temperature = options.temperature;
+        this.logger = options.logger ?? createLogger({ name: "llmist:agent" });
+        this.hooks = options.hooks ?? {};
+        this.registry = options.registry;
+        this.parameterFormat = options.parameterFormat ?? "json";
+        this.gadgetStartPrefix = options.gadgetStartPrefix;
+        this.gadgetEndPrefix = options.gadgetEndPrefix;
+        this.onHumanInputRequired = options.onHumanInputRequired;
+        this.textOnlyHandler = options.textOnlyHandler ?? "terminate";
+        this.stopOnGadgetError = options.stopOnGadgetError ?? true;
+        this.shouldContinueAfterError = options.shouldContinueAfterError;
+        this.defaultGadgetTimeoutMs = options.defaultGadgetTimeoutMs;
+        this.defaultMaxTokens = this.resolveMaxTokensFromCatalog(options.model);
+        const baseBuilder = new LLMMessageBuilder(options.promptConfig);
+        if (options.systemPrompt) {
+          baseBuilder.addSystem(options.systemPrompt);
+        }
+        baseBuilder.addGadgets(this.registry.getAll(), this.parameterFormat, {
+          startPrefix: options.gadgetStartPrefix,
+          endPrefix: options.gadgetEndPrefix
+        });
+        const baseMessages = baseBuilder.build();
+        const initialMessages = (options.initialMessages ?? []).map((message) => ({
+          role: message.role,
+          content: message.content
+        }));
+        this.conversation = new ConversationManager(
+          baseMessages,
+          initialMessages,
+          this.parameterFormat
+        );
+        this.userPromptProvided = !!options.userPrompt;
+        if (options.userPrompt) {
+          this.conversation.addUserMessage(options.userPrompt);
+        }
+      }
+      /**
+       * Get the gadget registry for this agent.
+       *
+       * Useful for inspecting registered gadgets in tests or advanced use cases.
+       *
+       * @returns The GadgetRegistry instance
+       *
+       * @example
+       * ```typescript
+       * const agent = new AgentBuilder()
+       *   .withModel("sonnet")
+       *   .withGadgets(Calculator, Weather)
+       *   .build();
+       *
+       * // Inspect registered gadgets
+       * console.log(agent.getRegistry().getNames()); // ['Calculator', 'Weather']
+       * ```
+       */
+      getRegistry() {
+        return this.registry;
+      }
+      /**
+       * Run the agent loop.
+       * Clean, simple orchestration - all complexity is in StreamProcessor.
+       *
+       * @throws {Error} If no user prompt was provided (when using build() without ask())
+       */
+      async *run() {
+        if (!this.userPromptProvided) {
+          throw new Error(
+            "No user prompt provided. Use .ask(prompt) instead of .build(), or call agent.run() after providing a prompt."
+          );
+        }
+        let currentIteration = 0;
+        this.logger.info("Starting agent loop", {
+          model: this.model,
+          maxIterations: this.maxIterations
+        });
+        while (currentIteration < this.maxIterations) {
+          this.logger.debug("Starting iteration", { iteration: currentIteration });
+          try {
+            let llmOptions = {
+              model: this.model,
+              messages: this.conversation.getMessages(),
+              temperature: this.temperature,
+              maxTokens: this.defaultMaxTokens
+            };
+            await this.safeObserve(async () => {
+              if (this.hooks.observers?.onLLMCallStart) {
+                const context = {
+                  iteration: currentIteration,
+                  options: llmOptions,
+                  logger: this.logger
+                };
+                await this.hooks.observers.onLLMCallStart(context);
+              }
+            });
+            if (this.hooks.controllers?.beforeLLMCall) {
+              const context = {
+                iteration: currentIteration,
+                options: llmOptions,
+                logger: this.logger
+              };
+              const action = await this.hooks.controllers.beforeLLMCall(context);
+              validateBeforeLLMCallAction(action);
+              if (action.action === "skip") {
+                this.logger.info("Controller skipped LLM call, using synthetic response");
+                this.conversation.addAssistantMessage(action.syntheticResponse);
+                yield { type: "text", content: action.syntheticResponse };
+                break;
+              } else if (action.action === "proceed" && action.modifiedOptions) {
+                llmOptions = { ...llmOptions, ...action.modifiedOptions };
+              }
+            }
+            this.logger.info("Calling LLM", { model: this.model });
+            this.logger.silly("LLM request details", {
+              model: llmOptions.model,
+              temperature: llmOptions.temperature,
+              maxTokens: llmOptions.maxTokens,
+              messageCount: llmOptions.messages.length,
+              messages: llmOptions.messages
+            });
+            const stream2 = this.client.stream(llmOptions);
+            const processor = new StreamProcessor({
+              iteration: currentIteration,
+              registry: this.registry,
+              parameterFormat: this.parameterFormat,
+              gadgetStartPrefix: this.gadgetStartPrefix,
+              gadgetEndPrefix: this.gadgetEndPrefix,
+              hooks: this.hooks,
+              logger: this.logger.getSubLogger({ name: "stream-processor" }),
+              onHumanInputRequired: this.onHumanInputRequired,
+              stopOnGadgetError: this.stopOnGadgetError,
+              shouldContinueAfterError: this.shouldContinueAfterError,
+              defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs
+            });
+            const result = await processor.process(stream2);
+            for (const output of result.outputs) {
+              yield output;
+            }
+            this.logger.info("LLM response completed", {
+              finishReason: result.finishReason,
+              usage: result.usage,
+              didExecuteGadgets: result.didExecuteGadgets
+            });
+            this.logger.silly("LLM response details", {
+              rawResponse: result.rawResponse
+            });
+            await this.safeObserve(async () => {
+              if (this.hooks.observers?.onLLMCallComplete) {
+                const context = {
+                  iteration: currentIteration,
+                  options: llmOptions,
+                  finishReason: result.finishReason,
+                  usage: result.usage,
+                  rawResponse: result.rawResponse,
+                  finalMessage: result.finalMessage,
+                  logger: this.logger
+                };
+                await this.hooks.observers.onLLMCallComplete(context);
+              }
+            });
+            let finalMessage = result.finalMessage;
+            if (this.hooks.controllers?.afterLLMCall) {
+              const context = {
+                iteration: currentIteration,
+                options: llmOptions,
+                finishReason: result.finishReason,
+                usage: result.usage,
+                finalMessage: result.finalMessage,
+                logger: this.logger
+              };
+              const action = await this.hooks.controllers.afterLLMCall(context);
+              validateAfterLLMCallAction(action);
+              if (action.action === "modify_and_continue" || action.action === "append_and_modify") {
+                finalMessage = action.modifiedMessage;
+              }
+              if (action.action === "append_messages" || action.action === "append_and_modify") {
+                for (const msg of action.messages) {
+                  if (msg.role === "user") {
+                    this.conversation.addUserMessage(msg.content);
+                  } else if (msg.role === "assistant") {
+                    this.conversation.addAssistantMessage(msg.content);
+                  } else if (msg.role === "system") {
+                    this.conversation.addUserMessage(`[System] ${msg.content}`);
+                  }
+                }
+              }
+            }
+            if (result.didExecuteGadgets) {
+              for (const output of result.outputs) {
+                if (output.type === "gadget_result") {
+                  const gadgetResult = output.result;
+                  this.conversation.addGadgetCall(
+                    gadgetResult.gadgetName,
+                    gadgetResult.parameters,
+                    gadgetResult.error ?? gadgetResult.result ?? ""
+                  );
+                }
+              }
+            } else {
+              this.conversation.addAssistantMessage(finalMessage);
+              const shouldBreak = await this.handleTextOnlyResponse(finalMessage);
+              if (shouldBreak) {
+                break;
+              }
+            }
+            if (result.shouldBreakLoop) {
+              this.logger.info("Loop terminated by gadget or processor");
+              break;
+            }
+          } catch (error) {
+            const errorHandled = await this.handleLLMError(error, currentIteration);
+            await this.safeObserve(async () => {
+              if (this.hooks.observers?.onLLMCallError) {
+                const context = {
+                  iteration: currentIteration,
+                  options: {
+                    model: this.model,
+                    messages: this.conversation.getMessages(),
+                    temperature: this.temperature,
+                    maxTokens: this.defaultMaxTokens
+                  },
+                  error,
+                  recovered: errorHandled,
+                  logger: this.logger
+                };
+                await this.hooks.observers.onLLMCallError(context);
+              }
+            });
+            if (!errorHandled) {
+              throw error;
+            }
+          }
+          currentIteration++;
+        }
+        this.logger.info("Agent loop completed", {
+          totalIterations: currentIteration,
+          reason: currentIteration >= this.maxIterations ? "max_iterations" : "natural_completion"
+        });
+      }
+      /**
+       * Handle LLM error through controller.
+       */
+      async handleLLMError(error, iteration) {
+        this.logger.error("LLM call failed", { error: error.message });
+        if (this.hooks.controllers?.afterLLMError) {
+          const context = {
+            iteration,
+            options: {
+              model: this.model,
+              messages: this.conversation.getMessages(),
+              temperature: this.temperature,
+              maxTokens: this.defaultMaxTokens
+            },
+            error,
+            logger: this.logger
+          };
+          const action = await this.hooks.controllers.afterLLMError(context);
+          validateAfterLLMErrorAction(action);
+          if (action.action === "recover") {
+            this.logger.info("Controller recovered from LLM error");
+            this.conversation.addAssistantMessage(action.fallbackResponse);
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Handle text-only response (no gadgets called).
+       */
+      async handleTextOnlyResponse(_text) {
+        const handler = this.textOnlyHandler;
+        if (typeof handler === "string") {
+          switch (handler) {
+            case "terminate":
+              this.logger.info("No gadgets called, ending loop");
+              return true;
+            case "acknowledge":
+              this.logger.info("No gadgets called, continuing loop");
+              return false;
+            case "wait_for_input":
+              this.logger.info("No gadgets called, waiting for input");
+              return true;
+            default:
+              this.logger.warn(`Unknown text-only strategy: ${handler}, defaulting to terminate`);
+              return true;
+          }
+        }
+        return true;
+      }
+      /**
+       * Safely execute an observer, catching and logging any errors.
+       */
+      async safeObserve(fn) {
+        try {
+          await fn();
+        } catch (error) {
+          this.logger.error("Observer threw error (ignoring)", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      /**
+       * Resolve max tokens from model catalog.
+       */
+      resolveMaxTokensFromCatalog(modelId) {
+        const limits = this.client.modelRegistry.getModelLimits(modelId);
+        if (limits?.maxOutputTokens !== void 0) {
+          return limits.maxOutputTokens;
+        }
+        const separatorIndex = modelId.indexOf(":");
+        if (separatorIndex === -1) {
+          return void 0;
+        }
+        const unprefixedModelId = modelId.slice(separatorIndex + 1).trim();
+        if (!unprefixedModelId) {
+          return void 0;
+        }
+        return this.client.modelRegistry.getModelLimits(unprefixedModelId)?.maxOutputTokens;
+      }
+      /**
+       * Run agent with named event handlers (syntactic sugar).
+       *
+       * Instead of verbose if/else chains, use named handlers for cleaner code.
+       *
+       * @param handlers - Named event handlers
+       *
+       * @example
+       * ```typescript
+       * await agent.runWith({
+       *   onText: (text) => console.log("LLM:", text),
+       *   onGadgetResult: (result) => console.log("Result:", result.result),
+       *   onGadgetCall: (call) => console.log("Calling:", call.gadgetName),
+       * });
+       * ```
+       */
+      async runWith(handlers) {
+        return runWithHandlers(this.run(), handlers);
+      }
+    };
+  }
+});
+
+// src/agent/builder.ts
+var AgentBuilder;
+var init_builder = __esm({
+  "src/agent/builder.ts"() {
+    "use strict";
+    init_model_shortcuts();
+    init_registry();
+    init_agent();
+    init_agent_internal_key();
+    init_event_handlers();
+    AgentBuilder = class {
+      client;
+      model;
+      systemPrompt;
+      temperature;
+      maxIterations;
+      logger;
+      hooks;
+      promptConfig;
+      gadgets = [];
+      initialMessages = [];
+      onHumanInputRequired;
+      parameterFormat;
+      gadgetStartPrefix;
+      gadgetEndPrefix;
+      textOnlyHandler;
+      stopOnGadgetError;
+      shouldContinueAfterError;
+      defaultGadgetTimeoutMs;
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Set the model to use.
+       * Supports aliases like "gpt4", "sonnet", "flash".
+       *
+       * @param model - Model name or alias
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withModel("sonnet")           // Alias
+       * .withModel("gpt-5-nano")       // Auto-detects provider
+       * .withModel("openai:gpt-5")     // Explicit provider
+       * ```
+       */
+      withModel(model) {
+        this.model = resolveModel(model);
+        return this;
+      }
+      /**
+       * Set the system prompt.
+       *
+       * @param prompt - System prompt
+       * @returns This builder for chaining
+       */
+      withSystem(prompt) {
+        this.systemPrompt = prompt;
+        return this;
+      }
+      /**
+       * Set the temperature (0-1).
+       *
+       * @param temperature - Temperature value
+       * @returns This builder for chaining
+       */
+      withTemperature(temperature) {
+        this.temperature = temperature;
+        return this;
+      }
+      /**
+       * Set maximum iterations.
+       *
+       * @param max - Maximum number of iterations
+       * @returns This builder for chaining
+       */
+      withMaxIterations(max) {
+        this.maxIterations = max;
+        return this;
+      }
+      /**
+       * Set logger instance.
+       *
+       * @param logger - Logger instance
+       * @returns This builder for chaining
+       */
+      withLogger(logger) {
+        this.logger = logger;
+        return this;
+      }
+      /**
+       * Add hooks for agent lifecycle events.
+       *
+       * @param hooks - Agent hooks configuration
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * import { HookPresets } from 'llmist/hooks';
+       *
+       * .withHooks(HookPresets.logging())
+       * .withHooks(HookPresets.merge(
+       *   HookPresets.logging(),
+       *   HookPresets.timing()
+       * ))
+       * ```
+       */
+      withHooks(hooks) {
+        this.hooks = hooks;
+        return this;
+      }
+      /**
+       * Configure custom prompts for gadget system messages.
+       *
+       * @param config - Prompt configuration object
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withPromptConfig({
+       *   mainInstruction: "Use the gadget markers below:",
+       *   rules: ["Always use markers", "Never use function calling"]
+       * })
+       * ```
+       */
+      withPromptConfig(config) {
+        this.promptConfig = config;
+        return this;
+      }
+      /**
+       * Add gadgets (classes or instances).
+       * Can be called multiple times to add more gadgets.
+       *
+       * @param gadgets - Gadget classes or instances
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withGadgets(Calculator, Weather, Email)
+       * .withGadgets(new Calculator(), new Weather())
+       * .withGadgets(createGadget({ ... }))
+       * ```
+       */
+      withGadgets(...gadgets) {
+        this.gadgets.push(...gadgets);
+        return this;
+      }
+      /**
+       * Add conversation history messages.
+       * Useful for continuing previous conversations.
+       *
+       * @param messages - Array of history messages
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withHistory([
+       *   { user: "Hello" },
+       *   { assistant: "Hi there!" },
+       *   { user: "How are you?" },
+       *   { assistant: "I'm doing well, thanks!" }
+       * ])
+       * ```
+       */
+      withHistory(messages) {
+        for (const msg of messages) {
+          if ("user" in msg) {
+            this.initialMessages.push({ role: "user", content: msg.user });
+          } else if ("assistant" in msg) {
+            this.initialMessages.push({ role: "assistant", content: msg.assistant });
+          } else if ("system" in msg) {
+            this.initialMessages.push({ role: "system", content: msg.system });
+          }
+        }
+        return this;
+      }
+      /**
+       * Add a single message to the conversation history.
+       *
+       * @param message - Single history message
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .addMessage({ user: "Hello" })
+       * .addMessage({ assistant: "Hi there!" })
+       * ```
+       */
+      addMessage(message) {
+        return this.withHistory([message]);
+      }
+      /**
+       * Set the human input handler for interactive conversations.
+       *
+       * @param handler - Function to handle human input requests
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .onHumanInput(async (question) => {
+       *   return await promptUser(question);
+       * })
+       * ```
+       */
+      onHumanInput(handler) {
+        this.onHumanInputRequired = handler;
+        return this;
+      }
+      /**
+       * Set the parameter format for gadget calls.
+       *
+       * @param format - Parameter format ("json" or "xml")
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withParameterFormat("xml")
+       * ```
+       */
+      withParameterFormat(format) {
+        this.parameterFormat = format;
+        return this;
+      }
+      /**
+       * Set custom gadget marker prefix.
+       *
+       * @param prefix - Custom start prefix for gadget markers
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withGadgetStartPrefix("<<GADGET_START>>")
+       * ```
+       */
+      withGadgetStartPrefix(prefix) {
+        this.gadgetStartPrefix = prefix;
+        return this;
+      }
+      /**
+       * Set custom gadget marker suffix.
+       *
+       * @param suffix - Custom end suffix for gadget markers
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withGadgetEndPrefix("<<GADGET_END>>")
+       * ```
+       */
+      withGadgetEndPrefix(suffix) {
+        this.gadgetEndPrefix = suffix;
+        return this;
+      }
+      /**
+       * Set the text-only handler strategy.
+       *
+       * Controls what happens when the LLM returns text without calling any gadgets:
+       * - "terminate": End the agent loop (default)
+       * - "acknowledge": Continue the loop for another iteration
+       * - "wait_for_input": Wait for human input
+       * - Custom handler: Provide a function for dynamic behavior
+       *
+       * @param handler - Text-only handler strategy or custom handler
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // Simple strategy
+       * .withTextOnlyHandler("acknowledge")
+       *
+       * // Custom handler
+       * .withTextOnlyHandler({
+       *   type: "custom",
+       *   handler: async (context) => {
+       *     if (context.text.includes("?")) {
+       *       return { action: "wait_for_input", question: context.text };
+       *     }
+       *     return { action: "continue" };
+       *   }
+       * })
+       * ```
+       */
+      withTextOnlyHandler(handler) {
+        this.textOnlyHandler = handler;
+        return this;
+      }
+      /**
+       * Set whether to stop gadget execution on first error.
+       *
+       * When true (default), if a gadget fails:
+       * - Subsequent gadgets in the same response are skipped
+       * - LLM stream is cancelled to save costs
+       * - Agent loop continues with error in context
+       *
+       * When false:
+       * - All gadgets in the response still execute
+       * - LLM stream continues to completion
+       *
+       * @param stop - Whether to stop on gadget error
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withStopOnGadgetError(false)
+       * ```
+       */
+      withStopOnGadgetError(stop) {
+        this.stopOnGadgetError = stop;
+        return this;
+      }
+      /**
+       * Set custom error handling logic.
+       *
+       * 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
+       * in `AgentOptions`. The method is named `withErrorHandler` for better developer experience,
+       * but maps to the `shouldContinueAfterError` property internally.
+       *
+       * @param handler - Function that decides whether to continue after an error.
+       *                  Return `true` to continue execution, `false` to stop.
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withErrorHandler((context) => {
+       *   // Stop on parse errors, continue on validation/execution errors
+       *   if (context.errorType === "parse") {
+       *     return false;
+       *   }
+       *   if (context.error.includes("CRITICAL")) {
+       *     return false;
+       *   }
+       *   return true;
+       * })
+       * ```
+       */
+      withErrorHandler(handler) {
+        this.shouldContinueAfterError = handler;
+        return this;
+      }
+      /**
+       * Set default timeout for gadget execution.
+       *
+       * @param timeoutMs - Timeout in milliseconds (must be non-negative)
+       * @returns This builder for chaining
+       * @throws {Error} If timeout is negative
+       *
+       * @example
+       * ```typescript
+       * .withDefaultGadgetTimeout(5000) // 5 second timeout
+       * ```
+       */
+      withDefaultGadgetTimeout(timeoutMs) {
+        if (timeoutMs < 0) {
+          throw new Error("Timeout must be a non-negative number");
+        }
+        this.defaultGadgetTimeoutMs = timeoutMs;
+        return this;
+      }
+      /**
+       * Build and create the agent with the given user prompt.
+       * Returns the Agent instance ready to run.
+       *
+       * @param userPrompt - User's question or request
+       * @returns Configured Agent instance
+       *
+       * @example
+       * ```typescript
+       * const agent = await LLMist.createAgent()
+       *   .withModel("sonnet")
+       *   .withGadgets(Calculator)
+       *   .ask("What is 2+2?");
+       *
+       * for await (const event of agent.run()) {
+       *   // handle events
+       * }
+       * ```
+       */
+      ask(userPrompt) {
+        if (!this.client) {
+          const { LLMist: LLMistClass } = (init_client(), __toCommonJS(client_exports));
+          this.client = new LLMistClass();
+        }
+        const registry = GadgetRegistry.from(this.gadgets);
+        const options = {
+          client: this.client,
+          model: this.model ?? "openai:gpt-5-nano",
+          systemPrompt: this.systemPrompt,
+          userPrompt,
+          registry,
+          maxIterations: this.maxIterations,
+          temperature: this.temperature,
+          logger: this.logger,
+          hooks: this.hooks,
+          promptConfig: this.promptConfig,
+          initialMessages: this.initialMessages,
+          onHumanInputRequired: this.onHumanInputRequired,
+          parameterFormat: this.parameterFormat,
+          gadgetStartPrefix: this.gadgetStartPrefix,
+          gadgetEndPrefix: this.gadgetEndPrefix,
+          textOnlyHandler: this.textOnlyHandler,
+          stopOnGadgetError: this.stopOnGadgetError,
+          shouldContinueAfterError: this.shouldContinueAfterError,
+          defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs
+        };
+        return new Agent(AGENT_INTERNAL_KEY, options);
+      }
+      /**
+       * Build, run, and collect only the text response.
+       * Convenient for simple queries where you just want the final answer.
+       *
+       * @param userPrompt - User's question or request
+       * @returns Promise resolving to the complete text response
+       *
+       * @example
+       * ```typescript
+       * const answer = await LLMist.createAgent()
+       *   .withModel("gpt4-mini")
+       *   .withGadgets(Calculator)
+       *   .askAndCollect("What is 42 * 7?");
+       *
+       * console.log(answer); // "294"
+       * ```
+       */
+      async askAndCollect(userPrompt) {
+        const agent = this.ask(userPrompt);
+        return collectText(agent.run());
+      }
+      /**
+       * Build and run with event handlers.
+       * Combines agent creation and event handling in one call.
+       *
+       * @param userPrompt - User's question or request
+       * @param handlers - Event handlers
+       *
+       * @example
+       * ```typescript
+       * await LLMist.createAgent()
+       *   .withModel("sonnet")
+       *   .withGadgets(Calculator)
+       *   .askWith("What is 2+2?", {
+       *     onText: (text) => console.log("LLM:", text),
+       *     onGadgetResult: (result) => console.log("Result:", result.result),
+       *   });
+       * ```
+       */
+      async askWith(userPrompt, handlers) {
+        const agent = this.ask(userPrompt);
+        await agent.runWith(handlers);
+      }
+      /**
+       * Build the agent without a user prompt.
+       *
+       * Returns an Agent instance that can be inspected (e.g., check registered gadgets)
+       * but cannot be run without first calling .ask(prompt).
+       *
+       * This is useful for:
+       * - Testing: Inspect the registry, configuration, etc.
+       * - Advanced use cases: Build agent configuration separately from execution
+       *
+       * @returns Configured Agent instance (without user prompt)
+       *
+       * @example
+       * ```typescript
+       * // Build agent for inspection
+       * const agent = new AgentBuilder()
+       *   .withModel("sonnet")
+       *   .withGadgets(Calculator, Weather)
+       *   .build();
+       *
+       * // Inspect registered gadgets
+       * console.log(agent.getRegistry().getNames()); // ['Calculator', 'Weather']
+       *
+       * // Note: Calling agent.run() will throw an error
+       * // Use .ask(prompt) instead if you want to run the agent
+       * ```
+       */
+      build() {
+        if (!this.client) {
+          const { LLMist: LLMistClass } = (init_client(), __toCommonJS(client_exports));
+          this.client = new LLMistClass();
+        }
+        const registry = GadgetRegistry.from(this.gadgets);
+        const options = {
+          client: this.client,
+          model: this.model ?? "openai:gpt-5-nano",
+          systemPrompt: this.systemPrompt,
+          // No userPrompt - agent.run() will throw if called directly
+          registry,
+          maxIterations: this.maxIterations,
+          temperature: this.temperature,
+          logger: this.logger,
+          hooks: this.hooks,
+          promptConfig: this.promptConfig,
+          initialMessages: this.initialMessages,
+          onHumanInputRequired: this.onHumanInputRequired,
+          parameterFormat: this.parameterFormat,
+          gadgetStartPrefix: this.gadgetStartPrefix,
+          gadgetEndPrefix: this.gadgetEndPrefix,
+          textOnlyHandler: this.textOnlyHandler,
+          stopOnGadgetError: this.stopOnGadgetError,
+          shouldContinueAfterError: this.shouldContinueAfterError,
+          defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs
+        };
+        return new Agent(AGENT_INTERNAL_KEY, options);
+      }
+    };
+  }
+});
+
+// src/core/client.ts
+var client_exports = {};
+__export(client_exports, {
+  LLMist: () => LLMist
+});
+var LLMist;
+var init_client = __esm({
+  "src/core/client.ts"() {
+    "use strict";
+    init_builder();
+    init_discovery();
+    init_model_registry();
+    init_options();
+    init_quick_methods();
+    LLMist = class _LLMist {
+      parser;
+      modelRegistry;
+      adapters;
+      constructor(...args) {
+        let adapters = [];
+        let defaultProvider;
+        let autoDiscoverProviders = true;
+        let customModels = [];
+        if (args.length === 0) {
+        } else if (Array.isArray(args[0])) {
+          adapters = args[0];
+          if (args.length > 1) {
+            defaultProvider = args[1];
+          }
+        } else if (typeof args[0] === "object" && args[0] !== null) {
+          const options = args[0];
+          adapters = options.adapters ?? [];
+          defaultProvider = options.defaultProvider;
+          customModels = options.customModels ?? [];
+          if (typeof options.autoDiscoverProviders === "boolean") {
+            autoDiscoverProviders = options.autoDiscoverProviders;
+          }
+        }
+        const discoveredAdapters = autoDiscoverProviders ? discoverProviderAdapters() : [];
+        const combinedAdapters = [...adapters];
+        for (const adapter of discoveredAdapters) {
+          if (!combinedAdapters.some((existing) => existing.providerId === adapter.providerId)) {
+            combinedAdapters.push(adapter);
+          }
+        }
+        if (combinedAdapters.length === 0) {
+          throw new Error(
+            "No LLM providers available. Provide adapters explicitly or set provider API keys in the environment."
+          );
+        }
+        const resolvedDefaultProvider = defaultProvider ?? combinedAdapters[0]?.providerId ?? "openai";
+        this.adapters = [...combinedAdapters].sort((a, b) => {
+          const priorityA = a.priority ?? 0;
+          const priorityB = b.priority ?? 0;
+          return priorityB - priorityA;
+        });
+        this.parser = new ModelIdentifierParser(resolvedDefaultProvider);
+        this.modelRegistry = new ModelRegistry();
+        for (const adapter of this.adapters) {
+          this.modelRegistry.registerProvider(adapter);
+        }
+        if (customModels.length > 0) {
+          this.modelRegistry.registerModels(customModels);
+        }
+      }
+      stream(options) {
+        const descriptor = this.parser.parse(options.model);
+        const spec = this.modelRegistry.getModelSpec(descriptor.name);
+        const adapter = this.resolveAdapter(descriptor);
+        return adapter.stream(options, descriptor, spec);
+      }
+      /**
+       * Count tokens in messages for a given model.
+       *
+       * Uses provider-specific token counting methods for accurate estimation:
+       * - OpenAI: tiktoken library with model-specific encodings
+       * - Anthropic: Native messages.countTokens() API
+       * - Gemini: SDK's countTokens() method
+       *
+       * Falls back to character-based estimation (4 chars/token) if the provider
+       * doesn't support native token counting or if counting fails.
+       *
+       * This is useful for:
+       * - Pre-request cost estimation
+       * - Context window management
+       * - Request batching optimization
+       *
+       * @param model - Model identifier (e.g., "openai:gpt-4", "anthropic:claude-3-5-sonnet-20241022")
+       * @param messages - Array of messages to count tokens for
+       * @returns Promise resolving to the estimated input token count
+       *
+       * @example
+       * ```typescript
+       * const client = new LLMist();
+       * const messages = [
+       *   { role: 'system', content: 'You are a helpful assistant.' },
+       *   { role: 'user', content: 'Hello!' }
+       * ];
+       *
+       * const tokenCount = await client.countTokens('openai:gpt-4', messages);
+       * console.log(`Estimated tokens: ${tokenCount}`);
+       * ```
+       */
+      async countTokens(model, messages) {
+        const descriptor = this.parser.parse(model);
+        const spec = this.modelRegistry.getModelSpec(descriptor.name);
+        const adapter = this.resolveAdapter(descriptor);
+        if (adapter.countTokens) {
+          return adapter.countTokens(messages, descriptor, spec);
+        }
+        const totalChars = messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0);
+        return Math.ceil(totalChars / 4);
+      }
+      resolveAdapter(descriptor) {
+        const adapter = this.adapters.find((item) => item.supports(descriptor));
+        if (!adapter) {
+          throw new Error(`No adapter registered for provider ${descriptor.provider}`);
+        }
+        return adapter;
+      }
+      /**
+       * Quick completion - returns final text response.
+       * Convenient for simple queries without needing agent setup.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Complete text response
+       *
+       * @example
+       * ```typescript
+       * const answer = await LLMist.complete("What is 2+2?");
+       * console.log(answer); // "4" or "2+2 equals 4"
+       *
+       * const answer = await LLMist.complete("Tell me a joke", {
+       *   model: "sonnet",
+       *   temperature: 0.9
+       * });
+       * ```
+       */
+      static async complete(prompt, options) {
+        const client = new _LLMist();
+        return complete(client, prompt, options);
+      }
+      /**
+       * Quick streaming - returns async generator of text chunks.
+       * Convenient for streaming responses without needing agent setup.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Async generator yielding text chunks
+       *
+       * @example
+       * ```typescript
+       * for await (const chunk of LLMist.stream("Tell me a story")) {
+       *   process.stdout.write(chunk);
+       * }
+       *
+       * // With options
+       * for await (const chunk of LLMist.stream("Generate code", {
+       *   model: "gpt4",
+       *   systemPrompt: "You are a coding assistant"
+       * })) {
+       *   process.stdout.write(chunk);
+       * }
+       * ```
+       */
+      static stream(prompt, options) {
+        const client = new _LLMist();
+        return stream(client, prompt, options);
+      }
+      /**
+       * Instance method: Quick completion using this client instance.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Complete text response
+       */
+      async complete(prompt, options) {
+        return complete(this, prompt, options);
+      }
+      /**
+       * Instance method: Quick streaming using this client instance.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Async generator yielding text chunks
+       */
+      streamText(prompt, options) {
+        return stream(this, prompt, options);
+      }
+      /**
+       * Create a fluent agent builder.
+       * Provides a chainable API for configuring and creating agents.
+       *
+       * @returns AgentBuilder instance for chaining
+       *
+       * @example
+       * ```typescript
+       * const agent = LLMist.createAgent()
+       *   .withModel("sonnet")
+       *   .withSystem("You are a helpful assistant")
+       *   .withGadgets(Calculator, Weather)
+       *   .ask("What's the weather in Paris?");
+       *
+       * for await (const event of agent.run()) {
+       *   // handle events
+       * }
+       * ```
+       *
+       * @example
+       * ```typescript
+       * // Quick one-liner for simple queries
+       * const answer = await LLMist.createAgent()
+       *   .withModel("gpt4-mini")
+       *   .askAndCollect("What is 2+2?");
+       * ```
+       */
+      static createAgent() {
+        return new AgentBuilder();
+      }
+      /**
+       * Create agent builder with this client instance.
+       * Useful when you want to reuse a configured client.
+       *
+       * @returns AgentBuilder instance using this client
+       *
+       * @example
+       * ```typescript
+       * const client = new LLMist({ ... });
+       *
+       * const agent = client.createAgent()
+       *   .withModel("sonnet")
+       *   .ask("Hello");
+       * ```
+       */
+      createAgent() {
+        return new AgentBuilder(this);
+      }
+    };
+  }
+});
+
+// src/gadgets/gadget.ts
+import * as yaml2 from "js-yaml";
+
+// src/gadgets/schema-to-json.ts
+init_logger();
+import * as z2 from "zod";
+function schemaToJSONSchema(schema, options) {
+  const jsonSchema = z2.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, path) {
+    if (!zodSchema || typeof zodSchema !== "object") return;
+    const def = zodSchema._def;
+    const jsonObj = json;
+    if (def?.description && !jsonObj?.description) {
+      mismatches.push(path || "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, path ? `${path}.${key}` : key);
+      }
+    }
+    if (def?.typeName === "ZodArray" && def?.type) {
+      checkSchema(def.type, jsonObj?.items, path ? `${path}[]` : "[]");
+    }
+    if ((def?.typeName === "ZodOptional" || def?.typeName === "ZodNullable") && def?.innerType) {
+      checkSchema(def.innerType, json, path);
+    }
+    if (def?.typeName === "ZodDefault" && def?.innerType) {
+      checkSchema(def.innerType, json, path);
+    }
+  }
+  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);
+}
+
+// src/gadgets/gadget.ts
+init_schema_validator();
+var BaseGadget = 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;
+  /**
+   * Auto-generated instruction text for the LLM.
+   * Combines name, description, and parameter schema into a formatted instruction.
+   * @deprecated Use getInstruction(format) instead for format-specific schemas
+   */
+  get instruction() {
+    return this.getInstruction("yaml");
+  }
+  /**
+   * Generate instruction text for the LLM with format-specific schema.
+   * Combines name, description, and parameter schema into a formatted instruction.
+   *
+   * @param format - Format for the schema representation ('json' | 'yaml' | 'auto')
+   * @returns Formatted instruction string
+   */
+  getInstruction(format = "json") {
+    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"
+      });
+      if (format === "json" || format === "auto") {
+        parts.push("\n\nInput Schema (JSON):");
+        parts.push(JSON.stringify(jsonSchema, null, 2));
+      } else {
+        const yamlSchema = yaml2.dump(jsonSchema).trimEnd();
+        parts.push("\n\nInput Schema (YAML):");
+        parts.push(yamlSchema);
+      }
+    }
+    return parts.join("\n");
+  }
+};
+
+export {
+  MODEL_ALIASES,
+  resolveModel,
+  hasProviderPrefix,
+  getProvider,
+  getModelId,
+  init_model_shortcuts,
+  GadgetRegistry,
+  init_registry,
+  GADGET_START_PREFIX,
+  GADGET_END_PREFIX,
+  init_constants,
+  DEFAULT_PROMPTS,
+  resolvePromptTemplate,
+  resolveRulesTemplate,
+  init_prompt_config,
+  LLMMessageBuilder,
+  init_messages,
+  createLogger,
+  defaultLogger,
+  init_logger,
+  ConversationManager,
+  init_conversation_manager,
+  runWithHandlers,
+  collectEvents,
+  collectText,
+  init_event_handlers,
+  BreakLoopException,
+  HumanInputException,
+  init_exceptions,
+  GadgetExecutor,
+  init_executor,
+  StreamParser,
+  init_parser,
+  StreamProcessor,
+  init_stream_processor,
+  FALLBACK_CHARS_PER_TOKEN,
+  init_constants2,
+  AnthropicMessagesProvider,
+  createAnthropicProviderFromEnv,
+  init_anthropic,
+  GeminiGenerativeProvider,
+  createGeminiProviderFromEnv,
+  init_gemini,
+  OpenAIChatProvider,
+  createOpenAIProviderFromEnv,
+  init_openai,
+  discoverProviderAdapters,
+  init_discovery,
+  ModelRegistry,
+  init_model_registry,
+  ModelIdentifierParser,
+  init_options,
+  complete,
+  stream,
+  init_quick_methods,
+  LLMist,
+  init_client,
+  AgentBuilder,
+  init_builder,
+  BaseGadget
+};
+//# sourceMappingURL=chunk-TP7HE3MN.js.map