nuabase 2.3.4 → 2.3.5

package/dist/cjs/index.cjs

@@ -1,96 +1,33 @@
 'use strict';
 
+var logger = require('./chunks/logger-Co5uZG0A.cjs');
 var zod = require('zod');
 
 var dist = {};
 
 var nuaLlmClient = {};
 
-var logger = {};
-
-var hasRequiredLogger;
-function requireLogger() {
-  if (hasRequiredLogger) return logger;
-  hasRequiredLogger = 1;
-  Object.defineProperty(logger, "__esModule", { value: true });
-  logger.logLlmCallError = logger.logLlmCallComplete = logger.logLlmCallStart = logger.generateSpanId = logger.ConsoleLogger = void 0;
-  logger.pickHeaders = pickHeaders;
-  logger.normalizeError = normalizeError;
-  class ConsoleLogger {
-    debug(message, context) {
-      console.debug(`[DEBUG] ${message}`, context || "");
-    }
-    info(message, context) {
-      console.info(`[INFO] ${message}`, context || "");
-    }
-    warn(message, context) {
-      console.warn(`[WARN] ${message}`, context || "");
-    }
-    error(message, context) {
-      console.error(`[ERROR] ${message}`, context || "");
-    }
-  }
-  logger.ConsoleLogger = ConsoleLogger;
-  const generateSpanId = () => crypto.randomUUID();
-  logger.generateSpanId = generateSpanId;
-  function pickHeaders(headers, allowlist, redactSet) {
-    const result = {};
-    for (const [key, value] of Object.entries(headers)) {
-      const lowerKey = key.toLowerCase();
-      if (redactSet?.has(lowerKey)) {
-        result[key] = "[REDACTED]";
-      } else if (allowlist.has(lowerKey)) {
-        result[key] = Array.isArray(value) ? value.join(", ") : value ?? "";
-      }
-    }
-    return result;
-  }
-  function normalizeError(error) {
-    return error instanceof Error ? { message: error.message, stack: error.stack } : String(error);
-  }
-  const LLM_RESPONSE_HEADER_ALLOWLIST = /* @__PURE__ */ new Set([
-    "x-request-id",
-    "x-ratelimit-limit-requests",
-    "x-ratelimit-limit-tokens",
-    "x-ratelimit-remaining-requests",
-    "x-ratelimit-remaining-tokens",
-    "x-groq-region"
-  ]);
-  const logLlmCallStart = (logger2, spanId, service, method, request) => {
-    logger2.info("LLM call started", {
-      type: "llm_call_start",
-      span_id: spanId,
-      service,
-      method,
-      ...request
-    });
+var nuaErrors = {};
+
+var hasRequiredNuaErrors;
+function requireNuaErrors() {
+  if (hasRequiredNuaErrors) return nuaErrors;
+  hasRequiredNuaErrors = 1;
+  Object.defineProperty(nuaErrors, "__esModule", { value: true });
+  nuaErrors.isNuaError = nuaErrors.isNuaInternalError = nuaErrors.isNuaValidationError = void 0;
+  const isNuaValidationError = (a) => {
+    return typeof a == "object" && a != null && "kind" in a && a.kind == "validation-error";
   };
-  logger.logLlmCallStart = logLlmCallStart;
-  const logLlmCallComplete = (logger2, spanId, service, method, response, duration) => {
-    const { headers, ...rest } = response;
-    logger2.info("LLM call completed", {
-      type: "llm_call_complete",
-      span_id: spanId,
-      service,
-      method,
-      ...rest,
-      ...pickHeaders(headers, LLM_RESPONSE_HEADER_ALLOWLIST),
-      duration_ms: duration
-    });
+  nuaErrors.isNuaValidationError = isNuaValidationError;
+  const isNuaInternalError = (a) => {
+    return typeof a == "object" && a != null && "kind" in a && a.kind == "internal-error";
   };
-  logger.logLlmCallComplete = logLlmCallComplete;
-  const logLlmCallError = (logger2, spanId, service, method, error, duration) => {
-    logger2.error("LLM call failed", {
-      type: "llm_call_error",
-      span_id: spanId,
-      service,
-      method,
-      error: normalizeError(error),
-      duration_ms: duration
-    });
+  nuaErrors.isNuaInternalError = isNuaInternalError;
+  const isNuaError = (a) => {
+    return typeof a == "object" && a != null && "kind" in a && (a.kind == "internal-error" || a.kind == "validation-error");
   };
-  logger.logLlmCallError = logLlmCallError;
-  return logger;
+  nuaErrors.isNuaError = isNuaError;
+  return nuaErrors;
 }
 
 var validateMappableInputData = {};
@@ -133,7 +70,7 @@ function requireValidateMappableInputData() {
   return validateMappableInputData;
 }
 
-var callLlmService = {};
+var runCast = {};
 
 var llmResponseExtraction = {};
 
@@ -242,60 +179,6 @@ function requireLlmResponseExtraction() {
   return llmResponseExtraction;
 }
 
-var hasRequiredCallLlmService;
-function requireCallLlmService() {
-  if (hasRequiredCallLlmService) return callLlmService;
-  hasRequiredCallLlmService = 1;
-  Object.defineProperty(callLlmService, "__esModule", { value: true });
-  callLlmService.callLLM = callLLM;
-  const llm_response_extraction_1 = requireLlmResponseExtraction();
-  const delay = (ms) => {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  };
-  async function callLLM(llmClient, prompt, model, maxTokens, temperature, maxRetries, validationFunction) {
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        const providerResponse = await llmClient.sendRequest(prompt, model, maxTokens);
-        const response = providerResponse.text;
-        let parsedResponse;
-        try {
-          const { cleanedResponse } = (0, llm_response_extraction_1.extractThinkingFromResponse)(response);
-          parsedResponse = (0, llm_response_extraction_1.parseJsonFromLlmResponse)(cleanedResponse);
-        } catch (parseError) {
-          const errorMessage2 = `Failed to parse LLM response as JSON: ${parseError instanceof Error ? parseError.message : "Unknown parsing error"}`;
-          throw new Error(`${errorMessage2}
-
-Raw LLM response:
-${response}`);
-        }
-        const validationResult = validationFunction(parsedResponse);
-        if (validationResult.success && validationResult.data) {
-          return {
-            data: validationResult.data,
-            usage: providerResponse.usage
-          };
-        }
-        const errorMessage = `Validation failed: ${validationResult.error || "Unknown validation error"}`;
-        throw new Error(`${errorMessage}
-
-Raw LLM response:
-${response}`);
-      } catch (error) {
-        const isLastAttempt = attempt === maxRetries;
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        if (isLastAttempt) {
-          throw new Error(`LLM call failed after ${maxRetries} attempts. Last error: ${errorMessage}`);
-        }
-        const backoffDelay = Math.pow(2, attempt - 1) * 1e3;
-        console.warn(`LLM call attempt ${attempt} failed: ${errorMessage}. Retrying in ${backoffDelay}ms...`);
-        await delay(backoffDelay);
-      }
-    }
-    throw new Error("Unexpected error: retry loop completed without success or failure");
-  }
-  return callLlmService;
-}
-
 var nuaJsonSchemaValueValidation = {};
 
 var ajvInstances = {};
@@ -9497,7 +9380,418 @@ function requireNuaJsonSchemaValueValidation() {
   return nuaJsonSchemaValueValidation;
 }
 
-var httpLlmClient = {};
+var envelope = {};
+
+var hasRequiredEnvelope;
+function requireEnvelope() {
+  if (hasRequiredEnvelope) return envelope;
+  hasRequiredEnvelope = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.ENVELOPE_KEY = void 0;
+    exports$1.wrapInEnvelope = wrapInEnvelope;
+    exports$1.unwrapEnvelope = unwrapEnvelope;
+    exports$1.ENVELOPE_KEY = "value";
+    function wrapInEnvelope(schema) {
+      return {
+        type: "object",
+        properties: { [exports$1.ENVELOPE_KEY]: withoutSchemaKeyword(schema) },
+        required: [exports$1.ENVELOPE_KEY],
+        additionalProperties: false
+      };
+    }
+    function unwrapEnvelope(envelope2) {
+      if (typeof envelope2 !== "object" || envelope2 === null || !(exports$1.ENVELOPE_KEY in envelope2)) {
+        return { found: false };
+      }
+      return { found: true, value: envelope2[exports$1.ENVELOPE_KEY] };
+    }
+    const SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+      "items",
+      "additionalItems",
+      "prefixItems",
+      "contains",
+      "additionalProperties",
+      "propertyNames",
+      "unevaluatedItems",
+      "unevaluatedProperties",
+      "not",
+      "if",
+      "then",
+      "else",
+      "allOf",
+      "anyOf",
+      "oneOf"
+    ]);
+    const SUBSCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+      "properties",
+      "patternProperties",
+      "dependentSchemas",
+      "dependencies",
+      "$defs",
+      "definitions"
+    ]);
+    function withoutSchemaKeyword(schema) {
+      const result = {};
+      for (const [keyword, value] of Object.entries(schema)) {
+        if (keyword === "$schema")
+          continue;
+        if (SUBSCHEMA_KEYWORDS.has(keyword)) {
+          result[keyword] = Array.isArray(value) ? value.map(subschema) : subschema(value);
+        } else if (SUBSCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+          result[keyword] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, subschema(child)]));
+        } else {
+          result[keyword] = value;
+        }
+      }
+      return result;
+    }
+    function subschema(value) {
+      return isObject(value) ? withoutSchemaKeyword(value) : value;
+    }
+    function isObject(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+  })(envelope);
+  return envelope;
+}
+
+var renderPrompt = {};
+
+var listPrompt = {};
+
+var promptTemplateUtils = {};
+
+var hasRequiredPromptTemplateUtils;
+function requirePromptTemplateUtils() {
+  if (hasRequiredPromptTemplateUtils) return promptTemplateUtils;
+  hasRequiredPromptTemplateUtils = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.replaceTemplateVarName = exports$1.templateVarName = void 0;
+    const templateVarName = (varName) => `<<{${varName}}>>`;
+    exports$1.templateVarName = templateVarName;
+    const replaceTemplateVarName = (str, varName, value) => str.replaceAll((0, exports$1.templateVarName)(varName), value);
+    exports$1.replaceTemplateVarName = replaceTemplateVarName;
+  })(promptTemplateUtils);
+  return promptTemplateUtils;
+}
+
+var hasRequiredListPrompt;
+function requireListPrompt() {
+  if (hasRequiredListPrompt) return listPrompt;
+  hasRequiredListPrompt = 1;
+  Object.defineProperty(listPrompt, "__esModule", { value: true });
+  listPrompt.renderListPrompt = renderListPrompt;
+  const prompt_template_utils_1 = requirePromptTemplateUtils();
+  const envelope_1 = requireEnvelope();
+  const DESCRIBE_OUTPUT = [
+    `Your task is to transform the provided <input-data> into a JSON array, that represents a list of`,
+    `${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}. The schema for this JSON array is defined below in <json-schema-spec> for you reference.`,
+    `It uses the JSON Schema spec.`
+  ];
+  const MATCH_PRIMARY_KEYS = [
+    `Note that the primary key of each element in the input-data is '${(0, prompt_template_utils_1.templateVarName)("PRIMARY_KEY")}'. In the output JSON array,`,
+    `each object should have the same key with the same value of the original data, so we can map the input element against the output element.`
+  ];
+  const SYSTEM_PROMPTS = {
+    "in-prompt": [
+      ...DESCRIBE_OUTPUT,
+      `Respond with only the instance, not the schema. It should not be wrapped in any wrapper object -- return exactly what the JSON schema is expecting.`,
+      `Your entire response should be just the value of the JSON array containing objects with '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}'`,
+      `and its primary key '${(0, prompt_template_utils_1.templateVarName)("PRIMARY_KEY")}', as valid JSON.`,
+      `We will validate the result with the AJV Node library, using ajv.parse, against the JSON schema, and we expect it to validate correctly.`,
+      ...MATCH_PRIMARY_KEYS
+    ].join(" "),
+    native: [
+      ...DESCRIBE_OUTPUT,
+      `Respond with only the instance, not the schema. Your reply is enforced by a JSON schema that wraps the result in an object:`,
+      `put the JSON array, containing objects with '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}' and its primary key '${(0, prompt_template_utils_1.templateVarName)("PRIMARY_KEY")}', in its "${envelope_1.ENVELOPE_KEY}" field.`,
+      `We will validate the "${envelope_1.ENVELOPE_KEY}" field with the AJV Node library against the JSON schema, and we expect it to validate correctly.`,
+      ...MATCH_PRIMARY_KEYS
+    ].join(" ")
+  };
+  function renderListPrompt(cast, enforcement) {
+    const withPrimaryKey = (0, prompt_template_utils_1.replaceTemplateVarName)(SYSTEM_PROMPTS[enforcement], "PRIMARY_KEY", cast.primaryKey);
+    const system = (0, prompt_template_utils_1.replaceTemplateVarName)(withPrimaryKey, "OUTPUT_TYPE_NAME", cast.outputName);
+    const full = [
+      cast.prompt || "Transform the provided data according to the schema.",
+      system,
+      `<json-schema-spec> ${JSON.stringify(cast.schema)} </json-schema-spec>`,
+      `<input-data>${JSON.stringify(cast.rows)}</input-data>`
+    ].join("\n");
+    return { system, full };
+  }
+  return listPrompt;
+}
+
+var valuePrompt = {};
+
+var hasRequiredValuePrompt;
+function requireValuePrompt() {
+  if (hasRequiredValuePrompt) return valuePrompt;
+  hasRequiredValuePrompt = 1;
+  Object.defineProperty(valuePrompt, "__esModule", { value: true });
+  valuePrompt.renderValuePrompt = renderValuePrompt;
+  const prompt_template_utils_1 = requirePromptTemplateUtils();
+  const envelope_1 = requireEnvelope();
+  const DESCRIBE_OUTPUT = [
+    `Please respond with a single JSON object that represents '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}'.`,
+    `The schema for this object (which uses the JSON Schema spec), is defined below for your reference.`,
+    `Your task is to create an instance of this object. Respond with only the instance, not the schema.`
+  ];
+  const SYSTEM_PROMPTS = {
+    "in-prompt": [
+      ...DESCRIBE_OUTPUT,
+      `Your entire response should be just the value of '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}', as valid JSON.`,
+      `And it should not be wrapped in any wrapper object -- return exactly what the JSON schema is expecting.`,
+      `We will validate the result with the AJV Node library, using ajv.parse, against the given schema, and we expect`,
+      `it to validate correctly.`,
+      `IMPORTANT: Output raw JSON only. No markdown code fences, no explanation, no commentary, no extra fields beyond the schema. Do not correct yourself -- produce the right answer on the first try.`
+    ].join(" "),
+    native: [
+      ...DESCRIBE_OUTPUT,
+      `Your reply is enforced by a JSON schema that wraps the result in an object:`,
+      `put the value of '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}' in its "${envelope_1.ENVELOPE_KEY}" field.`,
+      `We will validate the "${envelope_1.ENVELOPE_KEY}" field with the AJV Node library against the schema below, and we expect`,
+      `it to validate correctly.`
+    ].join(" ")
+  };
+  function renderValuePrompt(cast, enforcement) {
+    const system = (0, prompt_template_utils_1.replaceTemplateVarName)(SYSTEM_PROMPTS[enforcement], "OUTPUT_TYPE_NAME", cast.outputName);
+    const full = [
+      cast.prompt || "Transform the provided data according to the schema.",
+      system,
+      `<json-schema-spec> ${JSON.stringify(cast.schema)} </json-schema-spec>`,
+      cast.data ? `<input-data>${JSON.stringify(cast.data)}</input-data>` : ""
+    ].join("\n");
+    return { system, full };
+  }
+  return valuePrompt;
+}
+
+var hasRequiredRenderPrompt;
+function requireRenderPrompt() {
+  if (hasRequiredRenderPrompt) return renderPrompt;
+  hasRequiredRenderPrompt = 1;
+  Object.defineProperty(renderPrompt, "__esModule", { value: true });
+  renderPrompt.renderPrompt = renderPrompt$1;
+  const list_prompt_1 = requireListPrompt();
+  const value_prompt_1 = requireValuePrompt();
+  function renderPrompt$1(cast, enforcement) {
+    switch (cast.kind) {
+      case "value":
+        return (0, value_prompt_1.renderValuePrompt)(cast, enforcement);
+      case "list":
+        return (0, list_prompt_1.renderListPrompt)(cast, enforcement);
+    }
+  }
+  return renderPrompt;
+}
+
+var hasRequiredRunCast;
+function requireRunCast() {
+  if (hasRequiredRunCast) return runCast;
+  hasRequiredRunCast = 1;
+  Object.defineProperty(runCast, "__esModule", { value: true });
+  runCast.runCast = runCast$1;
+  runCast.judgeOutcome = judgeOutcome;
+  const llm_response_extraction_1 = requireLlmResponseExtraction();
+  const nua_json_schema_value_validation_1 = requireNuaJsonSchemaValueValidation();
+  const envelope_1 = requireEnvelope();
+  const render_prompt_1 = requireRenderPrompt();
+  const RETRY_DELAYS_MS = [1e3, 2e3];
+  const MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
+  async function runCast$1(engine, request, logger) {
+    let validate;
+    try {
+      validate = (0, nua_json_schema_value_validation_1.buildNuaJsonSchemaValueValidation)("library-req", request.schema);
+    } catch (error) {
+      return { success: false, error: `Invalid output schema: ${errorMessage(error)}` };
+    }
+    let plan = planAttempt(request, chooseEnforcement(engine, request.schema));
+    let lastFailure = { error: "", prompt: plan.prompt };
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      const outcome = await engine.attempt({
+        prompt: plan.prompt.full,
+        maxTokens: request.maxTokens,
+        enforcement: plan.enforcement
+      });
+      const verdict = judgeOutcome(outcome, validate);
+      if (verdict.kind === "accept") {
+        return {
+          success: true,
+          data: verdict.data,
+          usage: verdict.usage,
+          prompt: plan.prompt,
+          origin: verdict.origin,
+          schemaEnforcement: plan.enforcement.kind
+        };
+      }
+      if (verdict.kind === "give-up") {
+        return { success: false, error: verdict.error, prompt: plan.prompt };
+      }
+      lastFailure = { error: verdict.error, prompt: plan.prompt };
+      if (verdict.kind === "retry-in-prompt") {
+        logger.warn("Engine rejected the native output schema; retrying with the schema in the prompt", {
+          attempt,
+          error: verdict.error
+        });
+        plan = planAttempt(request, { kind: "in-prompt" });
+        continue;
+      }
+      if (attempt < MAX_ATTEMPTS) {
+        const delayMs = RETRY_DELAYS_MS[attempt - 1];
+        logger.warn("LLM call attempt failed; retrying", { attempt, delayMs, error: verdict.error });
+        await delay(delayMs);
+      }
+    }
+    return {
+      success: false,
+      error: `LLM call failed after ${MAX_ATTEMPTS} attempts. Last error: ${lastFailure.error}`,
+      prompt: lastFailure.prompt
+    };
+  }
+  function chooseEnforcement(engine, schema) {
+    const nativeSchema = engine.nativeSchema((0, envelope_1.wrapInEnvelope)(schema));
+    return nativeSchema ? { kind: "native", schema: nativeSchema } : { kind: "in-prompt" };
+  }
+  function planAttempt(request, enforcement) {
+    return { enforcement, prompt: (0, render_prompt_1.renderPrompt)(request, enforcement.kind) };
+  }
+  function judgeOutcome(outcome, validate) {
+    if (outcome.kind === "failed") {
+      return verdictForFailure(outcome.failure);
+    }
+    const candidate = readAnswer(outcome.answer);
+    if (!candidate.ok) {
+      return { kind: "retry", error: candidate.error };
+    }
+    const validation = validate(candidate.value);
+    if (!validation.success) {
+      return {
+        kind: "retry",
+        error: `Validation failed: ${validation.error || "Unknown validation error"}
+
+Raw LLM response:
+${candidate.raw}`
+      };
+    }
+    return { kind: "accept", data: candidate.value, usage: outcome.usage, origin: outcome.origin };
+  }
+  function verdictForFailure(failure) {
+    switch (failure.kind) {
+      case "transient":
+        return { kind: "retry", error: failure.message };
+      case "schema-rejected":
+        return { kind: "retry-in-prompt", error: failure.message };
+      case "fatal":
+        return { kind: "give-up", error: failure.message };
+    }
+  }
+  function readAnswer(answer) {
+    switch (answer.kind) {
+      case "text":
+        return readTextAnswer(answer.text);
+      case "structured":
+        return readStructuredAnswer(answer.envelope);
+    }
+  }
+  function readTextAnswer(text) {
+    try {
+      const { cleanedResponse } = (0, llm_response_extraction_1.extractThinkingFromResponse)(text);
+      return { ok: true, value: (0, llm_response_extraction_1.parseJsonFromLlmResponse)(cleanedResponse), raw: text };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to parse LLM response as JSON: ${errorMessage(error)}
+
+Raw LLM response:
+${text}`
+      };
+    }
+  }
+  function readStructuredAnswer(envelope) {
+    const raw = JSON.stringify(envelope);
+    const unwrapped = (0, envelope_1.unwrapEnvelope)(envelope);
+    if (!unwrapped.found) {
+      return { ok: false, error: `Structured output has no "${envelope_1.ENVELOPE_KEY}" field: ${raw}` };
+    }
+    return { ok: true, value: unwrapped.value, raw };
+  }
+  function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  return runCast;
+}
+
+var hasRequiredNuaLlmClient;
+function requireNuaLlmClient() {
+  if (hasRequiredNuaLlmClient) return nuaLlmClient;
+  hasRequiredNuaLlmClient = 1;
+  Object.defineProperty(nuaLlmClient, "__esModule", { value: true });
+  nuaLlmClient.NuaLlmClient = void 0;
+  const nua_errors_1 = requireNuaErrors();
+  const validate_mappable_input_data_1 = requireValidateMappableInputData();
+  const run_cast_1 = requireRunCast();
+  const DEFAULT_MAX_TOKENS = 4096;
+  class NuaLlmClient {
+    constructor(engines) {
+      this.engines = engines;
+    }
+    async castValue(params) {
+      const route = this.engines.route(params.model);
+      if (route.kind === "unroutable") {
+        return { success: false, error: route.message };
+      }
+      const request = {
+        kind: "value",
+        prompt: params.input.prompt,
+        data: params.input.data,
+        outputName: params.output.name,
+        schema: params.output.schema,
+        maxTokens: params.maxTokens ?? DEFAULT_MAX_TOKENS
+      };
+      return (0, run_cast_1.runCast)(route.engine, request, this.engines.logger);
+    }
+    async castArray(params) {
+      const { primaryKey, outputName, jsonSchema } = params.output;
+      const rows = (0, validate_mappable_input_data_1.validateMappableInputData)(params.input.data, primaryKey);
+      if ((0, nua_errors_1.isNuaValidationError)(rows)) {
+        return { success: false, error: rows.message };
+      }
+      const route = this.engines.route(params.model);
+      if (route.kind === "unroutable") {
+        return { success: false, error: route.message };
+      }
+      const request = {
+        kind: "list",
+        prompt: params.input.prompt,
+        rows,
+        primaryKey,
+        outputName,
+        schema: jsonSchema,
+        maxTokens: params.maxTokens ?? DEFAULT_MAX_TOKENS
+      };
+      return (0, run_cast_1.runCast)(route.engine, request, this.engines.logger);
+    }
+  }
+  nuaLlmClient.NuaLlmClient = NuaLlmClient;
+  return nuaLlmClient;
+}
+
+var types = {};
+
+var hasRequiredTypes;
+function requireTypes() {
+  if (hasRequiredTypes) return types;
+  hasRequiredTypes = 1;
+  Object.defineProperty(types, "__esModule", { value: true });
+  return types;
+}
 
 var providerConfig = {};
 
@@ -9716,346 +10010,433 @@ function requireProviderConfig() {
   return providerConfig;
 }
 
-var providerFormatters = {};
-
-var sseParser = {};
+var providerEngines = {};
 
-var hasRequiredSseParser;
-function requireSseParser() {
-  if (hasRequiredSseParser) return sseParser;
-  hasRequiredSseParser = 1;
-  Object.defineProperty(sseParser, "__esModule", { value: true });
-  sseParser.parseSSEStream = parseSSEStream;
-  async function* parseSSEStream(stream) {
-    const reader = stream.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        buffer += decoder.decode(value, { stream: true });
-        const parts = buffer.split(/\r?\n\r?\n/);
-        buffer = parts.pop();
-        for (const part of parts) {
-          for (const line of part.split(/\r?\n/)) {
-            if (line.startsWith("data: ")) {
-              const data = line.slice(6);
-              if (data === "[DONE]") {
-                return;
-              }
-              yield data;
-            }
-          }
-        }
-      }
-      if (buffer.trim()) {
-        for (const line of buffer.split(/\r?\n/)) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6);
-            if (data === "[DONE]") {
-              return;
-            }
-            yield data;
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  return sseParser;
-}
+var modelInfo = {};
 
-var hasRequiredProviderFormatters;
-function requireProviderFormatters() {
-  if (hasRequiredProviderFormatters) return providerFormatters;
-  hasRequiredProviderFormatters = 1;
-  Object.defineProperty(providerFormatters, "__esModule", { value: true });
-  providerFormatters.buildOpenAiAgenticRequest = buildOpenAiAgenticRequest;
-  providerFormatters.parseOpenAiAgenticResponse = parseOpenAiAgenticResponse;
-  providerFormatters.buildGeminiAgenticRequest = buildGeminiAgenticRequest;
-  providerFormatters.parseGeminiAgenticResponse = parseGeminiAgenticResponse;
-  providerFormatters.streamOpenAiAgenticResponse = streamOpenAiAgenticResponse;
-  providerFormatters.streamGeminiAgenticResponse = streamGeminiAgenticResponse;
-  const provider_config_1 = requireProviderConfig();
-  const sse_parser_1 = requireSseParser();
-  function convertMessagesToOpenAi(messages, systemPrompt) {
-    const result = [];
-    if (systemPrompt) {
-      result.push({ role: "system", content: systemPrompt });
+var hasRequiredModelInfo;
+function requireModelInfo() {
+  if (hasRequiredModelInfo) return modelInfo;
+  hasRequiredModelInfo = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.MODEL_ALIAS_NAMES = exports$1.MODEL_ALIASES = void 0;
+    exports$1.isLlmProviderId = isLlmProviderId;
+    exports$1.isModelAliasName = isModelAliasName;
+    exports$1.resolveModelInput = resolveModelInput;
+    const provider_config_1 = requireProviderConfig();
+    exports$1.MODEL_ALIASES = {
+      fast: [
+        { provider: "cerebras", model: "qwen-3.8-27b" },
+        { provider: "groq", model: "qwen/qwen3.8-27b" },
+        { provider: "openrouter", model: "z-ai/glm-5.2" }
+      ],
+      gemini: [
+        { provider: "gemini", model: "gemini-2.5-flash" },
+        { provider: "openrouter", model: "google/gemini-2.5-flash" }
+      ],
+      qwen: [
+        { provider: "openrouter", model: "qwen/qwen3-vl-235b-a22b-instruct" }
+      ],
+      sonnet: [
+        { provider: "openrouter", model: "anthropic/claude-sonnet-4.6" }
+      ],
+      opus: [
+        { provider: "openrouter", model: "anthropic/claude-opus-4.7" }
+      ],
+      haiku: [
+        { provider: "openrouter", model: "anthropic/claude-haiku-4.5" }
+      ],
+      kimi: [
+        { provider: "openrouter", model: "moonshotai/kimi-k2.7-code" }
+      ],
+      gpt: [
+        { provider: "openrouter", model: "openai/gpt-5" }
+      ]
+    };
+    exports$1.MODEL_ALIAS_NAMES = Object.keys(exports$1.MODEL_ALIASES);
+    const MODEL_ALIAS_SET = new Set(exports$1.MODEL_ALIAS_NAMES);
+    const LLM_PROVIDER_ID_SET = new Set(provider_config_1.LLM_PROVIDER_IDS);
+    function isLlmProviderId(value) {
+      return typeof value === "string" && LLM_PROVIDER_ID_SET.has(value);
     }
-    for (const msg of messages) {
-      switch (msg.role) {
-        case "user":
-          result.push({ role: "user", content: msg.content });
-          break;
-        case "assistant": {
-          const textParts = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-          const toolCalls = msg.content.filter((c) => c.type === "toolCall").map((c) => ({
-            id: c.id,
-            type: "function",
-            function: {
-              name: c.name,
-              arguments: JSON.stringify(c.arguments)
-            }
-          }));
-          const openAiMsg = {
-            role: "assistant",
-            content: textParts || null,
-            ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
-          };
-          result.push(openAiMsg);
-          break;
-        }
-        case "toolResult":
-          result.push({
-            role: "tool",
-            tool_call_id: msg.toolCallId,
-            content: msg.content
-          });
-          break;
+    function isModelAliasName(value) {
+      return typeof value === "string" && MODEL_ALIAS_SET.has(value);
+    }
+    function validationError(message) {
+      return {
+        kind: "validation-error",
+        message
+      };
+    }
+    function validateProviderModel(input, configuredProviders) {
+      if (!isLlmProviderId(input.provider)) {
+        return validationError(`Invalid LLM provider: ${String(input.provider)}`);
+      }
+      if (!configuredProviders.has(input.provider)) {
+        return validationError(`LLM provider ${input.provider} is not configured. Please check your API keys.`);
+      }
+      if (typeof input.model !== "string") {
+        return validationError("model.model must be a string");
+      }
+      const model = input.model.trim();
+      if (!model) {
+        return validationError("model.model must be a non-empty string");
+      }
+      if (input.provider === "gemini" && model.startsWith("models/")) {
+        return validationError('Gemini model names must use bare model IDs, for example "gemini-2.5-flash", not "models/gemini-2.5-flash".');
       }
+      return {
+        provider: input.provider,
+        model
+      };
     }
-    return result;
-  }
-  function convertToolsToOpenAi(tools) {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters
+    function resolveModelInput(input, configuredProviders) {
+      if (input == null) {
+        return resolveModelInput({ alias: "fast" }, configuredProviders);
       }
-    }));
+      if (typeof input !== "object") {
+        return validationError("model must be an object with either alias or provider/model fields");
+      }
+      if ("provider" in input || "model" in input) {
+        return validateProviderModel(input, configuredProviders);
+      }
+      if ("alias" in input) {
+        const alias = input.alias;
+        if (!isModelAliasName(alias)) {
+          return validationError(`Invalid model alias: ${String(alias)}`);
+        }
+        const configuredTarget = exports$1.MODEL_ALIASES[alias].find((target) => configuredProviders.has(target.provider));
+        if (!configuredTarget) {
+          return validationError(`No configured provider found for model alias ${alias}. Please check your API keys.`);
+        }
+        return configuredTarget;
+      }
+      return validationError("model must include either alias or provider/model fields");
+    }
+  })(modelInfo);
+  return modelInfo;
+}
+
+var httpEngine = {};
+
+var providerCall = {};
+
+var hasRequiredProviderCall;
+function requireProviderCall() {
+  if (hasRequiredProviderCall) return providerCall;
+  hasRequiredProviderCall = 1;
+  Object.defineProperty(providerCall, "__esModule", { value: true });
+  providerCall.callProvider = callProvider;
+  const logger_1 = logger.requireLogger();
+  const provider_config_1 = requireProviderConfig();
+  async function callProvider(call, logger) {
+    const { target, apiOperation, request } = call;
+    const method = request.method ?? "POST";
+    const spanId = (0, logger_1.generateSpanId)();
+    const startTime = Date.now();
+    let status;
+    (0, logger_1.logLlmCallStart)(logger, spanId, target.provider, apiOperation, {
+      url: request.loggableUrl ?? request.url,
+      httpMethod: method,
+      model: target.model,
+      maxTokens: call.maxTokens
+    });
+    try {
+      const response = await fetch(request.url, {
+        method,
+        headers: request.headers ?? {},
+        body: toFetchableBody(request.body)
+      });
+      status = response.status;
+      const reply = await call.parseResponse(response);
+      (0, logger_1.logLlmCallComplete)(logger, spanId, target.provider, apiOperation, {
+        status: response.status,
+        responseLength: call.responseLength(reply),
+        headers: Object.fromEntries(response.headers.entries()),
+        usage: call.usage(reply)
+      }, Date.now() - startTime);
+      return { kind: "ok", reply };
+    } catch (error) {
+      (0, logger_1.logLlmCallError)(logger, spanId, target.provider, apiOperation, error, Date.now() - startTime);
+      return {
+        kind: "failed",
+        status,
+        message: `${provider_config_1.providerConfigs[target.provider].errorLabel} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
   }
-  function buildOpenAiAgenticRequest(options, baseUrl, apiKey) {
-    const messages = convertMessagesToOpenAi(options.messages, options.systemPrompt);
-    const tools = convertToolsToOpenAi(options.tools);
-    const body = {
-      messages,
-      tools: tools.length > 0 ? tools : void 0,
-      model: options.model,
-      max_completion_tokens: options.maxTokens,
-      stream: options.stream ?? false
-    };
-    if (options.stream) {
-      body.stream_options = { include_usage: true };
+  function toFetchableBody(body) {
+    if (typeof body === "string" || body === void 0) {
+      return body;
     }
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    return {
-      url: baseUrl,
-      method: "POST",
-      headers,
-      body,
-      loggableHeaders: {
-        ...headers,
-        Authorization: "Bearer [REDACTED]"
-      },
-      loggableBody: body
-    };
+    return JSON.stringify(body);
   }
-  function parseOpenAiToolArguments(rawArguments, toolName, errorLabel) {
-    if (!rawArguments.trim()) {
-      return {};
+  return providerCall;
+}
+
+var hasRequiredHttpEngine;
+function requireHttpEngine() {
+  if (hasRequiredHttpEngine) return httpEngine;
+  hasRequiredHttpEngine = 1;
+  Object.defineProperty(httpEngine, "__esModule", { value: true });
+  httpEngine.HttpEngine = void 0;
+  const provider_call_1 = requireProviderCall();
+  const provider_config_1 = requireProviderConfig();
+  const FATAL_HTTP_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
+  class HttpEngine {
+    constructor(target, logger) {
+      this.target = target;
+      this.logger = logger;
     }
-    let parsed;
-    try {
-      parsed = JSON.parse(rawArguments);
-    } catch {
-      const preview = rawArguments.length > 500 ? rawArguments.slice(0, 500) + "..." : rawArguments;
-      throw new Error(`${errorLabel} API error: Invalid JSON arguments for tool "${toolName}": ${preview}`);
+    /** Provider APIs are given the schema in the prompt; none is enforced natively yet. */
+    nativeSchema() {
+      return null;
     }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error(`${errorLabel} API error: Tool "${toolName}" arguments must be a JSON object`);
+    async attempt(request) {
+      const { provider, model, apiKey } = this.target;
+      const config = provider_config_1.providerConfigs[provider];
+      const call = await (0, provider_call_1.callProvider)({
+        target: this.target,
+        apiOperation: config.apiOperation,
+        maxTokens: request.maxTokens,
+        request: config.buildRequest({ prompt: request.prompt, model, maxTokens: request.maxTokens }, apiKey),
+        parseResponse: config.parseResponse,
+        responseLength: (reply) => reply.text.length,
+        usage: (reply) => reply.usage
+      }, this.logger);
+      if (call.kind === "failed") {
+        return { kind: "failed", failure: failureForStatus(call.status, call.message) };
+      }
+      return {
+        kind: "answered",
+        answer: { kind: "text", text: call.reply.text },
+        usage: call.reply.usage,
+        origin: { engine: "http", provider, model }
+      };
     }
-    return parsed;
   }
-  async function parseOpenAiAgenticResponse(response, errorLabel) {
-    if (response.status !== 200) {
-      const errorBody = await response.text();
-      try {
-        const parsed = JSON.parse(errorBody);
-        const message = parsed?.error?.message || errorBody;
-        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
-      } catch (e) {
-        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
-          throw e;
-        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+  httpEngine.HttpEngine = HttpEngine;
+  function failureForStatus(status, message) {
+    const fatal = status !== void 0 && FATAL_HTTP_STATUSES.has(status);
+    return { kind: fatal ? "fatal" : "transient", message };
+  }
+  return httpEngine;
+}
+
+var hasRequiredProviderEngines;
+function requireProviderEngines() {
+  if (hasRequiredProviderEngines) return providerEngines;
+  hasRequiredProviderEngines = 1;
+  Object.defineProperty(providerEngines, "__esModule", { value: true });
+  providerEngines.ProviderEngines = void 0;
+  providerEngines.providerEngines = providerEngines$1;
+  const logger_1 = logger.requireLogger();
+  const nua_errors_1 = requireNuaErrors();
+  const model_info_1 = requireModelInfo();
+  const http_engine_1 = requireHttpEngine();
+  function providerEngines$1(config) {
+    return new ProviderEngines(config);
+  }
+  class ProviderEngines {
+    constructor(config) {
+      this.logger = config.logger ?? new logger_1.ConsoleLogger();
+      this.defaultModel = config.model;
+      const apiKeys = /* @__PURE__ */ new Map();
+      for (const [id, provider] of Object.entries(config.providers)) {
+        if (provider?.apiKey) {
+          apiKeys.set(id, provider.apiKey);
+        }
       }
+      this.apiKeys = apiKeys;
     }
-    const responseBody = await response.json();
-    const choice = responseBody.choices?.[0];
-    if (!choice?.message) {
-      throw new Error(`${errorLabel} API error: No message in response. Body: ${JSON.stringify(responseBody)}`);
-    }
-    const contentBlocks = [];
-    const assistantText = (0, provider_config_1.extractOpenAiMessageText)(choice.message);
-    if (assistantText) {
-      contentBlocks.push({
-        type: "text",
-        text: assistantText
-      });
+    route(model) {
+      const resolved = this.resolve(model);
+      if (resolved.kind === "unroutable") {
+        return resolved;
+      }
+      return { kind: "routed", engine: new http_engine_1.HttpEngine(resolved.target, this.logger) };
     }
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        contentBlocks.push({
-          type: "toolCall",
-          id: tc.id,
-          name: tc.function.name,
-          arguments: parseOpenAiToolArguments(tc.function.arguments, tc.function.name, errorLabel)
-        });
+    /** The provider model, with its API key, that a model choice runs on. */
+    resolve(model) {
+      const providerModel = (0, model_info_1.resolveModelInput)(model ?? this.defaultModel, new Set(this.apiKeys.keys()));
+      if ((0, nua_errors_1.isNuaValidationError)(providerModel)) {
+        return { kind: "unroutable", message: providerModel.message };
       }
+      const apiKey = this.apiKeys.get(providerModel.provider);
+      if (apiKey === void 0) {
+        return { kind: "unroutable", message: `LLM provider ${providerModel.provider} is not configured.` };
+      }
+      return { kind: "resolved", target: { ...providerModel, apiKey } };
     }
-    const usage = (0, provider_config_1.normalizeOpenAiUsage)(responseBody.usage);
-    const stopReason = choice.finish_reason === "tool_calls" || choice.finish_reason === "stop" ? choice.finish_reason === "tool_calls" ? "tool_use" : "stop" : choice.message.tool_calls && choice.message.tool_calls.length > 0 ? "tool_use" : "stop";
-    return {
-      message: {
-        role: "assistant",
-        content: contentBlocks
-      },
-      usage,
-      stopReason
-    };
   }
-  function convertMessagesToGemini(messages) {
-    const result = [];
-    for (const msg of messages) {
-      switch (msg.role) {
-        case "user":
-          result.push({
-            role: "user",
-            parts: [{ text: msg.content }]
-          });
-          break;
-        case "assistant": {
-          const parts = [];
-          for (const block of msg.content) {
-            if (block.type === "text") {
-              parts.push({ text: block.text });
-            } else if (block.type === "toolCall") {
-              parts.push({
-                functionCall: {
-                  name: block.name,
-                  args: block.arguments
-                }
-              });
-            }
-          }
-          result.push({ role: "model", parts });
-          break;
-        }
-        case "toolResult": {
-          result.push({
-            role: "user",
-            parts: [
-              {
-                functionResponse: {
-                  name: msg.toolName,
-                  response: { content: msg.content }
-                }
-              }
-            ]
-          });
-          break;
-        }
-      }
-    }
-    return result;
-  }
-  function convertToolsToGemini(tools) {
-    if (tools.length === 0)
-      return [];
-    return [
-      {
-        functionDeclarations: tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        }))
-      }
-    ];
+  providerEngines.ProviderEngines = ProviderEngines;
+  return providerEngines;
+}
+
+var validateJsonSchema = {};
+
+var errorUtils = {};
+
+var hasRequiredErrorUtils;
+function requireErrorUtils() {
+  if (hasRequiredErrorUtils) return errorUtils;
+  hasRequiredErrorUtils = 1;
+  Object.defineProperty(errorUtils, "__esModule", { value: true });
+  errorUtils.getErrorMessageFromException = getErrorMessageFromException;
+  function isErrorWithMessage(error) {
+    return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
   }
-  function buildGeminiAgenticRequest(options, apiKey) {
-    const contents = convertMessagesToGemini(options.messages);
-    const tools = convertToolsToGemini(options.tools);
-    const body = {
-      contents,
-      generationConfig: {
-        maxOutputTokens: options.maxTokens
-      }
-    };
-    if (tools.length > 0) {
-      body.tools = tools;
+  function getErrorMessageFromException(error) {
+    if (isErrorWithMessage(error)) {
+      return error.message;
     }
-    if (options.systemPrompt) {
-      body.systemInstruction = {
-        parts: [{ text: options.systemPrompt }]
+    return String(error);
+  }
+  return errorUtils;
+}
+
+var hasRequiredValidateJsonSchema;
+function requireValidateJsonSchema() {
+  if (hasRequiredValidateJsonSchema) return validateJsonSchema;
+  hasRequiredValidateJsonSchema = 1;
+  Object.defineProperty(validateJsonSchema, "__esModule", { value: true });
+  validateJsonSchema.validateJsonSchema = void 0;
+  const error_utils_1 = requireErrorUtils();
+  const ajv_instances_1 = requireAjvInstances();
+  const validateJsonSchema$1 = (schema) => {
+    if (!schema || typeof schema !== "object") {
+      return {
+        kind: "validation-error",
+        message: "Schema must be a valid object"
       };
     }
-    const action = options.stream ? "streamGenerateContent" : "generateContent";
-    const altParam = options.stream ? "&alt=sse" : "";
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${options.model}:${action}?key=${apiKey}${altParam}`;
-    return {
-      url,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body,
-      loggableUrl: url.replace(/key=[^&]+/, "key=[REDACTED]"),
-      loggableBody: body
-    };
-  }
-  async function parseGeminiAgenticResponse(response) {
-    if (response.status !== 200) {
-      const errorBody = await response.text();
+    const ajvInstance = ajv_instances_1.ajvInstances.getInstanceForSchema(schema);
+    const isValidSchema = ajvInstance.validateSchema(schema);
+    let errors = "";
+    if (ajvInstance.errors) {
+      errors = ajvInstance.errors.map((e) => JSON.stringify(e, null, 2)).join("; ");
+    } else if (isValidSchema) {
       try {
-        const parsed = JSON.parse(errorBody);
-        const message = parsed?.error?.message || errorBody;
-        throw new Error(`Gemini API error: ${response.status} - ${message}`);
+        ajvInstance.compile(schema);
+        return true;
       } catch (e) {
-        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
-          throw e;
-        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+        errors = (0, error_utils_1.getErrorMessageFromException)(e);
       }
+    } else {
+      errors = "unexpected-situation-no-errors-found-for-invalid-schema";
     }
-    const responseBody = await response.json();
-    const candidate = responseBody.candidates?.[0];
-    if (!candidate?.content?.parts) {
-      throw new Error(`Gemini API error: No content in response. Body: ${JSON.stringify(responseBody)}`);
-    }
-    const contentBlocks = [];
-    let hasToolCalls = false;
-    for (const part of candidate.content.parts) {
-      if (part.text) {
-        contentBlocks.push({ type: "text", text: part.text });
+    return {
+      kind: "validation-error",
+      message: `Unable to validate JSON schema: ${errors}`
+    };
+  };
+  validateJsonSchema.validateJsonSchema = validateJsonSchema$1;
+  return validateJsonSchema;
+}
+
+var stableStringify = {};
+
+var hasRequiredStableStringify;
+function requireStableStringify() {
+  if (hasRequiredStableStringify) return stableStringify;
+  hasRequiredStableStringify = 1;
+  Object.defineProperty(stableStringify, "__esModule", { value: true });
+  stableStringify.stableStringify = stableStringify$1;
+  function stableStringify$1(value) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const sorter = (_key, currentValue) => {
+      if (currentValue && typeof currentValue === "object" && !Array.isArray(currentValue)) {
+        if (seen.has(currentValue)) {
+          return currentValue;
+        }
+        seen.add(currentValue);
+        return Object.keys(currentValue).sort().reduce((acc, key) => {
+          acc[key] = currentValue[key];
+          return acc;
+        }, {});
       }
-      if (part.functionCall) {
-        hasToolCalls = true;
-        contentBlocks.push({
-          type: "toolCall",
-          id: crypto.randomUUID(),
-          name: part.functionCall.name,
-          arguments: part.functionCall.args
-        });
+      return currentValue;
+    };
+    return JSON.stringify(value, sorter) ?? "";
+  }
+  return stableStringify;
+}
+
+var schemaUtils = {};
+
+var hasRequiredSchemaUtils;
+function requireSchemaUtils() {
+  if (hasRequiredSchemaUtils) return schemaUtils;
+  hasRequiredSchemaUtils = 1;
+  Object.defineProperty(schemaUtils, "__esModule", { value: true });
+  return schemaUtils;
+}
+
+var listSchema = {};
+
+var hasRequiredListSchema;
+function requireListSchema() {
+  if (hasRequiredListSchema) return listSchema;
+  hasRequiredListSchema = 1;
+  Object.defineProperty(listSchema, "__esModule", { value: true });
+  listSchema.listSchema = listSchema$1;
+  listSchema.parseListSchema = parseListSchema;
+  function listSchema$1(itemSchema, keys) {
+    const jsonSchema = {
+      type: "array",
+      items: {
+        type: "object",
+        required: [keys.primaryKey, keys.outputName],
+        properties: {
+          [keys.primaryKey]: {
+            anyOf: [{ type: "string" }, { type: "number" }, { type: "integer" }]
+          },
+          [keys.outputName]: itemSchema
+        }
       }
+    };
+    if (typeof itemSchema.$schema === "string") {
+      jsonSchema.$schema = itemSchema.$schema;
+    }
+    return brand(keys, jsonSchema);
+  }
+  function parseListSchema(jsonSchema, keys) {
+    if (isObject(jsonSchema) && jsonSchema.type === "array" && rowsHoldKeys(jsonSchema.items, keys)) {
+      return brand(keys, jsonSchema);
     }
-    const usage = (0, provider_config_1.normalizeGeminiUsage)(responseBody.usageMetadata);
-    const stopReason = hasToolCalls ? "tool_use" : "stop";
     return {
-      message: {
-        role: "assistant",
-        content: contentBlocks
-      },
-      usage,
-      stopReason
+      kind: "validation-error",
+      message: `Not a list schema with rows keyed by "${keys.primaryKey}" holding "${keys.outputName}"`
     };
   }
+  function rowsHoldKeys(items, keys) {
+    if (!isObject(items) || !isObject(items.properties) || !Array.isArray(items.required)) {
+      return false;
+    }
+    const { properties, required } = items;
+    return [keys.primaryKey, keys.outputName].every((key) => key in properties && required.includes(key));
+  }
+  function brand(keys, jsonSchema) {
+    return { primaryKey: keys.primaryKey, outputName: keys.outputName, jsonSchema };
+  }
+  function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return listSchema;
+}
+
+var runAgent = {};
+
+var agentLoop = {};
+
+var hasRequiredAgentLoop;
+function requireAgentLoop() {
+  if (hasRequiredAgentLoop) return agentLoop;
+  hasRequiredAgentLoop = 1;
+  Object.defineProperty(agentLoop, "__esModule", { value: true });
+  agentLoop.runAgentLoop = runAgentLoop;
+  const provider_config_1 = requireProviderConfig();
   function safeEmit(onEvent, event) {
     if (!onEvent)
       return;
@@ -10064,946 +10445,713 @@ function requireProviderFormatters() {
     } catch {
     }
   }
-  async function streamOpenAiAgenticResponse(response, errorLabel, onEvent) {
-    if (response.status !== 200) {
-      const errorBody = await response.text();
+  async function runAgentLoop(params) {
+    const messages = [...params.messages];
+    let totalUsage = { ...provider_config_1.normalizedUsageZero };
+    const toolsByName = new Map(params.tools.map((tool) => [tool.name, tool]));
+    let completionReason = "max_turns";
+    const onEvent = params.onEvent;
+    for (let turn = 0; turn < params.maxTurns; turn++) {
+      safeEmit(onEvent, { type: "turn_start", turn });
+      let response;
       try {
-        const parsed = JSON.parse(errorBody);
-        const message = parsed?.error?.message || errorBody;
-        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
-      } catch (e) {
-        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
-          throw e;
-        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+        response = await params.sendRequest(messages, params.tools, params.systemPrompt);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        safeEmit(onEvent, { type: "error", error: errorMessage });
+        return buildAgentResult(messages, totalUsage, "error", errorMessage);
       }
-    }
-    if (!response.body) {
-      throw new Error(`${errorLabel} API error: Response body is null`);
-    }
-    let textContent = "";
-    const toolCallAccumulators = /* @__PURE__ */ new Map();
-    let finishReason = null;
-    let usage = { ...provider_config_1.normalizedUsageZero };
-    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
-      let chunk;
-      try {
-        chunk = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      if (chunk.usage) {
-        usage = (0, provider_config_1.normalizeOpenAiUsage)(chunk.usage);
-      }
-      const choice = chunk.choices?.[0];
-      if (!choice)
-        continue;
-      if (choice.finish_reason) {
-        finishReason = choice.finish_reason;
-      }
-      const delta = choice.delta;
-      if (!delta)
-        continue;
-      if (delta.content) {
-        textContent += delta.content;
-        safeEmit(onEvent, { type: "text_delta", text: delta.content });
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const existing = toolCallAccumulators.get(tc.index);
-          if (existing) {
-            if (tc.function?.arguments) {
-              existing.arguments += tc.function.arguments;
-            }
-          } else {
-            toolCallAccumulators.set(tc.index, {
-              id: tc.id ?? "",
-              name: tc.function?.name ?? "",
-              arguments: tc.function?.arguments ?? ""
-            });
-          }
-        }
-      }
-    }
-    const contentBlocks = [];
-    if (textContent) {
-      contentBlocks.push({ type: "text", text: textContent });
-    }
-    const sortedToolCalls = [...toolCallAccumulators.entries()].sort(([a], [b]) => a - b);
-    for (const [, tc] of sortedToolCalls) {
-      contentBlocks.push({
-        type: "toolCall",
-        id: tc.id,
-        name: tc.name,
-        arguments: parseOpenAiToolArguments(tc.arguments, tc.name, errorLabel)
+      messages.push(response.message);
+      totalUsage = addUsage(totalUsage, response.usage);
+      safeEmit(onEvent, {
+        type: "response_complete",
+        message: response.message,
+        usage: response.usage,
+        stopReason: response.stopReason
       });
-    }
-    const stopReason2 = finishReason === "tool_calls" || sortedToolCalls.length > 0 ? "tool_use" : "stop";
-    return {
-      message: { role: "assistant", content: contentBlocks },
-      usage,
-      stopReason: stopReason2
-    };
-  }
-  async function streamGeminiAgenticResponse(response, onEvent) {
-    if (response.status !== 200) {
-      const errorBody = await response.text();
-      try {
-        const parsed = JSON.parse(errorBody);
-        const message = parsed?.error?.message || errorBody;
-        throw new Error(`Gemini API error: ${response.status} - ${message}`);
-      } catch (e) {
-        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
-          throw e;
-        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
-      }
-    }
-    if (!response.body) {
-      throw new Error("Gemini API error: Response body is null");
-    }
-    const contentBlocks = [];
-    let hasToolCalls2 = false;
-    let textContent2 = "";
-    let usage2 = { ...provider_config_1.normalizedUsageZero };
-    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
-      let chunk;
-      try {
-        chunk = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      if (chunk.usageMetadata) {
-        usage2 = (0, provider_config_1.normalizeGeminiUsage)(chunk.usageMetadata);
+      const toolCalls = response.message.content.filter((c) => c.type === "toolCall");
+      if (toolCalls.length === 0 || response.stopReason === "stop") {
+        completionReason = "stop";
+        return buildAgentResult(messages, totalUsage, completionReason);
       }
-      const candidate = chunk.candidates?.[0];
-      if (!candidate?.content?.parts)
-        continue;
-      for (const part of candidate.content.parts) {
-        if (part.text) {
-          textContent2 += part.text;
-          safeEmit(onEvent, { type: "text_delta", text: part.text });
+      for (const toolCall of toolCalls) {
+        safeEmit(onEvent, {
+          type: "tool_start",
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          arguments: toolCall.arguments
+        });
+        const tool = toolsByName.get(toolCall.name);
+        if (!tool) {
+          const result = {
+            content: `Tool "${toolCall.name}" not found`,
+            isError: true
+          };
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: result.content,
+            isError: true
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
+          });
+          continue;
         }
-        if (part.functionCall) {
-          hasToolCalls2 = true;
-          contentBlocks.push({
-            type: "toolCall",
-            id: crypto.randomUUID(),
-            name: part.functionCall.name,
-            arguments: part.functionCall.args
+        try {
+          const result = await tool.execute(toolCall.arguments);
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: result.content,
+            isError: result.isError ?? false
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
+          });
+        } catch (error) {
+          const errorContent = `Tool execution error: ${error instanceof Error ? error.message : "Unknown error"}`;
+          const result = { content: errorContent, isError: true };
+          messages.push({
+            role: "toolResult",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: errorContent,
+            isError: true
+          });
+          safeEmit(onEvent, {
+            type: "tool_complete",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result
           });
         }
       }
     }
-    if (textContent2) {
-      contentBlocks.unshift({ type: "text", text: textContent2 });
+    return buildAgentResult(messages, totalUsage, completionReason, `Reached maxTurns limit (${params.maxTurns}) before receiving a final response`);
+  }
+  function addUsage(a, b) {
+    return {
+      promptTokens: a.promptTokens + b.promptTokens,
+      completionTokens: a.completionTokens + b.completionTokens,
+      totalTokens: a.totalTokens + b.totalTokens
+    };
+  }
+  function extractLastAssistantText(messages) {
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    if (lastAssistant?.role !== "assistant") {
+      return void 0;
     }
-    const stopReason3 = hasToolCalls2 ? "tool_use" : "stop";
+    const text = lastAssistant.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    return text || void 0;
+  }
+  function buildAgentResult(messages, usage, completionReason, error) {
+    const success = completionReason === "stop" && !error;
     return {
-      message: { role: "assistant", content: contentBlocks },
-      usage: usage2,
-      stopReason: stopReason3
+      success,
+      completionReason,
+      messages,
+      textResponse: extractLastAssistantText(messages),
+      usage,
+      error
     };
   }
-  return providerFormatters;
+  return agentLoop;
 }
 
-var hasRequiredHttpLlmClient;
-function requireHttpLlmClient() {
-  if (hasRequiredHttpLlmClient) return httpLlmClient;
-  hasRequiredHttpLlmClient = 1;
-  Object.defineProperty(httpLlmClient, "__esModule", { value: true });
-  httpLlmClient.HttpLlmClient = void 0;
-  const logger_1 = requireLogger();
-  const provider_config_1 = requireProviderConfig();
-  const provider_formatters_1 = requireProviderFormatters();
-  class HttpLlmClient {
-    constructor(providerId, apiKey, logger) {
-      this.providerId = providerId;
-      this.apiKey = apiKey;
-      this.logger = logger;
-    }
-    async sendRequest(prompt, model, maxTokens, assistantPrefillPrompt) {
-      const provider = this.getProviderConfig();
-      const requestOptions = provider.buildRequest({
-        prompt,
-        model,
-        maxTokens,
-        assistantPrefillPrompt
-      }, this.apiKey);
-      return this.executeProviderCall({
-        provider,
-        model,
-        maxTokens,
-        apiOperation: provider.apiOperation,
-        requestOptions,
-        parseResponse: provider.parseResponse,
-        getResponseLength: (parsedResponse) => parsedResponse.text.length,
-        getUsage: (parsedResponse) => parsedResponse.usage
-      });
-    }
-    async sendAgenticRequest(messages, tools, model, maxTokens, systemPrompt, onEvent) {
-      const provider = this.getProviderConfig();
-      const codec = this.getAgenticProviderCodec(provider.errorLabel);
-      const requestOptions = codec.buildRequest({
-        messages,
-        tools,
-        model,
-        maxTokens,
-        systemPrompt,
-        stream: !!onEvent
-      });
-      const parseResponse = onEvent ? (response) => codec.parseStreamingResponse(response, onEvent) : codec.parseResponse;
-      return this.executeProviderCall({
-        provider,
-        model,
-        maxTokens,
-        apiOperation: "agentic",
-        requestOptions,
-        parseResponse,
-        getResponseLength: (parsedResponse) => parsedResponse.message.content.reduce((total, content) => total + (content.type === "text" ? content.text.length : 0), 0),
-        getUsage: (parsedResponse) => parsedResponse.usage
-      });
-    }
-    getProviderConfig() {
-      const provider = provider_config_1.providerConfigs[this.providerId];
-      if (!provider) {
-        throw new Error(`Unknown LLM provider: ${this.providerId}`);
-      }
-      return provider;
-    }
-    async executeProviderCall(params) {
-      const method = params.requestOptions.method ?? "POST";
-      const headers = params.requestOptions.headers ?? {};
-      const body = this.toFetchableBody(params.requestOptions.body);
-      const spanId = (0, logger_1.generateSpanId)();
-      const startTime = Date.now();
-      (0, logger_1.logLlmCallStart)(this.logger, spanId, params.provider.providerId, params.apiOperation, {
-        url: params.requestOptions.loggableUrl ?? params.requestOptions.url,
-        httpMethod: method,
-        model: params.model,
-        maxTokens: params.maxTokens
-      });
-      try {
-        const response = await fetch(params.requestOptions.url, {
-          method,
-          headers,
-          body
-        });
-        const parsedResponse = await params.parseResponse(response);
-        const duration = Date.now() - startTime;
-        (0, logger_1.logLlmCallComplete)(this.logger, spanId, params.provider.providerId, params.apiOperation, {
-          status: response.status,
-          responseLength: params.getResponseLength(parsedResponse),
-          headers: Object.fromEntries(response.headers.entries()),
-          usage: params.getUsage(parsedResponse)
-        }, duration);
-        return parsedResponse;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        (0, logger_1.logLlmCallError)(this.logger, spanId, params.provider.providerId, params.apiOperation, error, duration);
-        throw new Error(`${params.provider.errorLabel} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    }
-    toFetchableBody(bodyPayload) {
-      if (typeof bodyPayload === "string") {
-        return bodyPayload;
-      }
-      if (bodyPayload === void 0) {
-        return void 0;
+var agentTurn = {};
+
+var providerFormatters = {};
+
+var sseParser = {};
+
+var hasRequiredSseParser;
+function requireSseParser() {
+  if (hasRequiredSseParser) return sseParser;
+  hasRequiredSseParser = 1;
+  Object.defineProperty(sseParser, "__esModule", { value: true });
+  sseParser.parseSSEStream = parseSSEStream;
+  async function* parseSSEStream(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop();
+        for (const part of parts) {
+          for (const line of part.split(/\r?\n/)) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") {
+                return;
+              }
+              yield data;
+            }
+          }
+        }
       }
-      return JSON.stringify(bodyPayload);
-    }
-    getAgenticProviderCodec(errorLabel) {
-      switch (this.providerId) {
-        case "groq":
-          return {
-            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://api.groq.com/openai/v1/chat/completions", this.apiKey),
-            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
-            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
-          };
-        case "cerebras":
-          return {
-            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://api.cerebras.ai/v1/chat/completions", this.apiKey),
-            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
-            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
-          };
-        case "openrouter":
-          return {
-            buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, "https://openrouter.ai/api/v1/chat/completions", this.apiKey),
-            parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
-            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
-          };
-        case "gemini":
-          return {
-            buildRequest: (options) => (0, provider_formatters_1.buildGeminiAgenticRequest)(options, this.apiKey),
-            parseResponse: provider_formatters_1.parseGeminiAgenticResponse,
-            parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamGeminiAgenticResponse)(response, onEvent)
-          };
-        default:
-          throw new Error(`Unsupported provider for agentic requests: ${this.providerId}`);
+      if (buffer.trim()) {
+        for (const line of buffer.split(/\r?\n/)) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              return;
+            }
+            yield data;
+          }
+        }
       }
+    } finally {
+      reader.releaseLock();
     }
   }
-  httpLlmClient.HttpLlmClient = HttpLlmClient;
-  return httpLlmClient;
+  return sseParser;
 }
 
-var modelInfo = {};
-
-var hasRequiredModelInfo;
-function requireModelInfo() {
-  if (hasRequiredModelInfo) return modelInfo;
-  hasRequiredModelInfo = 1;
-  (function(exports$1) {
-    Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.MODEL_ALIAS_NAMES = exports$1.MODEL_ALIASES = void 0;
-    exports$1.isLlmProviderId = isLlmProviderId;
-    exports$1.isModelAliasName = isModelAliasName;
-    exports$1.resolveModelInput = resolveModelInput;
-    const provider_config_1 = requireProviderConfig();
-    exports$1.MODEL_ALIASES = {
-      fast: [
-        { provider: "cerebras", model: "gpt-oss-120b" },
-        { provider: "groq", model: "openai/gpt-oss-120b" },
-        { provider: "openrouter", model: "openai/gpt-oss-120b" }
-      ],
-      gemini: [
-        { provider: "gemini", model: "gemini-2.5-flash" },
-        { provider: "openrouter", model: "google/gemini-2.5-flash" }
-      ],
-      qwen: [
-        { provider: "openrouter", model: "qwen/qwen3-vl-235b-a22b-instruct" }
-      ],
-      sonnet: [
-        { provider: "openrouter", model: "anthropic/claude-sonnet-4.6" }
-      ],
-      opus: [
-        { provider: "openrouter", model: "anthropic/claude-opus-4.7" }
-      ],
-      haiku: [
-        { provider: "openrouter", model: "anthropic/claude-haiku-4.5" }
-      ],
-      kimi: [
-        { provider: "openrouter", model: "moonshotai/kimi-k2.6" }
-      ],
-      gpt: [
-        { provider: "openrouter", model: "openai/gpt-5" }
-      ]
-    };
-    exports$1.MODEL_ALIAS_NAMES = Object.keys(exports$1.MODEL_ALIASES);
-    const MODEL_ALIAS_SET = new Set(exports$1.MODEL_ALIAS_NAMES);
-    const LLM_PROVIDER_ID_SET = new Set(provider_config_1.LLM_PROVIDER_IDS);
-    function isLlmProviderId(value) {
-      return typeof value === "string" && LLM_PROVIDER_ID_SET.has(value);
-    }
-    function isModelAliasName(value) {
-      return typeof value === "string" && MODEL_ALIAS_SET.has(value);
-    }
-    function validationError(message) {
-      return {
-        kind: "validation-error",
-        message
-      };
-    }
-    function validateProviderModel(input, configuredProviders) {
-      if (!isLlmProviderId(input.provider)) {
-        return validationError(`Invalid LLM provider: ${String(input.provider)}`);
-      }
-      if (!configuredProviders.has(input.provider)) {
-        return validationError(`LLM provider ${input.provider} is not configured. Please check your API keys.`);
-      }
-      if (typeof input.model !== "string") {
-        return validationError("model.model must be a string");
-      }
-      const model = input.model.trim();
-      if (!model) {
-        return validationError("model.model must be a non-empty string");
-      }
-      if (input.provider === "gemini" && model.startsWith("models/")) {
-        return validationError('Gemini model names must use bare model IDs, for example "gemini-2.5-flash", not "models/gemini-2.5-flash".');
-      }
-      return {
-        provider: input.provider,
-        model
-      };
-    }
-    function resolveModelInput(input, configuredProviders) {
-      if (input == null) {
-        return resolveModelInput({ alias: "fast" }, configuredProviders);
-      }
-      if (typeof input !== "object") {
-        return validationError("model must be an object with either alias or provider/model fields");
-      }
-      if ("provider" in input || "model" in input) {
-        return validateProviderModel(input, configuredProviders);
-      }
-      if ("alias" in input) {
-        const alias = input.alias;
-        if (!isModelAliasName(alias)) {
-          return validationError(`Invalid model alias: ${String(alias)}`);
-        }
-        const configuredTarget = exports$1.MODEL_ALIASES[alias].find((target) => configuredProviders.has(target.provider));
-        if (!configuredTarget) {
-          return validationError(`No configured provider found for model alias ${alias}. Please check your API keys.`);
+var hasRequiredProviderFormatters;
+function requireProviderFormatters() {
+  if (hasRequiredProviderFormatters) return providerFormatters;
+  hasRequiredProviderFormatters = 1;
+  Object.defineProperty(providerFormatters, "__esModule", { value: true });
+  providerFormatters.buildOpenAiAgenticRequest = buildOpenAiAgenticRequest;
+  providerFormatters.parseOpenAiAgenticResponse = parseOpenAiAgenticResponse;
+  providerFormatters.buildGeminiAgenticRequest = buildGeminiAgenticRequest;
+  providerFormatters.parseGeminiAgenticResponse = parseGeminiAgenticResponse;
+  providerFormatters.streamOpenAiAgenticResponse = streamOpenAiAgenticResponse;
+  providerFormatters.streamGeminiAgenticResponse = streamGeminiAgenticResponse;
+  const provider_config_1 = requireProviderConfig();
+  const sse_parser_1 = requireSseParser();
+  function convertMessagesToOpenAi(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({ role: "system", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "user":
+          result.push({ role: "user", content: msg.content });
+          break;
+        case "assistant": {
+          const textParts = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+          const toolCalls = msg.content.filter((c) => c.type === "toolCall").map((c) => ({
+            id: c.id,
+            type: "function",
+            function: {
+              name: c.name,
+              arguments: JSON.stringify(c.arguments)
+            }
+          }));
+          const openAiMsg = {
+            role: "assistant",
+            content: textParts || null,
+            ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+          };
+          result.push(openAiMsg);
+          break;
         }
-        return configuredTarget;
+        case "toolResult":
+          result.push({
+            role: "tool",
+            tool_call_id: msg.toolCallId,
+            content: msg.content
+          });
+          break;
       }
-      return validationError("model must include either alias or provider/model fields");
     }
-  })(modelInfo);
-  return modelInfo;
-}
-
-var castArrayPromptBuilder = {};
-
-var promptTemplateUtils = {};
-
-var hasRequiredPromptTemplateUtils;
-function requirePromptTemplateUtils() {
-  if (hasRequiredPromptTemplateUtils) return promptTemplateUtils;
-  hasRequiredPromptTemplateUtils = 1;
-  (function(exports$1) {
-    Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.replaceTemplateVarName = exports$1.templateVarName = void 0;
-    const templateVarName = (varName) => `<<{${varName}}>>`;
-    exports$1.templateVarName = templateVarName;
-    const replaceTemplateVarName = (str, varName, value) => str.replaceAll((0, exports$1.templateVarName)(varName), value);
-    exports$1.replaceTemplateVarName = replaceTemplateVarName;
-  })(promptTemplateUtils);
-  return promptTemplateUtils;
-}
-
-var hasRequiredCastArrayPromptBuilder;
-function requireCastArrayPromptBuilder() {
-  if (hasRequiredCastArrayPromptBuilder) return castArrayPromptBuilder;
-  hasRequiredCastArrayPromptBuilder = 1;
-  Object.defineProperty(castArrayPromptBuilder, "__esModule", { value: true });
-  const prompt_template_utils_1 = requirePromptTemplateUtils();
-  const builder = () => {
-    const BASE_SYSTEM_PROMPT_WHEN_OUTPUT_TYPE_NAME_PROVIDED = [
-      `Your task is to transform the provided <input-data> into a JSON array, that represents a list of`,
-      `${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}. The schema for this JSON array is defined below in <json-schema-spec> for you reference.`,
-      `It uses the JSON Schema spec.`,
-      `Respond with only the instance, not the schema. It should not be wrapped in any wrapper object -- return exactly what the JSON schema is expecting.`,
-      `Your entire response should be just the value of the JSON array containing objects with '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}'`,
-      `and its primary key '${(0, prompt_template_utils_1.templateVarName)("PRIMARY_KEY")}', as valid JSON.`,
-      `We will validate the result with the AJV Node library, using ajv.parse, against the JSON schema, and we expect it to validate correctly.`,
-      `Note that the primary key of each element in the input-data is '${(0, prompt_template_utils_1.templateVarName)("PRIMARY_KEY")}'. In the output JSON array,`,
-      `each object should have the same key with the same value of the original data, so we can map the input element against the output element.`
-    ].join(" ");
-    const buildSystemPrompt = (primaryKey, outputName) => {
-      let a = BASE_SYSTEM_PROMPT_WHEN_OUTPUT_TYPE_NAME_PROVIDED;
-      a = (0, prompt_template_utils_1.replaceTemplateVarName)(a, "PRIMARY_KEY", primaryKey);
-      a = (0, prompt_template_utils_1.replaceTemplateVarName)(a, "OUTPUT_TYPE_NAME", outputName);
-      return a;
-    };
-    const buildFullPrompt = (req, uncachedInputDataRows) => {
-      const prompt = req.input.prompt;
-      const fullPrompt = [
-        prompt || "Transform the provided data according to the schema.",
-        // user prompt
-        buildSystemPrompt(req.input.primaryKey, req.output.name),
-        `<json-schema-spec> ${JSON.stringify(req.output.effectiveSchema)} </json-schema-spec>`,
-        `<input-data>${JSON.stringify(uncachedInputDataRows)}</input-data>`
-      ].join("\n");
-      return fullPrompt;
-    };
-    return {
-      buildSystemPrompt,
-      buildFullPrompt
-    };
-  };
-  const castArrayPromptBuilder$1 = builder();
-  castArrayPromptBuilder.default = castArrayPromptBuilder$1;
-  return castArrayPromptBuilder;
-}
-
-var castPromptBuilder = {};
-
-var hasRequiredCastPromptBuilder;
-function requireCastPromptBuilder() {
-  if (hasRequiredCastPromptBuilder) return castPromptBuilder;
-  hasRequiredCastPromptBuilder = 1;
-  Object.defineProperty(castPromptBuilder, "__esModule", { value: true });
-  const prompt_template_utils_1 = requirePromptTemplateUtils();
-  const builder = () => {
-    const BASE_SYSTEM_PROMPT_WHEN_OUTPUT_TYPE_NAME_PROVIDED = [
-      `Please respond with a single JSON object that represents '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}'.`,
-      `The schema for this object (which uses the JSON Schema spec), is defined below for your reference.`,
-      `Your task is to create an instance of this object. Respond with only the instance, not the schema.`,
-      `Your entire response should be just the value of '${(0, prompt_template_utils_1.templateVarName)("OUTPUT_TYPE_NAME")}', as valid JSON.`,
-      `And it should not be wrapped in any wrapper object -- return exactly what the JSON schema is expecting.`,
-      `We will validate the result with the AJV Node library, using ajv.parse, against the given schema, and we expect`,
-      `it to validate correctly.`,
-      `IMPORTANT: Output raw JSON only. No markdown code fences, no explanation, no commentary, no extra fields beyond the schema. Do not correct yourself -- produce the right answer on the first try.`
-    ].join(" ");
-    const buildSystemPrompt = (reqParams) => {
-      let a = BASE_SYSTEM_PROMPT_WHEN_OUTPUT_TYPE_NAME_PROVIDED;
-      a = (0, prompt_template_utils_1.replaceTemplateVarName)(a, "OUTPUT_TYPE_NAME", reqParams.output.name);
-      return a;
+    return result;
+  }
+  function convertToolsToOpenAi(tools) {
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    }));
+  }
+  function buildOpenAiAgenticRequest(options, baseUrl, apiKey) {
+    const messages = convertMessagesToOpenAi(options.messages, options.systemPrompt);
+    const tools = convertToolsToOpenAi(options.tools);
+    const body = {
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      model: options.model,
+      max_completion_tokens: options.maxTokens,
+      stream: options.stream ?? false
     };
-    const buildFullPrompt = (reqParams) => {
-      const { prompt, data } = reqParams.input;
-      const { effectiveSchema } = reqParams.output;
-      const fullPrompt = [
-        prompt || "Transform the provided data according to the schema.",
-        // user prompt
-        buildSystemPrompt(reqParams),
-        `<json-schema-spec> ${JSON.stringify(effectiveSchema)} </json-schema-spec>`,
-        data ? `<input-data>${JSON.stringify(data)}</input-data>` : ""
-      ].join("\n");
-      return fullPrompt;
+    if (options.stream) {
+      body.stream_options = { include_usage: true };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
     };
     return {
-      buildSystemPrompt,
-      buildFullPrompt
+      url: baseUrl,
+      method: "POST",
+      headers,
+      body,
+      loggableHeaders: {
+        ...headers,
+        Authorization: "Bearer [REDACTED]"
+      },
+      loggableBody: body
     };
-  };
-  const castPromptBuilder$1 = builder();
-  castPromptBuilder.default = castPromptBuilder$1;
-  return castPromptBuilder;
-}
-
-var nuaErrors = {};
-
-var hasRequiredNuaErrors;
-function requireNuaErrors() {
-  if (hasRequiredNuaErrors) return nuaErrors;
-  hasRequiredNuaErrors = 1;
-  Object.defineProperty(nuaErrors, "__esModule", { value: true });
-  nuaErrors.isNuaError = nuaErrors.isNuaInternalError = nuaErrors.isNuaValidationError = void 0;
-  const isNuaValidationError = (a) => {
-    return typeof a == "object" && a != null && "kind" in a && a.kind == "validation-error";
-  };
-  nuaErrors.isNuaValidationError = isNuaValidationError;
-  const isNuaInternalError = (a) => {
-    return typeof a == "object" && a != null && "kind" in a && a.kind == "internal-error";
-  };
-  nuaErrors.isNuaInternalError = isNuaInternalError;
-  const isNuaError = (a) => {
-    return typeof a == "object" && a != null && "kind" in a && (a.kind == "internal-error" || a.kind == "validation-error");
-  };
-  nuaErrors.isNuaError = isNuaError;
-  return nuaErrors;
-}
-
-var agentLoop = {};
-
-var hasRequiredAgentLoop;
-function requireAgentLoop() {
-  if (hasRequiredAgentLoop) return agentLoop;
-  hasRequiredAgentLoop = 1;
-  Object.defineProperty(agentLoop, "__esModule", { value: true });
-  agentLoop.runAgentLoop = runAgentLoop;
-  const provider_config_1 = requireProviderConfig();
-  function safeEmit(onEvent, event) {
-    if (!onEvent)
-      return;
+  }
+  function parseOpenAiToolArguments(rawArguments, toolName, errorLabel) {
+    if (!rawArguments.trim()) {
+      return {};
+    }
+    let parsed;
     try {
-      onEvent(event);
+      parsed = JSON.parse(rawArguments);
     } catch {
+      const preview = rawArguments.length > 500 ? rawArguments.slice(0, 500) + "..." : rawArguments;
+      throw new Error(`${errorLabel} API error: Invalid JSON arguments for tool "${toolName}": ${preview}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`${errorLabel} API error: Tool "${toolName}" arguments must be a JSON object`);
     }
+    return parsed;
   }
-  async function runAgentLoop(params) {
-    const messages = [...params.messages];
-    let totalUsage = { ...provider_config_1.normalizedUsageZero };
-    const toolsByName = new Map(params.tools.map((tool) => [tool.name, tool]));
-    let completionReason = "max_turns";
-    const onEvent = params.onEvent;
-    for (let turn = 0; turn < params.maxTurns; turn++) {
-      safeEmit(onEvent, { type: "turn_start", turn });
-      let response;
+  async function parseOpenAiAgenticResponse(response, errorLabel) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
       try {
-        response = await params.sendRequest(messages, params.tools, params.systemPrompt);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        safeEmit(onEvent, { type: "error", error: errorMessage });
-        return buildAgentResult(messages, totalUsage, "error", errorMessage);
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
+          throw e;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
       }
-      messages.push(response.message);
-      totalUsage = addUsage(totalUsage, response.usage);
-      safeEmit(onEvent, {
-        type: "response_complete",
-        message: response.message,
-        usage: response.usage,
-        stopReason: response.stopReason
+    }
+    const responseBody = await response.json();
+    const choice = responseBody.choices?.[0];
+    if (!choice?.message) {
+      throw new Error(`${errorLabel} API error: No message in response. Body: ${JSON.stringify(responseBody)}`);
+    }
+    const contentBlocks = [];
+    const assistantText = (0, provider_config_1.extractOpenAiMessageText)(choice.message);
+    if (assistantText) {
+      contentBlocks.push({
+        type: "text",
+        text: assistantText
       });
-      const toolCalls = response.message.content.filter((c) => c.type === "toolCall");
-      if (toolCalls.length === 0 || response.stopReason === "stop") {
-        completionReason = "stop";
-        return buildAgentResult(messages, totalUsage, completionReason);
-      }
-      for (const toolCall of toolCalls) {
-        safeEmit(onEvent, {
-          type: "tool_start",
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          arguments: toolCall.arguments
+    }
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        contentBlocks.push({
+          type: "toolCall",
+          id: tc.id,
+          name: tc.function.name,
+          arguments: parseOpenAiToolArguments(tc.function.arguments, tc.function.name, errorLabel)
         });
-        const tool = toolsByName.get(toolCall.name);
-        if (!tool) {
-          const result = {
-            content: `Tool "${toolCall.name}" not found`,
-            isError: true
-          };
-          messages.push({
-            role: "toolResult",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            content: result.content,
-            isError: true
-          });
-          safeEmit(onEvent, {
-            type: "tool_complete",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            result
+      }
+    }
+    const usage = (0, provider_config_1.normalizeOpenAiUsage)(responseBody.usage);
+    const stopReason = choice.finish_reason === "tool_calls" || choice.finish_reason === "stop" ? choice.finish_reason === "tool_calls" ? "tool_use" : "stop" : choice.message.tool_calls && choice.message.tool_calls.length > 0 ? "tool_use" : "stop";
+    return {
+      message: {
+        role: "assistant",
+        content: contentBlocks
+      },
+      usage,
+      stopReason
+    };
+  }
+  function convertMessagesToGemini(messages) {
+    const result = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "user":
+          result.push({
+            role: "user",
+            parts: [{ text: msg.content }]
           });
-          continue;
+          break;
+        case "assistant": {
+          const parts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              parts.push({ text: block.text });
+            } else if (block.type === "toolCall") {
+              parts.push({
+                functionCall: {
+                  name: block.name,
+                  args: block.arguments
+                }
+              });
+            }
+          }
+          result.push({ role: "model", parts });
+          break;
         }
-        try {
-          const result = await tool.execute(toolCall.arguments);
-          messages.push({
-            role: "toolResult",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            content: result.content,
-            isError: result.isError ?? false
-          });
-          safeEmit(onEvent, {
-            type: "tool_complete",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            result
-          });
-        } catch (error) {
-          const errorContent = `Tool execution error: ${error instanceof Error ? error.message : "Unknown error"}`;
-          const result = { content: errorContent, isError: true };
-          messages.push({
-            role: "toolResult",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            content: errorContent,
-            isError: true
-          });
-          safeEmit(onEvent, {
-            type: "tool_complete",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            result
+        case "toolResult": {
+          result.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: msg.toolName,
+                  response: { content: msg.content }
+                }
+              }
+            ]
           });
+          break;
         }
       }
     }
-    return buildAgentResult(messages, totalUsage, completionReason, `Reached maxTurns limit (${params.maxTurns}) before receiving a final response`);
+    return result;
   }
-  function addUsage(a, b) {
+  function convertToolsToGemini(tools) {
+    if (tools.length === 0)
+      return [];
+    return [
+      {
+        functionDeclarations: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      }
+    ];
+  }
+  function buildGeminiAgenticRequest(options, apiKey) {
+    const contents = convertMessagesToGemini(options.messages);
+    const tools = convertToolsToGemini(options.tools);
+    const body = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens
+      }
+    };
+    if (tools.length > 0) {
+      body.tools = tools;
+    }
+    if (options.systemPrompt) {
+      body.systemInstruction = {
+        parts: [{ text: options.systemPrompt }]
+      };
+    }
+    const action = options.stream ? "streamGenerateContent" : "generateContent";
+    const altParam = options.stream ? "&alt=sse" : "";
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${options.model}:${action}?key=${apiKey}${altParam}`;
     return {
-      promptTokens: a.promptTokens + b.promptTokens,
-      completionTokens: a.completionTokens + b.completionTokens,
-      totalTokens: a.totalTokens + b.totalTokens
+      url,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body,
+      loggableUrl: url.replace(/key=[^&]+/, "key=[REDACTED]"),
+      loggableBody: body
     };
   }
-  function extractLastAssistantText(messages) {
-    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
-    if (lastAssistant?.role !== "assistant") {
-      return void 0;
+  async function parseGeminiAgenticResponse(response) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`Gemini API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
+          throw e;
+        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+      }
     }
-    const text = lastAssistant.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-    return text || void 0;
-  }
-  function buildAgentResult(messages, usage, completionReason, error) {
-    const success = completionReason === "stop" && !error;
+    const responseBody = await response.json();
+    const candidate = responseBody.candidates?.[0];
+    if (!candidate?.content?.parts) {
+      throw new Error(`Gemini API error: No content in response. Body: ${JSON.stringify(responseBody)}`);
+    }
+    const contentBlocks = [];
+    let hasToolCalls = false;
+    for (const part of candidate.content.parts) {
+      if (part.text) {
+        contentBlocks.push({ type: "text", text: part.text });
+      }
+      if (part.functionCall) {
+        hasToolCalls = true;
+        contentBlocks.push({
+          type: "toolCall",
+          id: crypto.randomUUID(),
+          name: part.functionCall.name,
+          arguments: part.functionCall.args
+        });
+      }
+    }
+    const usage = (0, provider_config_1.normalizeGeminiUsage)(responseBody.usageMetadata);
+    const stopReason = hasToolCalls ? "tool_use" : "stop";
     return {
-      success,
-      completionReason,
-      messages,
-      textResponse: extractLastAssistantText(messages),
+      message: {
+        role: "assistant",
+        content: contentBlocks
+      },
       usage,
-      error
+      stopReason
     };
   }
-  return agentLoop;
-}
-
-var hasRequiredNuaLlmClient;
-function requireNuaLlmClient() {
-  if (hasRequiredNuaLlmClient) return nuaLlmClient;
-  hasRequiredNuaLlmClient = 1;
-  var __importDefault = nuaLlmClient && nuaLlmClient.__importDefault || function(mod) {
-    return mod && mod.__esModule ? mod : { "default": mod };
-  };
-  Object.defineProperty(nuaLlmClient, "__esModule", { value: true });
-  nuaLlmClient.NuaLlmClient = void 0;
-  const logger_1 = requireLogger();
-  const validate_mappable_input_data_1 = requireValidateMappableInputData();
-  const call_llm_service_1 = requireCallLlmService();
-  const nua_json_schema_value_validation_1 = requireNuaJsonSchemaValueValidation();
-  const http_llm_client_1 = requireHttpLlmClient();
-  const provider_config_1 = requireProviderConfig();
-  const model_info_1 = requireModelInfo();
-  const cast_array_prompt_builder_1 = __importDefault(requireCastArrayPromptBuilder());
-  const cast_prompt_builder_1 = __importDefault(requireCastPromptBuilder());
-  const nua_errors_1 = requireNuaErrors();
-  const agent_loop_1 = requireAgentLoop();
-  class NuaLlmClient {
-    constructor(config) {
-      this.logger = config.logger || new logger_1.ConsoleLogger();
-      this.clients = /* @__PURE__ */ new Map();
-      Object.entries(config.providers).forEach(([providerId, providerConfig]) => {
-        if (providerConfig?.apiKey) {
-          this.clients.set(providerId, new http_llm_client_1.HttpLlmClient(providerId, providerConfig.apiKey, this.logger));
-        }
-      });
+  function safeEmit(onEvent, event) {
+    if (!onEvent)
+      return;
+    try {
+      onEvent(event);
+    } catch {
+    }
+  }
+  async function streamOpenAiAgenticResponse(response, errorLabel, onEvent) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
+      try {
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith(`${errorLabel} API error:`))
+          throw e;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+      }
     }
-    getConfiguredProviderIds() {
-      return new Set(this.clients.keys());
+    if (!response.body) {
+      throw new Error(`${errorLabel} API error: Response body is null`);
     }
-    resolveModel(model) {
-      const result = (0, model_info_1.resolveModelInput)(model, this.getConfiguredProviderIds());
-      if ((0, nua_errors_1.isNuaValidationError)(result)) {
-        throw new Error(result.message);
+    let textContent = "";
+    const toolCallAccumulators = /* @__PURE__ */ new Map();
+    let finishReason = null;
+    let usage = { ...provider_config_1.normalizedUsageZero };
+    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.usage) {
+        usage = (0, provider_config_1.normalizeOpenAiUsage)(chunk.usage);
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice)
+        continue;
+      if (choice.finish_reason) {
+        finishReason = choice.finish_reason;
+      }
+      const delta = choice.delta;
+      if (!delta)
+        continue;
+      if (delta.content) {
+        textContent += delta.content;
+        safeEmit(onEvent, { type: "text_delta", text: delta.content });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const existing = toolCallAccumulators.get(tc.index);
+          if (existing) {
+            if (tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+            }
+          } else {
+            toolCallAccumulators.set(tc.index, {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              arguments: tc.function?.arguments ?? ""
+            });
+          }
+        }
       }
-      return result;
     }
-    getClientForProvider(provider) {
-      const client = this.clients.get(provider);
-      if (!client) {
-        throw new Error(`LLM provider ${provider} is not configured. Please check your API keys.`);
-      }
-      return client;
+    const contentBlocks = [];
+    if (textContent) {
+      contentBlocks.push({ type: "text", text: textContent });
     }
-    async castValue(params) {
-      const providerModel = this.resolveModel(params.model);
-      const client = this.getClientForProvider(providerModel.provider);
-      const maxTokens = params.maxTokens || 4096;
-      const temperature = params.temperature ?? 0;
-      const prompt = cast_prompt_builder_1.default.buildFullPrompt(params);
-      const validationFn = (0, nua_json_schema_value_validation_1.buildNuaJsonSchemaValueValidation)("library-req", params.output.effectiveSchema);
-      try {
-        const result = await (0, call_llm_service_1.callLLM)(
-          client,
-          prompt,
-          providerModel.model,
-          maxTokens,
-          temperature,
-          3,
-          // default retries
-          validationFn
-        );
-        return {
-          success: true,
-          data: result.data,
-          usage: result.usage,
-          prompt
-        };
-      } catch (e) {
-        return {
-          success: false,
-          error: e instanceof Error ? e.message : String(e),
-          prompt
-        };
-      }
+    const sortedToolCalls = [...toolCallAccumulators.entries()].sort(([a], [b]) => a - b);
+    for (const [, tc] of sortedToolCalls) {
+      contentBlocks.push({
+        type: "toolCall",
+        id: tc.id,
+        name: tc.name,
+        arguments: parseOpenAiToolArguments(tc.arguments, tc.name, errorLabel)
+      });
     }
-    async castArray(params) {
-      const providerModel = this.resolveModel(params.model);
-      const client = this.getClientForProvider(providerModel.provider);
-      const maxTokens = params.maxTokens || 4096;
-      const temperature = params.temperature ?? 0;
-      const validData = (0, validate_mappable_input_data_1.validateMappableInputData)(params.data, params.input.primaryKey);
-      if ((0, nua_errors_1.isNuaValidationError)(validData)) {
-        return {
-          success: false,
-          error: validData.message
-        };
-      }
-      const prompt = cast_array_prompt_builder_1.default.buildFullPrompt(params, validData);
-      const validationFn = (0, nua_json_schema_value_validation_1.buildNuaJsonSchemaValueValidation)("library-req", params.output.effectiveSchema);
+    const stopReason2 = finishReason === "tool_calls" || sortedToolCalls.length > 0 ? "tool_use" : "stop";
+    return {
+      message: { role: "assistant", content: contentBlocks },
+      usage,
+      stopReason: stopReason2
+    };
+  }
+  async function streamGeminiAgenticResponse(response, onEvent) {
+    if (response.status !== 200) {
+      const errorBody = await response.text();
       try {
-        const result = await (0, call_llm_service_1.callLLM)(client, prompt, providerModel.model, maxTokens, temperature, 3, validationFn);
-        return {
-          success: true,
-          data: result.data,
-          usage: result.usage,
-          prompt
-        };
+        const parsed = JSON.parse(errorBody);
+        const message = parsed?.error?.message || errorBody;
+        throw new Error(`Gemini API error: ${response.status} - ${message}`);
       } catch (e) {
-        return {
-          success: false,
-          error: e instanceof Error ? e.message : String(e),
-          prompt
-        };
+        if (e instanceof Error && e.message.startsWith("Gemini API error:"))
+          throw e;
+        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
       }
     }
-    async runAgent(params) {
+    if (!response.body) {
+      throw new Error("Gemini API error: Response body is null");
+    }
+    const contentBlocks = [];
+    let hasToolCalls2 = false;
+    let textContent2 = "";
+    let usage2 = { ...provider_config_1.normalizedUsageZero };
+    for await (const data of (0, sse_parser_1.parseSSEStream)(response.body)) {
+      let chunk;
       try {
-        const providerModel = this.resolveModel(params.model);
-        const client = this.getClientForProvider(providerModel.provider);
-        const maxTokens = params.maxTokens ?? 4096;
-        const maxTurns = params.maxTurns ?? 10;
-        return (0, agent_loop_1.runAgentLoop)({
-          messages: params.messages,
-          tools: params.tools,
-          systemPrompt: params.systemPrompt,
-          maxTurns,
-          onEvent: params.onEvent,
-          sendRequest: (messages, tools, systemPrompt) => client.sendAgenticRequest(messages, tools, providerModel.model, maxTokens, systemPrompt, params.onEvent)
-        });
-      } catch (e) {
-        return {
-          success: false,
-          completionReason: "error",
-          messages: params.messages,
-          usage: provider_config_1.normalizedUsageZero,
-          error: e instanceof Error ? e.message : String(e)
-        };
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.usageMetadata) {
+        usage2 = (0, provider_config_1.normalizeGeminiUsage)(chunk.usageMetadata);
+      }
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts)
+        continue;
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          textContent2 += part.text;
+          safeEmit(onEvent, { type: "text_delta", text: part.text });
+        }
+        if (part.functionCall) {
+          hasToolCalls2 = true;
+          contentBlocks.push({
+            type: "toolCall",
+            id: crypto.randomUUID(),
+            name: part.functionCall.name,
+            arguments: part.functionCall.args
+          });
+        }
       }
     }
-  }
-  nuaLlmClient.NuaLlmClient = NuaLlmClient;
-  return nuaLlmClient;
-}
-
-var types = {};
-
-var hasRequiredTypes;
-function requireTypes() {
-  if (hasRequiredTypes) return types;
-  hasRequiredTypes = 1;
-  Object.defineProperty(types, "__esModule", { value: true });
-  return types;
-}
-
-var validateJsonSchema = {};
-
-var errorUtils = {};
-
-var hasRequiredErrorUtils;
-function requireErrorUtils() {
-  if (hasRequiredErrorUtils) return errorUtils;
-  hasRequiredErrorUtils = 1;
-  Object.defineProperty(errorUtils, "__esModule", { value: true });
-  errorUtils.getErrorMessageFromException = getErrorMessageFromException;
-  function isErrorWithMessage(error) {
-    return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
-  }
-  function getErrorMessageFromException(error) {
-    if (isErrorWithMessage(error)) {
-      return error.message;
+    if (textContent2) {
+      contentBlocks.unshift({ type: "text", text: textContent2 });
     }
-    return String(error);
+    const stopReason3 = hasToolCalls2 ? "tool_use" : "stop";
+    return {
+      message: { role: "assistant", content: contentBlocks },
+      usage: usage2,
+      stopReason: stopReason3
+    };
   }
-  return errorUtils;
+  return providerFormatters;
 }
 
-var hasRequiredValidateJsonSchema;
-function requireValidateJsonSchema() {
-  if (hasRequiredValidateJsonSchema) return validateJsonSchema;
-  hasRequiredValidateJsonSchema = 1;
-  Object.defineProperty(validateJsonSchema, "__esModule", { value: true });
-  validateJsonSchema.validateJsonSchema = void 0;
-  const error_utils_1 = requireErrorUtils();
-  const ajv_instances_1 = requireAjvInstances();
-  const validateJsonSchema$1 = (schema) => {
-    if (!schema || typeof schema !== "object") {
-      return {
-        kind: "validation-error",
-        message: "Schema must be a valid object"
-      };
+var hasRequiredAgentTurn;
+function requireAgentTurn() {
+  if (hasRequiredAgentTurn) return agentTurn;
+  hasRequiredAgentTurn = 1;
+  Object.defineProperty(agentTurn, "__esModule", { value: true });
+  agentTurn.sendAgentTurn = sendAgentTurn;
+  const provider_call_1 = requireProviderCall();
+  const provider_config_1 = requireProviderConfig();
+  const provider_formatters_1 = requireProviderFormatters();
+  async function sendAgentTurn(turn, logger) {
+    const codec = agentCodec(turn.target);
+    const onEvent = turn.onEvent;
+    const call = await (0, provider_call_1.callProvider)({
+      target: turn.target,
+      apiOperation: "agentic",
+      maxTokens: turn.maxTokens,
+      request: codec.buildRequest({
+        messages: turn.messages,
+        tools: turn.tools,
+        model: turn.target.model,
+        maxTokens: turn.maxTokens,
+        systemPrompt: turn.systemPrompt,
+        stream: onEvent !== void 0
+      }),
+      parseResponse: onEvent ? (response) => codec.parseStreamingResponse(response, onEvent) : codec.parseResponse,
+      responseLength: (reply) => reply.message.content.reduce((total, content) => total + (content.type === "text" ? content.text.length : 0), 0),
+      usage: (reply) => reply.usage
+    }, logger);
+    if (call.kind === "failed") {
+      throw new Error(call.message);
     }
-    const ajvInstance = ajv_instances_1.ajvInstances.getInstanceForSchema(schema);
-    const isValidSchema = ajvInstance.validateSchema(schema);
-    let errors = "";
-    if (ajvInstance.errors) {
-      errors = ajvInstance.errors.map((e) => JSON.stringify(e, null, 2)).join("; ");
-    } else if (isValidSchema) {
-      try {
-        ajvInstance.compile(schema);
-        return true;
-      } catch (e) {
-        errors = (0, error_utils_1.getErrorMessageFromException)(e);
-      }
-    } else {
-      errors = "unexpected-situation-no-errors-found-for-invalid-schema";
+    return call.reply;
+  }
+  function agentCodec({ provider, apiKey }) {
+    const errorLabel = provider_config_1.providerConfigs[provider].errorLabel;
+    switch (provider) {
+      case "groq":
+        return openAiStyleCodec("https://api.groq.com/openai/v1/chat/completions", apiKey, errorLabel);
+      case "cerebras":
+        return openAiStyleCodec("https://api.cerebras.ai/v1/chat/completions", apiKey, errorLabel);
+      case "openrouter":
+        return openAiStyleCodec("https://openrouter.ai/api/v1/chat/completions", apiKey, errorLabel);
+      case "gemini":
+        return {
+          buildRequest: (options) => (0, provider_formatters_1.buildGeminiAgenticRequest)(options, apiKey),
+          parseResponse: provider_formatters_1.parseGeminiAgenticResponse,
+          parseStreamingResponse: provider_formatters_1.streamGeminiAgenticResponse
+        };
     }
+  }
+  function openAiStyleCodec(url, apiKey, errorLabel) {
     return {
-      kind: "validation-error",
-      message: `Unable to validate JSON schema: ${errors}`
-    };
-  };
-  validateJsonSchema.validateJsonSchema = validateJsonSchema$1;
-  return validateJsonSchema;
-}
-
-var stableStringify = {};
-
-var hasRequiredStableStringify;
-function requireStableStringify() {
-  if (hasRequiredStableStringify) return stableStringify;
-  hasRequiredStableStringify = 1;
-  Object.defineProperty(stableStringify, "__esModule", { value: true });
-  stableStringify.stableStringify = stableStringify$1;
-  function stableStringify$1(value) {
-    const seen = /* @__PURE__ */ new WeakSet();
-    const sorter = (_key, currentValue) => {
-      if (currentValue && typeof currentValue === "object" && !Array.isArray(currentValue)) {
-        if (seen.has(currentValue)) {
-          return currentValue;
-        }
-        seen.add(currentValue);
-        return Object.keys(currentValue).sort().reduce((acc, key) => {
-          acc[key] = currentValue[key];
-          return acc;
-        }, {});
-      }
-      return currentValue;
+      buildRequest: (options) => (0, provider_formatters_1.buildOpenAiAgenticRequest)(options, url, apiKey),
+      parseResponse: (response) => (0, provider_formatters_1.parseOpenAiAgenticResponse)(response, errorLabel),
+      parseStreamingResponse: (response, onEvent) => (0, provider_formatters_1.streamOpenAiAgenticResponse)(response, errorLabel, onEvent)
     };
-    return JSON.stringify(value, sorter) ?? "";
   }
-  return stableStringify;
+  return agentTurn;
 }
 
-var schemaUtils = {};
-
-var hasRequiredSchemaUtils;
-function requireSchemaUtils() {
-  if (hasRequiredSchemaUtils) return schemaUtils;
-  hasRequiredSchemaUtils = 1;
-  Object.defineProperty(schemaUtils, "__esModule", { value: true });
-  schemaUtils.wrapArraySchema = wrapArraySchema;
-  schemaUtils.unwrapArraySchema = unwrapArraySchema;
-  function wrapArraySchema(schema, options) {
-    const { primaryKey, outputName } = options;
-    const schemaVersion = typeof schema.$schema === "string" ? schema.$schema : void 0;
-    const wrappedSchema = {
-      type: "array",
-      items: {
-        type: "object",
-        required: [primaryKey, outputName],
-        properties: {
-          [primaryKey]: {
-            anyOf: [{ type: "string" }, { type: "number" }, { type: "integer" }]
-          },
-          [outputName]: schema
-        }
-      }
-    };
-    if (schemaVersion) {
-      wrappedSchema.$schema = schemaVersion;
-    }
-    return wrappedSchema;
-  }
-  function unwrapArraySchema(wrappedSchema, outputName) {
-    const items = wrappedSchema.items;
-    if (!items || typeof items !== "object") {
-      return null;
-    }
-    const properties = items.properties;
-    if (!properties || typeof properties !== "object") {
-      return null;
+var hasRequiredRunAgent;
+function requireRunAgent() {
+  if (hasRequiredRunAgent) return runAgent;
+  hasRequiredRunAgent = 1;
+  Object.defineProperty(runAgent, "__esModule", { value: true });
+  runAgent.runAgent = runAgent$1;
+  const provider_config_1 = requireProviderConfig();
+  const agent_loop_1 = requireAgentLoop();
+  const agent_turn_1 = requireAgentTurn();
+  const DEFAULT_MAX_TOKENS = 4096;
+  const DEFAULT_MAX_TURNS = 10;
+  async function runAgent$1(providers, params) {
+    const resolved = providers.resolve(params.model);
+    if (resolved.kind === "unroutable") {
+      return {
+        success: false,
+        completionReason: "error",
+        messages: params.messages,
+        usage: provider_config_1.normalizedUsageZero,
+        error: resolved.message
+      };
     }
-    return properties[outputName] ?? null;
+    const maxTokens = params.maxTokens ?? DEFAULT_MAX_TOKENS;
+    return (0, agent_loop_1.runAgentLoop)({
+      messages: params.messages,
+      tools: params.tools,
+      systemPrompt: params.systemPrompt,
+      maxTurns: params.maxTurns ?? DEFAULT_MAX_TURNS,
+      onEvent: params.onEvent,
+      sendRequest: (messages, tools, systemPrompt) => (0, agent_turn_1.sendAgentTurn)({ target: resolved.target, maxTokens, messages, tools, systemPrompt, onEvent: params.onEvent }, providers.logger)
+    });
   }
-  return schemaUtils;
+  return runAgent;
 }
 
 var hasRequiredDist;
@@ -11027,23 +11175,12 @@ function requireDist() {
     var __exportStar = dist && dist.__exportStar || function(m, exports2) {
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
     };
-    var __importDefault = dist && dist.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
     Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.runAgentLoop = exports$1.stableStringify = exports$1.validateJsonSchema = exports$1.providerConfigs = exports$1.normalizedUsageZero = exports$1.LLM_PROVIDER_IDS = exports$1.castArrayPromptBuilder = exports$1.castPromptBuilder = void 0;
+    exports$1.runAgentLoop = exports$1.runAgent = exports$1.parseListSchema = exports$1.listSchema = exports$1.stableStringify = exports$1.validateJsonSchema = exports$1.providerEngines = exports$1.providerConfigs = exports$1.normalizedUsageZero = exports$1.LLM_PROVIDER_IDS = void 0;
     __exportStar(requireNuaLlmClient(), exports$1);
-    __exportStar(requireLogger(), exports$1);
+    __exportStar(logger.requireLogger(), exports$1);
     __exportStar(requireTypes(), exports$1);
     __exportStar(requireNuaErrors(), exports$1);
-    var cast_prompt_builder_1 = requireCastPromptBuilder();
-    Object.defineProperty(exports$1, "castPromptBuilder", { enumerable: true, get: function() {
-      return __importDefault(cast_prompt_builder_1).default;
-    } });
-    var cast_array_prompt_builder_1 = requireCastArrayPromptBuilder();
-    Object.defineProperty(exports$1, "castArrayPromptBuilder", { enumerable: true, get: function() {
-      return __importDefault(cast_array_prompt_builder_1).default;
-    } });
     var provider_config_1 = requireProviderConfig();
     Object.defineProperty(exports$1, "LLM_PROVIDER_IDS", { enumerable: true, get: function() {
       return provider_config_1.LLM_PROVIDER_IDS;
@@ -11054,6 +11191,10 @@ function requireDist() {
     Object.defineProperty(exports$1, "providerConfigs", { enumerable: true, get: function() {
       return provider_config_1.providerConfigs;
     } });
+    var provider_engines_1 = requireProviderEngines();
+    Object.defineProperty(exports$1, "providerEngines", { enumerable: true, get: function() {
+      return provider_engines_1.providerEngines;
+    } });
     var validate_json_schema_1 = requireValidateJsonSchema();
     Object.defineProperty(exports$1, "validateJsonSchema", { enumerable: true, get: function() {
       return validate_json_schema_1.validateJsonSchema;
@@ -11064,6 +11205,17 @@ function requireDist() {
     } });
     __exportStar(requireModelInfo(), exports$1);
     __exportStar(requireSchemaUtils(), exports$1);
+    var list_schema_1 = requireListSchema();
+    Object.defineProperty(exports$1, "listSchema", { enumerable: true, get: function() {
+      return list_schema_1.listSchema;
+    } });
+    Object.defineProperty(exports$1, "parseListSchema", { enumerable: true, get: function() {
+      return list_schema_1.parseListSchema;
+    } });
+    var run_agent_1 = requireRunAgent();
+    Object.defineProperty(exports$1, "runAgent", { enumerable: true, get: function() {
+      return run_agent_1.runAgent;
+    } });
     var agent_loop_1 = requireAgentLoop();
     Object.defineProperty(exports$1, "runAgentLoop", { enumerable: true, get: function() {
       return agent_loop_1.runAgentLoop;
@@ -11074,80 +11226,59 @@ function requireDist() {
 
 var distExports = requireDist();
 
-const normalizedUsageZero = {
-  promptTokens: 0,
-  completionTokens: 0,
-  totalTokens: 0
-};
 class DirectBackend {
   constructor(config) {
-    this.model = config.model;
-    this.client = new distExports.NuaLlmClient({ providers: config.providers });
+    this.client = new distExports.NuaLlmClient(enginesFor(config));
   }
   async castValue(params) {
-    const model = params.model ?? this.model;
     const startTime = Date.now();
     const result = await this.client.castValue({
-      model,
+      model: params.model,
       input: { prompt: params.prompt, data: params.data },
-      output: { name: params.outputName, effectiveSchema: params.outputSchema }
+      output: { name: params.outputName, schema: params.outputSchema }
     });
-    const latencyMs = Date.now() - startTime;
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || "Unknown error",
-        source: "direct",
-        latencyMs
-      };
-    }
-    return {
-      success: true,
-      data: result.data,
-      usage: result.usage || normalizedUsageZero,
-      model: formatModelInput(model),
-      latencyMs,
-      source: "direct",
-      meta: {}
-    };
+    return toDirectResult(result, Date.now() - startTime);
   }
   async castArray(params) {
-    const model = params.model ?? this.model;
     const startTime = Date.now();
-    const wrappedSchema = distExports.wrapArraySchema(params.outputSchema, {
-      primaryKey: params.primaryKey,
-      outputName: params.outputName
-    });
     const result = await this.client.castArray({
-      model,
-      data: params.data,
-      input: { prompt: params.prompt, primaryKey: params.primaryKey },
-      output: { name: params.outputName, effectiveSchema: wrappedSchema }
+      model: params.model,
+      input: { prompt: params.prompt, data: params.data },
+      output: distExports.listSchema(params.outputSchema, {
+        primaryKey: params.primaryKey,
+        outputName: params.outputName
+      })
     });
-    const latencyMs = Date.now() - startTime;
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || "Unknown error",
-        source: "direct",
-        latencyMs
-      };
-    }
-    return {
-      success: true,
-      data: result.data,
-      usage: result.usage || normalizedUsageZero,
-      model: formatModelInput(model),
-      latencyMs,
-      source: "direct",
-      meta: {}
-    };
+    return toDirectResult(result, Date.now() - startTime);
+  }
+}
+function enginesFor(config) {
+  if (config.localAgent) {
+    return config.localAgent;
   }
+  return distExports.providerEngines({ providers: config.providers, model: config.model });
 }
-function formatModelInput(model) {
-  if (!model) return "fast";
-  if ("alias" in model) return model.alias;
-  return `${model.provider}:${model.model}`;
+function toDirectResult(result, latencyMs) {
+  if (!result.success) {
+    return { success: false, error: result.error, source: "direct", latencyMs };
+  }
+  return {
+    success: true,
+    data: result.data,
+    usage: result.usage,
+    model: describeModel(result.origin),
+    latencyMs,
+    source: "direct",
+    meta: { ...result.origin, schemaEnforcement: result.schemaEnforcement }
+  };
+}
+function describeModel(origin) {
+  switch (origin.engine) {
+    case "http":
+      return `${origin.provider}:${origin.model}`;
+    case "local-agent":
+      return `${origin.agent}:${origin.model ?? "default"}`;
+  }
 }
 
 function resolveConfigValue(config, key, envVar) {
@@ -11397,6 +11528,11 @@ class Nua {
   static gateway(config) {
     return new Nua(new GatewayBackend(config));
   }
+  /**
+   * Runs casts in this process: on LLM providers' APIs with your API keys (`providers`), or
+   * on a coding-agent CLI installed on this machine (`localAgent`, set up with `localAgent()` or
+   * `findLocalAgent()` from "nuabase/local-agent").
+   */
   static direct(config) {
     return new Nua(new DirectBackend(config));
   }