nuabase 1.2.0 → 2.1.0

package/dist/esm/index.mjs

@@ -1,60 +1,1289 @@
+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';
 
-function resolveConfigValue(config, key, envVar) {
-  if (config[key]) return config[key];
-  const pe = globalThis.process;
-  const isNode = !!pe?.versions?.node;
-  if (isNode) {
-    return pe?.env?.[envVar];
+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 || "");
+    }
   }
-  return void 0;
+  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;
 }
 
-async function parseErrorResponse(response, urlPath) {
-  const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-  let responseBody = "";
-  try {
-    responseBody = (await response.text()).trim();
-  } catch {
-    return { error: fallbackMessage, isError: true };
+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;
   }
-  if (!responseBody) {
-    return { error: fallbackMessage, isError: true };
+  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
+    };
   }
-  const parsedBody = safeParseJson(responseBody);
-  if (parsedBody && typeof parsedBody === "object") {
-    const errorMessage = extractErrorMessage(parsedBody);
-    if (errorMessage) {
-      return { error: errorMessage, isError: true };
+  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 { error: responseBody, isError: true };
+  return llmResponseExtraction;
 }
-function safeParseJson(payload) {
-  try {
-    return JSON.parse(payload);
-  } catch {
-    return void 0;
+
+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;
 }
-function extractErrorMessage(body) {
-  const e = body["error"];
-  if (e && typeof e === "string") return e;
-  return void 0;
+
+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;
 }
 
-function isErrorWithMessage(error) {
-  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+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;
 }
-function getErrorMessageFromException(error) {
-  if (isErrorWithMessage(error)) {
-    return error.message;
+
+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"}`);
+      }
+    }
   }
-  return String(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,
+  totalTokens: 0
+};
+class DirectBackend {
+  constructor(config) {
+    if (!config.model) {
+      throw new Error("model is required for direct mode");
+    }
+    this.model = config.model;
+    this.client = new distExports.NuaLlmClient({ providers: config.providers });
+  }
+  async castValue(params) {
+    const startTime = Date.now();
+    const result = await this.client.castValue({
+      model: this.model,
+      input: { prompt: params.prompt, data: params.data },
+      output: { name: params.outputName, effectiveSchema: 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: this.model,
+      latencyMs,
+      source: "direct",
+      meta: {}
+    };
+  }
+  async castArray(params) {
+    const startTime = Date.now();
+    const wrappedSchema = distExports.wrapArraySchema(params.outputSchema, {
+      primaryKey: params.primaryKey,
+      outputName: params.outputName
+    });
+    const result = await this.client.castArray({
+      model: this.model,
+      data: params.data,
+      input: { prompt: params.prompt, primaryKey: params.primaryKey },
+      output: { name: params.outputName, effectiveSchema: wrappedSchema }
+    });
+    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: this.model,
+      latencyMs,
+      source: "direct",
+      meta: {}
+    };
+  }
+}
+
+function resolveConfigValue(config, key, envVar) {
+  if (config[key]) return config[key];
+  const pe = globalThis.process;
+  const isNode = !!pe?.versions?.node;
+  if (isNode) {
+    return pe?.env?.[envVar];
+  }
+  return void 0;
 }
 
 const isBrowserEnvironment = () => typeof window !== "undefined" && !!window.document;
-class NuabaseAuthTokenManager {
+class AuthTokenManager {
   constructor(config) {
     this.apiKey = resolveConfigValue(config, "apiKey", "NUABASE_API_KEY") || void 0;
     this.fetchToken = config.fetchToken;
@@ -96,403 +1325,262 @@ class NuabaseAuthTokenManager {
     return this.pendingTokenPromise;
   }
 }
-class NuabaseAPIClient {
-  constructor(config = {}) {
+
+async function parseErrorResponse(response, urlPath) {
+  const fallbackMessage = `Request to ${urlPath} failed with status ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  let responseBody = "";
+  try {
+    responseBody = (await response.text()).trim();
+  } catch {
+    return { error: fallbackMessage, isError: true };
+  }
+  if (!responseBody) {
+    return { error: fallbackMessage, isError: true };
+  }
+  const parsedBody = safeParseJson(responseBody);
+  if (parsedBody && typeof parsedBody === "object") {
+    const errorMessage = extractErrorMessage(parsedBody);
+    if (errorMessage) {
+      return { error: errorMessage, isError: true };
+    }
+  }
+  return { error: responseBody, isError: true };
+}
+function safeParseJson(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
+}
+function extractErrorMessage(body) {
+  const parts = [];
+  const error = body["error"];
+  if (typeof error === "string" && error.trim()) {
+    parts.push(error.trim());
+  }
+  const message = body["message"];
+  if (typeof message === "string" && message.trim()) {
+    parts.push(message.trim());
+  }
+  if (parts.length === 0) return void 0;
+  return parts.join(". ");
+}
+
+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);
+}
+
+function isErrorResponse(response) {
+  return Boolean(response && typeof response === "object" && "error" in response);
+}
+class GatewayBackend {
+  constructor(config) {
     this.baseUrl = resolveConfigValue(config, "baseUrl", "NUABASE_API_URL") || "https://api.nuabase.com";
-    this.authTokenManager = new NuabaseAuthTokenManager(config);
+    this.authManager = new AuthTokenManager(config);
   }
-  async request(method, urlPath, params) {
-    const url = `${this.baseUrl}/${urlPath}`;
+  async castValue(params) {
+    const startTime = Date.now();
+    const response = await this.post("cast/value/now", {
+      input: { prompt: params.prompt, data: params.data },
+      output: { name: params.outputName, schema: params.outputSchema }
+    });
+    const latencyMs = Date.now() - startTime;
+    if (isErrorResponse(response)) {
+      return { success: false, error: response.error, source: "gateway", latencyMs };
+    }
+    const apiResponse = response;
+    const usage = {
+      promptTokens: apiResponse.llmUsage.promptTokens + apiResponse.cacheUsage.promptTokens,
+      completionTokens: apiResponse.llmUsage.completionTokens + apiResponse.cacheUsage.completionTokens,
+      totalTokens: apiResponse.llmUsage.totalTokens + apiResponse.cacheUsage.totalTokens
+    };
+    return {
+      success: true,
+      data: apiResponse.data,
+      usage,
+      model: apiResponse.model ?? "unknown",
+      latencyMs,
+      source: "gateway",
+      meta: {
+        requestId: apiResponse.llmRequestId,
+        cached: apiResponse.isCacheHit,
+        llmUsage: apiResponse.llmUsage,
+        cacheUsage: apiResponse.cacheUsage
+      }
+    };
+  }
+  async castArray(params) {
+    const startTime = Date.now();
+    const response = await this.post("cast/array/now", {
+      input: { prompt: params.prompt, data: params.data, primaryKey: params.primaryKey },
+      output: { name: params.outputName, schema: params.outputSchema }
+    });
+    const latencyMs = Date.now() - startTime;
+    if (isErrorResponse(response)) {
+      return { success: false, error: response.error, source: "gateway", latencyMs };
+    }
+    const apiResponse = response;
+    const usage = {
+      promptTokens: apiResponse.llmUsage.promptTokens + apiResponse.cacheUsage.promptTokens,
+      completionTokens: apiResponse.llmUsage.completionTokens + apiResponse.cacheUsage.completionTokens,
+      totalTokens: apiResponse.llmUsage.totalTokens + apiResponse.cacheUsage.totalTokens
+    };
+    return {
+      success: true,
+      data: apiResponse.data,
+      usage,
+      model: apiResponse.model ?? "unknown",
+      latencyMs,
+      source: "gateway",
+      meta: {
+        requestId: apiResponse.llmRequestId,
+        cached: apiResponse.cacheHits === apiResponse.data.length,
+        llmUsage: apiResponse.llmUsage,
+        cacheUsage: apiResponse.cacheUsage
+      }
+    };
+  }
+  async queueCastValue(params) {
+    const response = await this.post("cast/value", {
+      input: { prompt: params.prompt, data: params.data },
+      output: { name: params.outputName, schema: params.outputSchema }
+    });
+    if (isErrorResponse(response)) {
+      return { success: false, error: response.error, source: "gateway" };
+    }
+    const apiResponse = response;
+    return { success: true, jobId: apiResponse.jobId, source: "gateway" };
+  }
+  async queueCastArray(params) {
+    const response = await this.post("cast/array", {
+      input: { prompt: params.prompt, data: params.data, primaryKey: params.primaryKey },
+      output: { name: params.outputName, schema: params.outputSchema }
+    });
+    if (isErrorResponse(response)) {
+      return { success: false, error: response.error, source: "gateway" };
+    }
+    const apiResponse = response;
+    return { success: true, jobId: apiResponse.jobId, source: "gateway" };
+  }
+  async post(path, body) {
+    const url = `${this.baseUrl}/${path}`;
     let response;
-    const hasBody = method !== "GET" && params !== void 0;
     const headers = {
-      Authorization: `Bearer ${await this.authTokenManager.getToken()}`
+      Authorization: `Bearer ${await this.authManager.getToken()}`,
+      "Content-Type": "application/json"
     };
-    if (hasBody) {
-      headers["Content-Type"] = "application/json";
-    }
     try {
       response = await fetch(url, {
-        method,
+        method: "POST",
         headers,
-        body: hasBody ? JSON.stringify(params) : void 0
+        body: JSON.stringify(body)
       });
     } catch (e) {
       return { error: `Error calling Nuabase API: ${getErrorMessageFromException(e)}` };
     }
-    let result;
     if (!response.ok) {
-      return await parseErrorResponse(response, urlPath);
+      return await parseErrorResponse(response, path);
     }
     try {
-      result = await response.json();
+      return await response.json();
     } catch {
       return { error: "Invalid response received from Nuabase API call, unable to parse" };
     }
-    return result;
   }
 }
 
-const zs_NuaQueuedResponse = z.object({
-  id: z.string(),
-  sseUrl: z.string().min(1)
-}).strict();
-
-const validateArrayRequestParams = (data, primaryKeyName) => {
-  if (!Array.isArray(data)) {
-    throw new Error("`data` must be an array of objects.");
+class Nua {
+  constructor(backend) {
+    this.backend = backend;
   }
-  if (!primaryKeyName || typeof primaryKeyName !== "string") {
-    throw new Error("`primaryKeyName` must be a non-empty string.");
+  static gateway(config) {
+    return new Nua(new GatewayBackend(config));
   }
-  data.forEach((item, index) => {
-    if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw new Error(`data[${index}] must be a non-null object.`);
-    }
-    if (!(primaryKeyName in item)) {
-      throw new Error(`data[${index}] must contain property '${primaryKeyName}'.`);
+  static direct(config) {
+    return new Nua(new DirectBackend(config));
+  }
+  // Implementation
+  async get(prompt, options) {
+    if (typeof prompt !== "string" || prompt.trim() === "") {
+      throw new TypeError("Prompt must be a non-empty string");
     }
-  });
-};
-
-const zs_NormalizedUsage = z.object({
-  promptTokens: z.number(),
-  completionTokens: z.number(),
-  totalTokens: z.number()
-}).strict();
-
-const zs_ResponseRecord = (primaryKeyName, outputKey, outputSchema) => {
-  const primaryKeySchema = z.any();
-  const shape = {
-    [primaryKeyName]: primaryKeySchema,
-    [outputKey]: outputSchema
-  };
-  return z.object(shape).strict();
-};
-const createNuaApiResponseCastArray = (primaryKeyName, outputKey, outputSchema) => {
-  const recordSchema = zs_ResponseRecord(
-    primaryKeyName,
-    outputKey,
-    outputSchema
-  );
-  const dataSchema = z.array(recordSchema);
-  return z.object({
-    llmRequestId: z.string(),
-    kind: z.literal("cast/array"),
-    data: dataSchema,
-    cacheHits: z.number(),
-    rowsWithNoResults: z.array(z.string()),
-    isSuccess: z.literal(true),
-    isError: z.optional(z.literal(false)),
-    usage: zs_NormalizedUsage
-  }).strict();
-};
-const zs_NuaApiResponse_CastArray = createNuaApiResponseCastArray;
-
-const zs_ArrayFnDef = z.object({
-  prompt: z.string(),
-  output: z.object({
-    name: z.string(),
-    schema: z.custom(
-      (value) => value instanceof z.ZodType,
-      "Expected a Zod schema"
-    )
-  })
-});
-const validateArrayFnDef = (fnDef) => {
-  const parsed = zs_ArrayFnDef.safeParse(fnDef);
-  if (!parsed.success) {
-    const message = z.prettifyError(parsed.error);
-    throw new TypeError(`Invalid array function definition: ${message}`);
-  }
-  return parsed.data;
-};
-
-function addOriginalInputRows(inputRows, outputRows, primaryKeyName) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const row of inputRows) {
-    lookup.set(row[primaryKeyName], row);
+    const outputSchema = options?.output?.schema ?? z.string();
+    const outputName = options?.output?.name ?? "result";
+    const jsonSchema = z.toJSONSchema(outputSchema);
+    return this.backend.castValue({
+      prompt,
+      data: options?.input ?? null,
+      outputName,
+      outputSchema: jsonSchema
+    });
   }
-  return outputRows.map((row) => {
-    const primaryKeyValue = row[primaryKeyName];
-    const sourceRow = lookup.get(primaryKeyValue);
-    if (!sourceRow) {
-      throw new Error(
-        `Unable to locate source row for primary key "${String(primaryKeyValue)}" in cast array response.`
-      );
+  // ========== list() - Array Operations ==========
+  async list(prompt, options) {
+    if (typeof prompt !== "string" || prompt.trim() === "") {
+      throw new TypeError("Prompt must be a non-empty string");
     }
-    return {
-      ...row,
-      sourceRow
-    };
-  });
-}
-const toCastArrayApiRequest = (prompt, data, primaryKeyName, outputName, outputSchema) => ({
-  input: {
-    prompt,
-    data,
-    primaryKey: primaryKeyName
-  },
-  output: {
-    schema: outputSchema,
-    name: outputName
-  }
-});
-const createArrayFn = (client, inputFnDef) => {
-  const fnDef = validateArrayFnDef(inputFnDef);
-  const outputJsonSchema = z.toJSONSchema(fnDef.output.schema);
-  const toNuabaseError = (response) => {
-    if (response && typeof response === "object" && "error" in response)
-      return { error: String(response.error), isError: true };
-    return void 0;
-  };
-  const queueFn = async (data, primaryKeyName) => {
-    validateArrayRequestParams(data, primaryKeyName);
-    const response = await client.request(
-      "POST",
-      "cast/array",
-      toCastArrayApiRequest(
-        fnDef.prompt,
-        data,
-        primaryKeyName,
-        fnDef.output.name,
-        outputJsonSchema
-      )
-    );
-    const error = toNuabaseError(response);
-    if (error) return error;
-    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
-    if (!parsedResponse.success) {
-      const emsg = z.prettifyError(parsedResponse.error);
-      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
-    }
-    return parsedResponse.data;
-  };
-  const baseNowFn = async (data, primaryKeyName) => {
-    validateArrayRequestParams(data, primaryKeyName);
-    const response = await client.request(
-      "POST",
-      "cast/array/now",
-      toCastArrayApiRequest(
-        fnDef.prompt,
-        data,
-        primaryKeyName,
-        fnDef.output.name,
-        outputJsonSchema
-      )
-    );
-    const error = toNuabaseError(response);
-    if (error) return error;
-    const outputKey = fnDef.output.name;
-    const successSchema = zs_NuaApiResponse_CastArray(primaryKeyName, outputKey, fnDef.output.schema);
-    const parsedResponse = successSchema.safeParse(response);
-    if (!parsedResponse.success) {
-      const emsg = z.prettifyError(parsedResponse.error);
-      return { error: `Invalid data received from Nuabase API: ${emsg}`, isError: true };
+    if (!Array.isArray(options.input)) {
+      throw new TypeError("Input must be an array for list()");
     }
-    return {
-      isSuccess: true,
-      llmRequestId: parsedResponse.data.llmRequestId,
-      kind: parsedResponse.data.kind,
-      data: addOriginalInputRows(
-        data,
-        parsedResponse.data.data,
-        primaryKeyName
-      ),
-      rowsWithNoResults: parsedResponse.data.rowsWithNoResults,
-      cacheHits: parsedResponse.data.cacheHits,
-      usage: parsedResponse.data.usage
-    };
-  };
-  return Object.assign(baseNowFn, {
-    queue: queueFn
-  });
-};
-
-const createNuaApiResponseCastValue = (outputKey, outputSchema) => {
-  return z.object({
-    llmRequestId: z.string(),
-    kind: z.literal("cast/value"),
-    data: outputSchema,
-    isCacheHit: z.boolean(),
-    isSuccess: z.literal(true),
-    isError: z.optional(z.literal(false)),
-    usage: zs_NormalizedUsage
-  }).strict();
-};
-const zs_NuaApiResponse_CastValue = createNuaApiResponseCastValue;
-
-const zs_ValueFnDef = z.object({
-  prompt: z.string(),
-  output: z.object({
-    name: z.string(),
-    schema: z.custom(
-      (value) => value instanceof z.ZodType,
-      "Expected a Zod schema for `output.schema`"
-    )
-  })
-});
-const validateValueFnDef = (fnDef) => {
-  const parsed = zs_ValueFnDef.safeParse(fnDef);
-  if (!parsed.success) {
-    const message = z.prettifyError(parsed.error);
-    throw new TypeError(`Invalid value function definition: ${message}`);
-  }
-  return parsed.data;
-};
-
-const toCastValueApiRequest = (prompt, data, outputName, outputSchema) => ({
-  input: {
-    prompt,
-    data
-  },
-  output: {
-    schema: outputSchema,
-    name: outputName
-  }
-});
-const createValueFn = (client, inputFnDef) => {
-  const fnDef = validateValueFnDef(inputFnDef);
-  const outputJsonSchema = z.toJSONSchema(fnDef.output.schema);
-  const toNuabaseError = (response) => {
-    if (response && typeof response === "object" && "error" in response)
-      return { error: String(response.error), isError: true };
-    return void 0;
-  };
-  const sendRequest = async (path, data) => client.request(
-    "POST",
-    path,
-    toCastValueApiRequest(fnDef.prompt, data, fnDef.output.name, outputJsonSchema)
-  );
-  const queueFn = async (data) => {
-    const response = await sendRequest("cast/value", data);
-    const error = toNuabaseError(response);
-    if (error) return error;
-    const parsedResponse = zs_NuaQueuedResponse.safeParse(response);
-    if (!parsedResponse.success) {
-      const emsg = z.prettifyError(parsedResponse.error);
-      return { error: `Invalid queued response received from Nuabase API: ${emsg}`, isError: true };
-    }
-    return parsedResponse.data;
-  };
-  const baseNowFn = async (data) => {
-    const response = await sendRequest("cast/value/now", data);
-    const error = toNuabaseError(response);
-    if (error) return error;
-    const outputKey = fnDef.output.name;
-    const successSchema = zs_NuaApiResponse_CastValue(
-      outputKey,
-      fnDef.output.schema
-    );
-    const parsedResponse = successSchema.safeParse(response);
-    if (!parsedResponse.success) {
-      const emsg = z.prettifyError(parsedResponse.error);
-      return { error: `Invalid data received from Nuabase API: ${emsg}`, isError: true };
+    if (typeof options.primaryKey !== "string" || options.primaryKey.trim() === "") {
+      throw new TypeError("primaryKey must be a non-empty string");
     }
-    return {
-      isSuccess: true,
-      llmRequestId: parsedResponse.data.llmRequestId,
-      kind: parsedResponse.data.kind,
-      data: parsedResponse.data.data,
-      isCacheHit: parsedResponse.data.isCacheHit,
-      usage: parsedResponse.data.usage
-    };
-  };
-  return Object.assign(baseNowFn, {
-    queue: queueFn
-  });
-};
-
-const errorParseFailed = {
-  kind: "internal-error",
-  message: "Unable to parse stored LLM result"
-};
-const dateFromIso = z.preprocess(
-  (value) => {
-    if (value == null) return null;
-    if (value instanceof Date) return value;
-    if (typeof value === "string") {
-      const parsed = new Date(value);
-      if (!Number.isNaN(parsed.getTime())) return parsed;
-    }
-    return z.NEVER;
-  },
-  z.union([z.date(), z.null()])
-);
-const mandatoryDateFromIso = z.preprocess((value) => {
-  if (value instanceof Date) return value;
-  if (typeof value === "string") {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.getTime())) return parsed;
-  }
-  return z.NEVER;
-}, z.date());
-const apiResponseSchema = z.object({
-  id: z.string(),
-  requestType: z.string(),
-  llmStatus: z.union([
-    z.literal("pending"),
-    z.literal("processing"),
-    z.literal("success"),
-    z.literal("failed")
-  ]),
-  sseStatus: z.union([
-    z.literal("n/a"),
-    z.literal("pending"),
-    z.literal("sent"),
-    z.literal("failed")
-  ]),
-  webhookStatus: z.union([
-    z.literal("n/a"),
-    z.literal("pending"),
-    z.literal("sent"),
-    z.literal("failed")
-  ]),
-  input: z.object({
-    prompt: z.union([z.string(), z.null()]),
-    data: z.union([z.string(), z.null()]),
-    primaryKey: z.union([z.string(), z.null()])
-  }),
-  output: z.object({
-    name: z.string(),
-    schema: z.string(),
-    effectiveSchema: z.string()
-  }),
-  result: z.union([z.record(z.string(), z.unknown()), z.null()]).optional(),
-  error: z.union([z.string(), z.null()]),
-  fullPrompt: z.string(),
-  model: z.string(),
-  provider: z.string(),
-  startedAt: dateFromIso,
-  finishedAt: dateFromIso,
-  createdAt: mandatoryDateFromIso,
-  updatedAt: mandatoryDateFromIso
-});
-const isNuabaseError = (value) => Boolean(value && typeof value === "object" && "isError" in value && value.isError);
-async function getRequest(client, llmRequestId) {
-  const response = await client.request("GET", `requests/${encodeURIComponent(llmRequestId)}`);
-  if (isNuabaseError(response)) {
-    return response;
-  }
-  const parsedResponse = apiResponseSchema.safeParse(response);
-  if (!parsedResponse.success) {
-    return errorParseFailed;
-  }
-  return parsedResponse.data;
-}
-
-class Nua {
-  constructor(config) {
-    this.apiClient = new NuabaseAPIClient(config);
+    const jsonSchema = z.toJSONSchema(options.output.schema);
+    return this.backend.castArray({
+      prompt,
+      data: options.input,
+      primaryKey: options.primaryKey,
+      outputName: options.output.name,
+      outputSchema: jsonSchema
+    });
   }
-  createArrayFn(fnDef) {
-    return createArrayFn(this.apiClient, fnDef);
-  }
-  createFn(fnDef) {
-    return createValueFn(this.apiClient, fnDef);
+  // Implementation
+  async queueGet(prompt, options) {
+    if (typeof prompt !== "string" || prompt.trim() === "") {
+      throw new TypeError("Prompt must be a non-empty string");
+    }
+    if (!this.backend.queueCastValue) {
+      throw new Error("Queue operations are only supported in gateway mode");
+    }
+    const outputSchema = options?.output?.schema ?? z.string();
+    const outputName = options?.output?.name ?? "result";
+    const jsonSchema = z.toJSONSchema(outputSchema);
+    return this.backend.queueCastValue({
+      prompt,
+      data: options?.input ?? null,
+      outputName,
+      outputSchema: jsonSchema
+    });
   }
-  async getRequest(llmRequestId) {
-    return getRequest(this.apiClient, llmRequestId);
+  // ========== queueList() - Async Array Operations ==========
+  async queueList(prompt, options) {
+    if (typeof prompt !== "string" || prompt.trim() === "") {
+      throw new TypeError("Prompt must be a non-empty string");
+    }
+    if (!this.backend.queueCastArray) {
+      throw new Error("Queue operations are only supported in gateway mode");
+    }
+    if (!Array.isArray(options.input)) {
+      throw new TypeError("Input must be an array for queueList()");
+    }
+    if (typeof options.primaryKey !== "string" || options.primaryKey.trim() === "") {
+      throw new TypeError("primaryKey must be a non-empty string");
+    }
+    const jsonSchema = z.toJSONSchema(options.output.schema);
+    return this.backend.queueCastArray({
+      prompt,
+      data: options.input,
+      primaryKey: options.primaryKey,
+      outputName: options.output.name,
+      outputSchema: jsonSchema
+    });
   }
 }