nuabase 2.0.0 → 2.1.0

package/dist/esm/index.mjs

@@ -1,7 +1,1205 @@
-import { NuaLlmClient, wrapArraySchema } from 'nua-llm-core';
+import { createRequire } from 'node:module';
+import require$$0 from 'ajv';
+import require$$1 from 'ajv/dist/2019';
+import require$$2 from 'ajv/dist/2020';
+import require$$3 from 'ajv/dist/refs/json-schema-draft-07.json';
+import require$$4 from 'ajv/dist/refs/json-schema-draft-06.json';
 import { z } from 'zod';
 export { z } from 'zod';
 
+var dist = {};
+
+var nuaLlmClient = {};
+
+var logger = {};
+
+const require$1 = createRequire(import.meta.url);
+function __require() { return require$1("node:crypto"); }
+
+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.truncateText = truncateText;
+  logger.pickHeaders = pickHeaders;
+  logger.normalizeError = normalizeError;
+  const node_crypto_1 = __require();
+  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 = () => (0, node_crypto_1.randomUUID)();
+  logger.generateSpanId = generateSpanId;
+  function truncateText(text, limit = 500) {
+    const length = text.length;
+    if (length <= limit) {
+      return { preview: text, length };
+    }
+    return { preview: text.slice(0, limit), length };
+  }
+  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
+    });
+  };
+  logger.logLlmCallStart = logLlmCallStart;
+  const logLlmCallComplete = (logger2, spanId, service, method, response, duration) => {
+    const { headers, responseText, ...rest } = response;
+    const { preview: responsePreview, length: responseLength } = truncateText(responseText);
+    logger2.info("LLM call completed", {
+      type: "llm_call_complete",
+      span_id: spanId,
+      service,
+      method,
+      ...rest,
+      responsePreview,
+      responseLength,
+      ...pickHeaders(headers, LLM_RESPONSE_HEADER_ALLOWLIST),
+      duration_ms: duration
+    });
+  };
+  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
+    });
+  };
+  logger.logLlmCallError = logLlmCallError;
+  return logger;
+}
+
+var validateMappableInputData = {};
+
+var hasRequiredValidateMappableInputData;
+function requireValidateMappableInputData() {
+  if (hasRequiredValidateMappableInputData) return validateMappableInputData;
+  hasRequiredValidateMappableInputData = 1;
+  Object.defineProperty(validateMappableInputData, "__esModule", { value: true });
+  validateMappableInputData.validateMappableInputData = validateMappableInputData$1;
+  function validateMappableInputData$1(data, primaryKey) {
+    if (!Array.isArray(data))
+      return {
+        kind: "validation-error",
+        message: "input.data must be an array"
+      };
+    if (typeof primaryKey !== "string" || primaryKey.trim() === "") {
+      return {
+        kind: "validation-error",
+        message: "input.primaryKey must be a non-empty string"
+      };
+    }
+    const invalidDataMessage = `Each item in 'data' must be an object with at least one key including the primary key '${primaryKey}'`;
+    for (let i = 0; i < data.length; i++) {
+      const item = data[i];
+      if (item === null || typeof item !== "object" || Array.isArray(item))
+        return {
+          kind: "validation-error",
+          message: invalidDataMessage
+        };
+      const keys = Object.keys(item);
+      if (keys.length < 2 || !keys.includes(primaryKey))
+        return {
+          kind: "validation-error",
+          message: invalidDataMessage
+        };
+    }
+    return data;
+  }
+  return validateMappableInputData;
+}
+
+var callLlmService = {};
+
+var llmResponseExtraction = {};
+
+var hasRequiredLlmResponseExtraction;
+function requireLlmResponseExtraction() {
+  if (hasRequiredLlmResponseExtraction) return llmResponseExtraction;
+  hasRequiredLlmResponseExtraction = 1;
+  Object.defineProperty(llmResponseExtraction, "__esModule", { value: true });
+  llmResponseExtraction.extractThinkingFromResponse = extractThinkingFromResponse;
+  llmResponseExtraction.extractJsonFromMarkdown = extractJsonFromMarkdown;
+  function extractThinkingFromResponse(input) {
+    const startTag = "<think>";
+    const endTag = "</think>";
+    const thinkingParts = [];
+    const cleanedParts = [];
+    let cursor = 0;
+    while (cursor < input.length) {
+      const startIndex = input.indexOf(startTag, cursor);
+      if (startIndex === -1) {
+        cleanedParts.push(input.slice(cursor));
+        break;
+      }
+      cleanedParts.push(input.slice(cursor, startIndex));
+      const contentStart = startIndex + startTag.length;
+      const endIndex = input.indexOf(endTag, contentStart);
+      if (endIndex === -1) {
+        cleanedParts.push(input.slice(startIndex));
+        break;
+      }
+      thinkingParts.push(input.slice(contentStart, endIndex).trim());
+      cursor = endIndex + endTag.length;
+    }
+    const thinking = thinkingParts.join("\n\n");
+    const cleanedResponse = cleanedParts.join("").trim();
+    return {
+      thinking,
+      cleanedResponse
+    };
+  }
+  function extractJsonFromMarkdown(input) {
+    const trimmed = input.trim();
+    const codeFence = "```";
+    const jsonFence = "```json";
+    if (trimmed.startsWith(jsonFence)) {
+      const startIndex = jsonFence.length;
+      const endIndex = trimmed.lastIndexOf(codeFence);
+      if (endIndex > startIndex) {
+        return trimmed.substring(startIndex, endIndex).trim();
+      }
+    }
+    if (trimmed.startsWith(codeFence) && !trimmed.startsWith(jsonFence)) {
+      const startIndex = codeFence.length;
+      const endIndex = trimmed.lastIndexOf(codeFence);
+      if (endIndex > startIndex) {
+        return trimmed.substring(startIndex, endIndex).trim();
+      }
+    }
+    return input;
+  }
+  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 {
+          let { thinking, cleanedResponse } = (0, llm_response_extraction_1.extractThinkingFromResponse)(response);
+          cleanedResponse = (0, llm_response_extraction_1.extractJsonFromMarkdown)(cleanedResponse);
+          parsedResponse = JSON.parse(cleanedResponse);
+        } catch (parseError) {
+          const errorMessage2 = `Failed to parse LLM response as JSON: ${parseError instanceof Error ? parseError.message : "Unknown parsing error"}`;
+          throw new Error(errorMessage2);
+        }
+        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);
+      } 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 = {};
+
+var hasRequiredAjvInstances;
+function requireAjvInstances() {
+  if (hasRequiredAjvInstances) return ajvInstances;
+  hasRequiredAjvInstances = 1;
+  var __importDefault = ajvInstances && ajvInstances.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(ajvInstances, "__esModule", { value: true });
+  ajvInstances.ajvInstances = void 0;
+  const ajv_1 = __importDefault(require$$0);
+  const _2019_1 = __importDefault(require$$1);
+  const _2020_1 = __importDefault(require$$2);
+  const json_schema_draft_07_json_1 = __importDefault(require$$3);
+  const json_schema_draft_06_json_1 = __importDefault(require$$4);
+  const ajvOptions = {
+    allErrors: true,
+    strict: true,
+    strictSchema: true,
+    strictNumbers: true,
+    strictRequired: true
+  };
+  class AjvInstances {
+    constructor() {
+      this.draft07 = new ajv_1.default(ajvOptions);
+      this.draft2019 = new _2019_1.default(ajvOptions);
+      this.draft2019.addMetaSchema(json_schema_draft_07_json_1.default);
+      this.draft2019.addMetaSchema(json_schema_draft_06_json_1.default);
+      this.draft2020 = new _2020_1.default(ajvOptions);
+    }
+    getInstanceForSchema(schema) {
+      const schemaVersion = schema.$schema;
+      if (!schemaVersion) {
+        return this.draft07;
+      }
+      if (schemaVersion.includes("draft/2020-12") || schemaVersion.includes("draft-2020-12")) {
+        return this.draft2020;
+      }
+      if (schemaVersion.includes("draft/2019-09") || schemaVersion.includes("draft-2019-09")) {
+        return this.draft2019;
+      }
+      return this.draft07;
+    }
+  }
+  ajvInstances.ajvInstances = new AjvInstances();
+  return ajvInstances;
+}
+
+var hasRequiredNuaJsonSchemaValueValidation;
+function requireNuaJsonSchemaValueValidation() {
+  if (hasRequiredNuaJsonSchemaValueValidation) return nuaJsonSchemaValueValidation;
+  hasRequiredNuaJsonSchemaValueValidation = 1;
+  Object.defineProperty(nuaJsonSchemaValueValidation, "__esModule", { value: true });
+  nuaJsonSchemaValueValidation.buildNuaJsonSchemaValueValidation = buildNuaJsonSchemaValueValidation;
+  const ajv_instances_1 = requireAjvInstances();
+  function buildNuaJsonSchemaValueValidation(llmRequestId, parsedSchema) {
+    const ajv = ajv_instances_1.ajvInstances.getInstanceForSchema(parsedSchema);
+    const ajvValidation = ajv.compile(parsedSchema);
+    return (json) => {
+      if (ajvValidation(json)) {
+        return { success: true, data: json };
+      } else {
+        const errors = ajvValidation.errors;
+        if (errors) {
+          const errString = errors.map((err) => `${err.instancePath} ${err.message}`).join(", ");
+          return {
+            success: false,
+            error: errString
+          };
+        } else {
+          return { success: false, error: "Unknown validation error" };
+        }
+      }
+    };
+  }
+  return nuaJsonSchemaValueValidation;
+}
+
+var httpLlmClient = {};
+
+var modelInfo = {};
+
+var hasRequiredModelInfo;
+function requireModelInfo() {
+  if (hasRequiredModelInfo) return modelInfo;
+  hasRequiredModelInfo = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.SUPPORTED_MODELS = exports$1.CANONICAL_MODELS = void 0;
+    exports$1.parseCanonicalModelName = parseCanonicalModelName;
+    exports$1.CANONICAL_MODELS = [
+      "qwen3-30b-a3b-instruct-2507",
+      "claude-sonnet-4-5",
+      "qwen3-vl-235b-a22b-instruct",
+      "qwen3-max",
+      "gpt-5",
+      "gemini-2.5-flash-lite-preview-09-2025",
+      "qwen3-coder-flash",
+      "gpt-oss-120b",
+      "llama-3.3-70b-versatile",
+      "gpt-4o",
+      "llama-3.3-70b",
+      "gemini-2.0-flash"
+    ];
+    const CANONICAL_SET = new Set(exports$1.CANONICAL_MODELS);
+    exports$1.SUPPORTED_MODELS = {
+      "gpt-oss-120b": [
+        {
+          provider: "cerebras",
+          providerModelName: "gpt-oss-120b"
+        },
+        {
+          provider: "openrouter",
+          providerModelName: "openai/gpt-oss-120b"
+        }
+      ],
+      "qwen3-30b-a3b-instruct-2507": [
+        {
+          provider: "openrouter",
+          providerModelName: "qwen/qwen3-30b-a3b-instruct-2507"
+        }
+      ],
+      "claude-sonnet-4-5": [
+        {
+          provider: "openrouter",
+          providerModelName: "anthropic/claude-sonnet-4.5"
+        }
+      ],
+      "qwen3-vl-235b-a22b-instruct": [
+        {
+          provider: "openrouter",
+          providerModelName: "qwen/qwen3-vl-235b-a22b-instruct"
+        }
+      ],
+      "qwen3-max": [
+        {
+          provider: "openrouter",
+          providerModelName: "qwen/qwen3-max"
+        }
+      ],
+      "gpt-5": [
+        {
+          provider: "openrouter",
+          providerModelName: "openai/gpt-5"
+        }
+      ],
+      "gemini-2.5-flash-lite-preview-09-2025": [
+        {
+          provider: "openrouter",
+          providerModelName: "google/gemini-2.5-flash-lite-preview-09-2025"
+        }
+      ],
+      "qwen3-coder-flash": [
+        {
+          provider: "openrouter",
+          providerModelName: "qwen/qwen3-coder-flash"
+        }
+      ],
+      "llama-3.3-70b-versatile": [
+        {
+          provider: "groq",
+          providerModelName: "llama-3.3-70b-versatile"
+        }
+      ],
+      "gpt-4o": [
+        {
+          provider: "openrouter",
+          providerModelName: "openai/gpt-4o"
+        }
+      ],
+      "llama-3.3-70b": [
+        {
+          provider: "cerebras",
+          providerModelName: "llama-3.3-70b"
+        }
+      ],
+      "gemini-2.0-flash": [
+        {
+          provider: "gemini",
+          providerModelName: "gemini-2.0-flash"
+        }
+      ]
+    };
+    function parseCanonicalModelName(requestedModel) {
+      let m = requestedModel || "fast";
+      if (CANONICAL_SET.has(m))
+        return m;
+      let m2;
+      switch (m) {
+        case "fast":
+          m2 = "gpt-oss-120b";
+          break;
+        case "qwen":
+          m2 = "qwen3-vl-235b-a22b-instruct";
+          break;
+        case "sonnet":
+          m2 = "claude-sonnet-4-5";
+          break;
+        case "gpt":
+          m2 = "gpt-5";
+          break;
+      }
+      if (m2)
+        return m2;
+      return {
+        kind: "validation-error",
+        message: `Invalid model name: ${m ?? "null/undefined"}`
+      };
+    }
+  })(modelInfo);
+  return modelInfo;
+}
+
+var providerConfig = {};
+
+var hasRequiredProviderConfig;
+function requireProviderConfig() {
+  if (hasRequiredProviderConfig) return providerConfig;
+  hasRequiredProviderConfig = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.providerConfigs = exports$1.normalizedUsageZero = void 0;
+    exports$1.normalizedUsageZero = {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    const normalizeOpenAiUsage = (usage) => {
+      if (!usage) {
+        return exports$1.normalizedUsageZero;
+      }
+      if (typeof usage.prompt_tokens !== "number" || typeof usage.completion_tokens !== "number" || typeof usage.total_tokens !== "number") {
+        return exports$1.normalizedUsageZero;
+      }
+      return {
+        promptTokens: usage.prompt_tokens,
+        completionTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens
+      };
+    };
+    const normalizeGeminiUsage = (usage) => {
+      if (!usage) {
+        return exports$1.normalizedUsageZero;
+      }
+      if (typeof usage.promptTokenCount !== "number" || typeof usage.candidatesTokenCount !== "number" || typeof usage.totalTokenCount !== "number") {
+        return exports$1.normalizedUsageZero;
+      }
+      return {
+        promptTokens: usage.promptTokenCount,
+        completionTokens: usage.candidatesTokenCount,
+        totalTokens: usage.totalTokenCount
+      };
+    };
+    const buildOpenAiStyleRequest = (baseUrl) => ({ prompt, model, maxTokens, assistantPrefillPrompt }, apiKey) => {
+      const messages = [];
+      messages.push({ role: "user", content: prompt });
+      if (assistantPrefillPrompt) {
+        messages.push({ role: "assistant", content: assistantPrefillPrompt });
+      }
+      const body = {
+        messages,
+        model,
+        temperature: 0.6,
+        max_completion_tokens: maxTokens,
+        top_p: 1,
+        stream: false,
+        stop: null
+      };
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      };
+      return {
+        url: baseUrl,
+        method: "POST",
+        headers,
+        body,
+        loggableHeaders: {
+          ...headers,
+          Authorization: "Bearer [REDACTED]"
+        },
+        loggableBody: body
+      };
+    };
+    const parseOpenAiStyleResponse = (errorLabel) => async (response) => {
+      if (response.status === 200) {
+        const responseBody = await response.json();
+        const responseText = responseBody.choices?.[0]?.message?.content;
+        if (responseText) {
+          return {
+            text: responseText,
+            usage: normalizeOpenAiUsage(responseBody.usage)
+          };
+        }
+        throw new Error(`${errorLabel} API error: Could not extract text from response. Body: ${JSON.stringify(responseBody)}`);
+      }
+      const errorBody = await response.text();
+      try {
+        const parsedError = JSON.parse(errorBody);
+        const message = parsedError.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch {
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+      }
+    };
+    const parseOpenAiGPT5ThinkingStyleResponse = (errorLabel) => async (response) => {
+      const normalize = (value) => {
+        if (typeof value !== "string") {
+          return void 0;
+        }
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : void 0;
+      };
+      if (response.status === 200) {
+        const responseBody = await response.json();
+        const message = responseBody.choices?.[0]?.message;
+        const content = normalize(message?.content) ?? normalize(message?.reasoning) ?? normalize(message?.reasoning_details?.map((detail) => typeof detail === "object" && detail !== null ? "summary" in detail ? detail.summary : void 0 : void 0).find((summary) => summary !== void 0));
+        if (content) {
+          return {
+            text: content,
+            usage: normalizeOpenAiUsage(responseBody.usage)
+          };
+        }
+        throw new Error(`${errorLabel} API error: Could not extract text from thinking response. Body: ${JSON.stringify(responseBody)}`);
+      }
+      const errorBody = await response.text();
+      try {
+        const parsedError = JSON.parse(errorBody);
+        const message = parsedError.error?.message || errorBody;
+        throw new Error(`${errorLabel} API error: ${response.status} - ${message}`);
+      } catch {
+        throw new Error(`${errorLabel} API error: ${response.status} - ${errorBody}`);
+      }
+    };
+    const buildGeminiRequest = ({ prompt, model, maxTokens, assistantPrefillPrompt }, apiKey) => {
+      const contents = [];
+      contents.push({ role: "user", parts: [{ text: prompt }] });
+      if (assistantPrefillPrompt) {
+        contents.push({
+          role: "model",
+          parts: [{ text: assistantPrefillPrompt }]
+        });
+      }
+      const body = {
+        contents,
+        generationConfig: {
+          maxOutputTokens: maxTokens
+        }
+      };
+      const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+      return {
+        url,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body,
+        loggableUrl: url.replace(/key=[^&]+/, "key=[REDACTED]"),
+        loggableBody: body
+      };
+    };
+    const parseGeminiResponse = async (response) => {
+      if (response.status === 200) {
+        const responseBody = await response.json();
+        const responseText = responseBody.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("");
+        if (responseText) {
+          return {
+            text: responseText,
+            usage: normalizeGeminiUsage(responseBody.usageMetadata)
+          };
+        }
+        throw new Error(`Gemini API error: Could not extract text from response. Body: ${JSON.stringify(responseBody)}`);
+      }
+      const errorBody = await response.text();
+      try {
+        const parsedError = JSON.parse(errorBody);
+        const message = parsedError.error?.message || errorBody;
+        throw new Error(`Gemini API error: ${response.status} - ${message}`);
+      } catch {
+        throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+      }
+    };
+    exports$1.providerConfigs = {
+      groq: {
+        providerId: "groq",
+        apiOperation: "chat/completions",
+        errorLabel: "Groq",
+        buildRequest: buildOpenAiStyleRequest("https://api.groq.com/openai/v1/chat/completions"),
+        parseResponse: parseOpenAiStyleResponse("Groq")
+      },
+      cerebras: {
+        providerId: "cerebras",
+        apiOperation: "chat/completions",
+        errorLabel: "Cerebras",
+        buildRequest: buildOpenAiStyleRequest("https://api.cerebras.ai/v1/chat/completions"),
+        parseResponse: parseOpenAiStyleResponse("Cerebras")
+      },
+      gemini: {
+        providerId: "gemini",
+        apiOperation: "generateContent",
+        errorLabel: "Gemini",
+        buildRequest: buildGeminiRequest,
+        parseResponse: parseGeminiResponse
+      },
+      openrouter: {
+        providerId: "openrouter",
+        apiOperation: "chat/completions",
+        errorLabel: "OpenRouter",
+        buildRequest: buildOpenAiStyleRequest("https://openrouter.ai/api/v1/chat/completions"),
+        parseResponse: parseOpenAiGPT5ThinkingStyleResponse("OpenRouter")
+      }
+    };
+  })(providerConfig);
+  return providerConfig;
+}
+
+var hasRequiredHttpLlmClient;
+function requireHttpLlmClient() {
+  if (hasRequiredHttpLlmClient) return httpLlmClient;
+  hasRequiredHttpLlmClient = 1;
+  Object.defineProperty(httpLlmClient, "__esModule", { value: true });
+  httpLlmClient.HttpLlmClient = void 0;
+  const model_info_1 = requireModelInfo();
+  const logger_1 = requireLogger();
+  const provider_config_1 = requireProviderConfig();
+  class HttpLlmClient {
+    constructor(providerId, apiKey, logger) {
+      this.providerId = providerId;
+      this.apiKey = apiKey;
+      this.logger = logger;
+    }
+    async sendRequest(prompt, model, maxTokens, assistantPrefillPrompt) {
+      const provider = provider_config_1.providerConfigs[this.providerId];
+      if (!provider) {
+        throw new Error(`Unknown LLM provider: ${this.providerId}`);
+      }
+      const providerSpecificModelName = model_info_1.SUPPORTED_MODELS[model].find((pm) => pm.provider === this.providerId);
+      if (!providerSpecificModelName) {
+        throw new Error(`LLM Provider ${this.providerId} does not support model ${model}. If this is an error and the provider does support this model, please contact us to fix it`);
+      }
+      const requestOptions = provider.buildRequest({
+        prompt,
+        model: providerSpecificModelName.providerModelName,
+        maxTokens,
+        assistantPrefillPrompt
+      }, this.apiKey);
+      const method = requestOptions.method ?? "POST";
+      const headers = requestOptions.headers ?? {};
+      const bodyPayload = requestOptions.body;
+      const body = typeof bodyPayload === "string" ? bodyPayload : bodyPayload !== void 0 ? JSON.stringify(bodyPayload) : void 0;
+      const spanId = (0, logger_1.generateSpanId)();
+      const startTime = Date.now();
+      (0, logger_1.logLlmCallStart)(this.logger, spanId, provider.providerId, provider.apiOperation, {
+        url: requestOptions.loggableUrl ?? requestOptions.url,
+        httpMethod: method,
+        model,
+        maxTokens
+      });
+      try {
+        const response = await fetch(requestOptions.url, {
+          method,
+          headers,
+          body
+        });
+        const parsedResponse = await provider.parseResponse(response);
+        const duration = Date.now() - startTime;
+        (0, logger_1.logLlmCallComplete)(this.logger, spanId, provider.providerId, provider.apiOperation, {
+          status: response.status,
+          responseText: parsedResponse.text,
+          headers: Object.fromEntries(response.headers.entries()),
+          usage: parsedResponse.usage
+        }, duration);
+        return parsedResponse;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        (0, logger_1.logLlmCallError)(this.logger, spanId, provider.providerId, provider.apiOperation, error, duration);
+        throw new Error(`${provider.errorLabel} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+  }
+  httpLlmClient.HttpLlmClient = HttpLlmClient;
+  return httpLlmClient;
+}
+
+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.`
+    ].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;
+    };
+    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;
+    };
+    return {
+      buildSystemPrompt,
+      buildFullPrompt
+    };
+  };
+  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 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 model_info_1 = requireModelInfo();
+  const cast_array_prompt_builder_1 = __importDefault(requireCastArrayPromptBuilder());
+  const cast_prompt_builder_1 = __importDefault(requireCastPromptBuilder());
+  const nua_errors_1 = requireNuaErrors();
+  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));
+        }
+      });
+    }
+    getClientForModel(model) {
+      const supported = model_info_1.SUPPORTED_MODELS[model];
+      if (!supported || supported.length === 0) {
+        throw new Error(`Model ${model} is not supported or configuration is missing.`);
+      }
+      for (const option of supported) {
+        if (this.clients.has(option.provider)) {
+          return this.clients.get(option.provider);
+        }
+      }
+      throw new Error(`No configured provider found for model ${model}. Please check your API keys.`);
+    }
+    resolveModel(modelName) {
+      const result = (0, model_info_1.parseCanonicalModelName)(modelName);
+      if ((0, nua_errors_1.isNuaValidationError)(result)) {
+        throw new Error(result.message);
+      }
+      return result;
+    }
+    async castValue(params) {
+      const model = this.resolveModel(params.model);
+      const client = this.getClientForModel(model);
+      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,
+          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)
+        };
+      }
+    }
+    async castArray(params) {
+      const model = this.resolveModel(params.model);
+      const client = this.getClientForModel(model);
+      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);
+      try {
+        const result = await (0, call_llm_service_1.callLLM)(client, prompt, model, maxTokens, temperature, 3, validationFn);
+        return {
+          success: true,
+          data: result.data,
+          usage: result.usage,
+          prompt
+        };
+      } catch (e) {
+        return {
+          success: false,
+          error: e instanceof Error ? e.message : String(e)
+        };
+      }
+    }
+  }
+  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;
+    }
+    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 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 {
+      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;
+    };
+    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 });
+  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;
+    }
+    return properties[outputName] ?? null;
+  }
+  return schemaUtils;
+}
+
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports$1) {
+    var __createBinding = dist && dist.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    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.stableStringify = exports$1.validateJsonSchema = exports$1.providerConfigs = exports$1.normalizedUsageZero = exports$1.castArrayPromptBuilder = exports$1.castPromptBuilder = void 0;
+    __exportStar(requireNuaLlmClient(), exports$1);
+    __exportStar(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, "normalizedUsageZero", { enumerable: true, get: function() {
+      return provider_config_1.normalizedUsageZero;
+    } });
+    Object.defineProperty(exports$1, "providerConfigs", { enumerable: true, get: function() {
+      return provider_config_1.providerConfigs;
+    } });
+    var validate_json_schema_1 = requireValidateJsonSchema();
+    Object.defineProperty(exports$1, "validateJsonSchema", { enumerable: true, get: function() {
+      return validate_json_schema_1.validateJsonSchema;
+    } });
+    var stable_stringify_1 = requireStableStringify();
+    Object.defineProperty(exports$1, "stableStringify", { enumerable: true, get: function() {
+      return stable_stringify_1.stableStringify;
+    } });
+    __exportStar(requireModelInfo(), exports$1);
+    __exportStar(requireSchemaUtils(), exports$1);
+  })(dist);
+  return dist;
+}
+
+var distExports = requireDist();
+
 const normalizedUsageZero = {
   promptTokens: 0,
   completionTokens: 0,
@@ -13,7 +1211,7 @@ class DirectBackend {
       throw new Error("model is required for direct mode");
     }
     this.model = config.model;
-    this.client = new NuaLlmClient({ providers: config.providers });
+    this.client = new distExports.NuaLlmClient({ providers: config.providers });
   }
   async castValue(params) {
     const startTime = Date.now();
@@ -43,7 +1241,7 @@ class DirectBackend {
   }
   async castArray(params) {
     const startTime = Date.now();
-    const wrappedSchema = wrapArraySchema(params.outputSchema, {
+    const wrappedSchema = distExports.wrapArraySchema(params.outputSchema, {
       primaryKey: params.primaryKey,
       outputName: params.outputName
     });