@dexto/core 1.5.7 → 1.6.0

package/dist/llm/registry/index.cjs

@@ -0,0 +1,806 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  DEFAULT_MAX_INPUT_TOKENS: () => DEFAULT_MAX_INPUT_TOKENS,
+  LLM_REGISTRY: () => LLM_REGISTRY,
+  MIME_TYPE_TO_FILE_TYPE: () => MIME_TYPE_TO_FILE_TYPE,
+  acceptsAnyModel: () => acceptsAnyModel,
+  calculateCost: () => calculateCost,
+  getAllModelsForProvider: () => getAllModelsForProvider,
+  getAllSupportedModels: () => getAllSupportedModels,
+  getAllowedMimeTypes: () => getAllowedMimeTypes,
+  getDefaultModelForProvider: () => getDefaultModelForProvider,
+  getEffectiveMaxInputTokens: () => getEffectiveMaxInputTokens,
+  getMaxInputTokensForModel: () => getMaxInputTokensForModel,
+  getModelDisplayName: () => getModelDisplayName,
+  getModelPricing: () => getModelPricing,
+  getOpenRouterCandidateModelIds: () => getOpenRouterCandidateModelIds,
+  getProviderFromModel: () => getProviderFromModel,
+  getSupportedFileTypesForModel: () => getSupportedFileTypesForModel,
+  getSupportedModels: () => getSupportedModels,
+  getSupportedProviders: () => getSupportedProviders,
+  hasAllRegistryModelsSupport: () => hasAllRegistryModelsSupport,
+  isModelValidForProvider: () => isModelValidForProvider,
+  isReasoningCapableModel: () => isReasoningCapableModel,
+  isValidProviderModel: () => isValidProviderModel,
+  modelSupportsFileType: () => modelSupportsFileType,
+  requiresApiKey: () => requiresApiKey,
+  requiresBaseURL: () => requiresBaseURL,
+  stripBedrockRegionPrefix: () => stripBedrockRegionPrefix,
+  supportsBaseURL: () => supportsBaseURL,
+  supportsCustomModels: () => supportsCustomModels,
+  transformModelNameForProvider: () => transformModelNameForProvider,
+  validateModelFileSupport: () => validateModelFileSupport
+});
+module.exports = __toCommonJS(registry_exports);
+var import_errors = require("../errors.js");
+var import_error_codes = require("../error-codes.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_types = require("../types.js");
+var import_openrouter_model_registry = require("../providers/openrouter-model-registry.js");
+var import_models_generated = require("./models.generated.js");
+var import_models_manual = require("./models.manual.js");
+const LEGACY_MODEL_ID_ALIASES = {
+  anthropic: {
+    // Older Dexto configs/tests used "claude-4-{tier}-{date}".
+    // models.dev (and our generated snapshot) use "claude-{tier}-4-{date}".
+    "claude-4-sonnet-20250514": "claude-sonnet-4-20250514",
+    "claude-4-opus-20250514": "claude-opus-4-20250514"
+  }
+};
+function getNormalizedModelIdForLookup(provider, model) {
+  const stripped = stripBedrockRegionPrefix(model);
+  const lower = stripped.toLowerCase();
+  const aliases = LEGACY_MODEL_ID_ALIASES[provider];
+  return aliases?.[lower] ?? lower;
+}
+function mergeModels(base, extra) {
+  if (!extra || extra.length === 0) return base;
+  const merged = [...base];
+  const indexByName = /* @__PURE__ */ new Map();
+  for (let i = 0; i < merged.length; i++) {
+    indexByName.set(merged[i].name.toLowerCase(), i);
+  }
+  for (const m of extra) {
+    const key = m.name.toLowerCase();
+    const existingIndex = indexByName.get(key);
+    if (existingIndex != null) {
+      merged[existingIndex] = m;
+    } else {
+      indexByName.set(key, merged.length);
+      merged.push(m);
+    }
+  }
+  return merged;
+}
+const MIME_TYPE_TO_FILE_TYPE = {
+  "application/pdf": "pdf",
+  "audio/mp3": "audio",
+  "audio/mpeg": "audio",
+  "audio/wav": "audio",
+  "audio/x-wav": "audio",
+  "audio/wave": "audio",
+  "audio/webm": "audio",
+  "audio/ogg": "audio",
+  "audio/m4a": "audio",
+  "audio/aac": "audio",
+  // Common image MIME types
+  "image/jpeg": "image",
+  "image/jpg": "image",
+  "image/png": "image",
+  "image/webp": "image",
+  "image/gif": "image"
+};
+function getAllowedMimeTypes() {
+  return Object.keys(MIME_TYPE_TO_FILE_TYPE);
+}
+const DEFAULT_MAX_INPUT_TOKENS = 128e3;
+const LLM_REGISTRY = {
+  openai: {
+    models: mergeModels(import_models_generated.MODELS_BY_PROVIDER.openai, import_models_manual.MANUAL_MODELS_BY_PROVIDER.openai),
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  "openai-compatible": {
+    models: [],
+    // Empty - accepts any model name for custom endpoints
+    baseURLSupport: "required",
+    supportedFileTypes: ["pdf", "image", "audio"],
+    // Allow all types for custom endpoints
+    supportsCustomModels: true
+  },
+  anthropic: {
+    models: import_models_generated.MODELS_BY_PROVIDER.anthropic,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  google: {
+    models: import_models_generated.MODELS_BY_PROVIDER.google,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://console.groq.com/docs/models
+  groq: {
+    models: import_models_generated.MODELS_BY_PROVIDER.groq,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // Groq currently doesn't support file uploads
+  },
+  // https://docs.x.ai/docs/models
+  // Note: XAI API only supports image uploads (JPG/PNG up to 20MB), not PDFs
+  xai: {
+    models: import_models_generated.MODELS_BY_PROVIDER.xai,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://docs.cohere.com/reference/models
+  cohere: {
+    models: import_models_generated.MODELS_BY_PROVIDER.cohere,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://platform.minimax.io/docs/api-reference/text-openai-api
+  // MiniMax provides an OpenAI-compatible endpoint at https://api.minimax.chat/v1
+  minimax: {
+    models: import_models_generated.MODELS_BY_PROVIDER.minimax,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://open.bigmodel.cn/dev/api/normal-model/glm-4
+  // GLM (Zhipu AI) provides an OpenAI-compatible endpoint
+  glm: {
+    models: import_models_generated.MODELS_BY_PROVIDER.glm,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://openrouter.ai/docs
+  // OpenRouter is a unified API gateway providing access to 100+ models from various providers.
+  // Model validation is handled dynamically via openrouter-model-registry.ts
+  openrouter: {
+    models: import_models_generated.MODELS_BY_PROVIDER.openrouter,
+    baseURLSupport: "none",
+    // Fixed endpoint - baseURL auto-injected in resolver, no user override allowed
+    supportedFileTypes: ["pdf", "image", "audio"],
+    // Allow all types - user assumes responsibility
+    supportsCustomModels: true,
+    supportsAllRegistryModels: true
+    // Can serve models from all other providers
+  },
+  // https://docs.litellm.ai/
+  // LiteLLM is an OpenAI-compatible proxy that unifies 100+ LLM providers.
+  // User must host their own LiteLLM proxy and provide the baseURL.
+  litellm: {
+    models: [],
+    baseURLSupport: "required",
+    supportedFileTypes: ["pdf", "image", "audio"],
+    supportsCustomModels: true
+  },
+  // https://glama.ai/
+  // Glama is an OpenAI-compatible gateway providing unified access to multiple LLM providers.
+  // Fixed endpoint: https://glama.ai/api/gateway/openai/v1
+  glama: {
+    models: [],
+    baseURLSupport: "none",
+    supportedFileTypes: ["pdf", "image", "audio"],
+    supportsCustomModels: true
+  },
+  // https://cloud.google.com/vertex-ai
+  vertex: {
+    models: import_models_generated.MODELS_BY_PROVIDER.vertex,
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://docs.aws.amazon.com/bedrock/latest/userguide/models.html
+  bedrock: {
+    models: import_models_generated.MODELS_BY_PROVIDER.bedrock,
+    baseURLSupport: "none",
+    supportedFileTypes: [],
+    // No defaults - models must explicitly specify support
+    supportsCustomModels: true
+  },
+  // Native local model execution via node-llama-cpp
+  local: {
+    models: [],
+    // Populated dynamically from local model registry
+    baseURLSupport: "none",
+    supportedFileTypes: ["image"],
+    supportsCustomModels: true
+  },
+  // Ollama server integration
+  ollama: {
+    models: [],
+    // Populated dynamically from Ollama API
+    baseURLSupport: "optional",
+    supportedFileTypes: ["image"],
+    supportsCustomModels: true
+  },
+  // Dexto Gateway - OpenAI-compatible proxy through api.dexto.ai
+  // Routes to OpenRouter with per-request billing (balance decrement)
+  // Requires DEXTO_API_KEY from dexto login
+  //
+  // Model IDs are in OpenRouter format (e.g., 'anthropic/claude-sonnet-4.5')
+  "dexto-nova": {
+    models: [
+      // Claude models (Anthropic via OpenRouter)
+      {
+        name: "anthropic/claude-haiku-4.5",
+        displayName: "Claude 4.5 Haiku",
+        maxInputTokens: 2e5,
+        default: true,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 1,
+          outputPerM: 5,
+          cacheWritePerM: 1.25,
+          cacheReadPerM: 0.1,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "anthropic/claude-sonnet-4.5",
+        displayName: "Claude 4.5 Sonnet",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheWritePerM: 3.75,
+          cacheReadPerM: 0.3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "anthropic/claude-opus-4.5",
+        displayName: "Claude 4.5 Opus",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 5,
+          outputPerM: 25,
+          cacheWritePerM: 6.25,
+          cacheReadPerM: 0.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      // OpenAI models (via OpenRouter)
+      {
+        name: "openai/gpt-5.2",
+        displayName: "GPT-5.2",
+        maxInputTokens: 4e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 1.75,
+          outputPerM: 14,
+          cacheReadPerM: 0.175,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "openai/gpt-5.2-codex",
+        displayName: "GPT-5.2 Codex",
+        maxInputTokens: 4e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 1.75,
+          outputPerM: 14,
+          cacheReadPerM: 0.175,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      // Google models (via OpenRouter)
+      {
+        name: "google/gemini-3-pro-preview",
+        displayName: "Gemini 3 Pro",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"]
+      },
+      {
+        name: "google/gemini-3-flash-preview",
+        displayName: "Gemini 3 Flash",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"]
+      },
+      // Free models (via OpenRouter)
+      {
+        name: "qwen/qwen3-coder:free",
+        displayName: "Qwen3 Coder (Free)",
+        maxInputTokens: 262e3,
+        supportedFileTypes: []
+      },
+      {
+        name: "deepseek/deepseek-r1-0528:free",
+        displayName: "DeepSeek R1 (Free)",
+        maxInputTokens: 163840,
+        supportedFileTypes: []
+      },
+      // Other models (via OpenRouter)
+      {
+        name: "z-ai/glm-4.7",
+        displayName: "GLM 4.7",
+        maxInputTokens: 202752,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.27,
+          outputPerM: 1.1,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "minimax/minimax-m2.1",
+        displayName: "Minimax M2.1",
+        maxInputTokens: 196608,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.2,
+          outputPerM: 0.6,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "moonshotai/kimi-k2.5",
+        displayName: "Kimi K2.5",
+        maxInputTokens: 262144,
+        supportedFileTypes: ["image"],
+        pricing: {
+          inputPerM: 0.5,
+          outputPerM: 2.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    baseURLSupport: "none",
+    supportedFileTypes: ["pdf", "image", "audio"],
+    supportsCustomModels: true,
+    supportsAllRegistryModels: true
+  }
+};
+function stripBedrockRegionPrefix(model) {
+  if (model.startsWith("eu.") || model.startsWith("us.")) {
+    return model.slice(3);
+  }
+  if (model.startsWith("global.")) {
+    return model.slice(7);
+  }
+  return model;
+}
+function getDefaultModelForProvider(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const explicit = providerInfo.models.find((m) => m.default)?.name;
+  if (explicit) return explicit;
+  if (providerInfo.models.length === 0) return null;
+  const sorted = [...providerInfo.models].sort((a, b) => a.name.localeCompare(b.name));
+  return sorted[0]?.name ?? null;
+}
+function getSupportedProviders() {
+  return [...import_types.LLM_PROVIDERS];
+}
+function getSupportedModels(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.map((m) => m.name);
+}
+function getMaxInputTokensForModel(provider, model, logger) {
+  const modelInfo = findModelInfo(provider, model);
+  if (!modelInfo) {
+    if ((provider === "openrouter" || provider === "dexto-nova") && model.includes("/")) {
+      const contextLength = (0, import_openrouter_model_registry.getOpenRouterModelContextLength)(model);
+      if (typeof contextLength === "number") {
+        logger?.debug(
+          `Using max tokens from OpenRouter cache for ${provider}/${model}: ${contextLength}`
+        );
+        return contextLength;
+      }
+    }
+    const supportedModels = getSupportedModels(provider).join(", ");
+    logger?.error(
+      `Model '${model}' not found for provider '${provider}' in LLM registry. Supported models: ${supportedModels}`
+    );
+    throw import_errors.LLMError.unknownModel(provider, model);
+  }
+  logger?.debug(`Found max tokens for ${provider}/${model}: ${modelInfo.maxInputTokens}`);
+  return modelInfo.maxInputTokens;
+}
+function isValidProviderModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const normalizedModel = getNormalizedModelIdForLookup(provider, model);
+  return providerInfo.models.some((m) => m.name.toLowerCase() === normalizedModel);
+}
+function getProviderFromModel(model) {
+  if (model.includes("/")) {
+    throw import_errors.LLMError.modelProviderUnknown(model);
+  }
+  for (const provider of import_types.LLM_PROVIDERS) {
+    const info = LLM_REGISTRY[provider];
+    const normalizedModel = getNormalizedModelIdForLookup(provider, model);
+    if (info.models.some((m) => m.name.toLowerCase() === normalizedModel)) {
+      return provider;
+    }
+  }
+  throw import_errors.LLMError.modelProviderUnknown(model);
+}
+function getAllSupportedModels() {
+  return Object.values(LLM_REGISTRY).flatMap((info) => info.models.map((m) => m.name));
+}
+function supportsBaseURL(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.baseURLSupport !== "none";
+}
+function requiresBaseURL(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.baseURLSupport === "required";
+}
+function acceptsAnyModel(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.length === 0;
+}
+function supportsCustomModels(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.supportsCustomModels === true;
+}
+function hasAllRegistryModelsSupport(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.supportsAllRegistryModels === true;
+}
+const OPENROUTER_PREFIX_BY_PROVIDER = {
+  openai: "openai",
+  anthropic: "anthropic",
+  google: "google",
+  xai: "x-ai",
+  cohere: "cohere",
+  minimax: "minimax",
+  glm: "z-ai"
+};
+function getOpenRouterModelIdSet() {
+  return new Set(LLM_REGISTRY.openrouter.models.map((m) => m.name.toLowerCase()));
+}
+function getOpenRouterCandidateModelIds(model, originalProvider) {
+  if (model.includes("/")) return [model];
+  const prefix = OPENROUTER_PREFIX_BY_PROVIDER[originalProvider];
+  if (!prefix) return [];
+  if (originalProvider === "anthropic") {
+    const noDate = model.replace(/-\d{8}.*$/i, "");
+    const dotted = noDate.replace(/-(\d)-(\d)\b/g, "-$1.$2");
+    return [`${prefix}/${dotted}`, `${prefix}/${noDate}`, `${prefix}/${model}`];
+  }
+  if (originalProvider === "google") {
+    if (!/^gemini-/i.test(model)) {
+      return [`${prefix}/${model}`];
+    }
+    return [`${prefix}/${model}`, `${prefix}/${model}-001`];
+  }
+  return [`${prefix}/${model}`];
+}
+function pickExistingOpenRouterModelId(candidates) {
+  const openrouterSet = getOpenRouterModelIdSet();
+  for (const candidate of candidates) {
+    if (openrouterSet.has(candidate.toLowerCase())) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function findModelInfo(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const normalizedModel = getNormalizedModelIdForLookup(provider, model);
+  const direct = providerInfo.models.find((m) => m.name.toLowerCase() === normalizedModel);
+  if (direct) return direct;
+  if (provider !== "openrouter" && hasAllRegistryModelsSupport(provider) && model.includes("/")) {
+    const openrouterModel = LLM_REGISTRY.openrouter.models.find(
+      (m) => m.name.toLowerCase() === model.toLowerCase()
+    );
+    if (openrouterModel) return openrouterModel;
+  }
+  return null;
+}
+function getAllModelsForProvider(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  if (!providerInfo.supportsAllRegistryModels) {
+    return providerInfo.models.map((m) => ({ ...m }));
+  }
+  const allModels = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const model of providerInfo.models) {
+    const key = model.name.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    allModels.push({ ...model, originalProvider: provider });
+  }
+  if (provider !== "openrouter") {
+    for (const model of LLM_REGISTRY.openrouter.models) {
+      const key = model.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      allModels.push({ ...model, originalProvider: "openrouter" });
+    }
+  }
+  return allModels;
+}
+function transformModelNameForProvider(model, originalProvider, targetProvider) {
+  if (!hasAllRegistryModelsSupport(targetProvider)) {
+    return model;
+  }
+  if (hasAllRegistryModelsSupport(originalProvider)) {
+    return model;
+  }
+  if (model.includes("/")) {
+    return model;
+  }
+  const candidates = getOpenRouterCandidateModelIds(model, originalProvider);
+  if (candidates.length === 0) return model;
+  return pickExistingOpenRouterModelId(candidates) ?? candidates[0];
+}
+function isModelValidForProvider(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const normalizedModel = getNormalizedModelIdForLookup(provider, model);
+  if (providerInfo.models.some((m) => m.name.toLowerCase() === normalizedModel)) {
+    return true;
+  }
+  if (providerInfo.supportsAllRegistryModels && !model.includes("/")) {
+    return false;
+  }
+  if (providerInfo.supportsCustomModels) {
+    return true;
+  }
+  if (providerInfo.supportsAllRegistryModels) {
+    return findModelInfo(provider, model) !== null;
+  }
+  return false;
+}
+const API_KEY_OPTIONAL_PROVIDERS = /* @__PURE__ */ new Set([
+  "local",
+  // Native node-llama-cpp execution - no auth needed
+  "ollama",
+  // Ollama server - no auth needed by default
+  "openai-compatible",
+  // vLLM, LocalAI - often no auth needed
+  "litellm",
+  // Self-hosted proxy - handles auth internally
+  "vertex",
+  // Uses Google Cloud ADC (Application Default Credentials)
+  "bedrock"
+  // Uses AWS credentials (access key + secret or IAM role)
+]);
+function requiresApiKey(provider) {
+  return !API_KEY_OPTIONAL_PROVIDERS.has(provider);
+}
+function getSupportedFileTypesForModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  if (acceptsAnyModel(provider)) {
+    return providerInfo.supportedFileTypes;
+  }
+  const modelInfo = findModelInfo(provider, model);
+  if (modelInfo) {
+    return modelInfo.supportedFileTypes;
+  }
+  if (supportsCustomModels(provider)) {
+    return providerInfo.supportedFileTypes;
+  }
+  throw import_errors.LLMError.unknownModel(provider, model);
+}
+function modelSupportsFileType(provider, model, fileType) {
+  const supportedTypes = getSupportedFileTypesForModel(provider, model);
+  return supportedTypes.includes(fileType);
+}
+function validateModelFileSupport(provider, model, mimeType) {
+  const baseMimeType = mimeType.toLowerCase().split(";")[0]?.trim() || mimeType.toLowerCase();
+  const fileType = MIME_TYPE_TO_FILE_TYPE[baseMimeType];
+  if (!fileType) {
+    return {
+      isSupported: false,
+      error: `Unsupported file type: ${mimeType}`
+    };
+  }
+  try {
+    if (!modelSupportsFileType(provider, model, fileType)) {
+      return {
+        isSupported: false,
+        fileType,
+        error: `Model '${model}' (${provider}) does not support ${fileType} files`
+      };
+    }
+    return {
+      isSupported: true,
+      fileType
+    };
+  } catch (error) {
+    return {
+      isSupported: false,
+      fileType,
+      error: error instanceof Error ? error.message : "Unknown error validating model file support"
+    };
+  }
+}
+function getEffectiveMaxInputTokens(config, logger) {
+  const configuredMaxInputTokens = config.maxInputTokens;
+  if (configuredMaxInputTokens != null) {
+    if (config.baseURL) {
+      logger.debug(
+        `Using maxInputTokens from configuration (with baseURL): ${configuredMaxInputTokens}`
+      );
+      return configuredMaxInputTokens;
+    }
+    try {
+      const registryMaxInputTokens = getMaxInputTokensForModel(
+        config.provider,
+        config.model,
+        logger
+      );
+      if (configuredMaxInputTokens > registryMaxInputTokens) {
+        logger.warn(
+          `Provided maxInputTokens (${configuredMaxInputTokens}) for ${config.provider}/${config.model} exceeds the known limit (${registryMaxInputTokens}) for model ${config.model}. Capping to registry limit.`
+        );
+        return registryMaxInputTokens;
+      } else {
+        logger.debug(
+          `Using valid maxInputTokens override from configuration: ${configuredMaxInputTokens} (Registry limit: ${registryMaxInputTokens})`
+        );
+        return configuredMaxInputTokens;
+      }
+    } catch (error) {
+      if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
+        logger.warn(
+          `Registry lookup failed during maxInputTokens override check for ${config.provider}/${config.model}: ${error.message}. Proceeding with the provided maxInputTokens value (${configuredMaxInputTokens}), but it might be invalid.`
+        );
+        return configuredMaxInputTokens;
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(
+          `getEffectiveMaxInputTokens: unexpected error during maxInputTokens override check: ${errorMessage}`
+        );
+        throw error;
+      }
+    }
+  }
+  if (config.baseURL) {
+    logger.warn(
+      `baseURL is set but maxInputTokens is missing. Defaulting to ${DEFAULT_MAX_INPUT_TOKENS}. Provide 'maxInputTokens' in configuration to avoid default fallback.`
+    );
+    return DEFAULT_MAX_INPUT_TOKENS;
+  }
+  if (acceptsAnyModel(config.provider)) {
+    logger.debug(
+      `Provider ${config.provider} accepts any model, defaulting to ${DEFAULT_MAX_INPUT_TOKENS} tokens`
+    );
+    return DEFAULT_MAX_INPUT_TOKENS;
+  }
+  try {
+    const registryMaxInputTokens = getMaxInputTokensForModel(
+      config.provider,
+      config.model,
+      logger
+    );
+    logger.debug(
+      `Using maxInputTokens from registry for ${config.provider}/${config.model}: ${registryMaxInputTokens}`
+    );
+    return registryMaxInputTokens;
+  } catch (error) {
+    if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
+      if (supportsCustomModels(config.provider)) {
+        logger.debug(
+          `Custom model ${config.model} not in ${config.provider} registry, defaulting to ${DEFAULT_MAX_INPUT_TOKENS} tokens`
+        );
+        return DEFAULT_MAX_INPUT_TOKENS;
+      }
+      logger.error(
+        `Registry lookup failed for ${config.provider}/${config.model}: ${error.message}. Effective maxInputTokens cannot be determined.`
+      );
+      throw import_errors.LLMError.unknownModel(config.provider, config.model);
+    } else {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(
+        `getEffectiveMaxInputTokens: unexpected error during registry lookup for maxInputTokens: ${errorMessage}`
+      );
+      throw error;
+    }
+  }
+}
+function getModelPricing(provider, model) {
+  if (acceptsAnyModel(provider)) {
+    return void 0;
+  }
+  const modelInfo = findModelInfo(provider, model);
+  return modelInfo?.pricing;
+}
+function getModelDisplayName(model, provider) {
+  if (provider) {
+    const modelInfo = findModelInfo(provider, model);
+    return modelInfo?.displayName ?? model;
+  }
+  if (model.includes("/")) {
+    const modelInfo = findModelInfo("openrouter", model);
+    return modelInfo?.displayName ?? model;
+  }
+  try {
+    const inferredProvider = getProviderFromModel(model);
+    const modelInfo = findModelInfo(inferredProvider, model);
+    return modelInfo?.displayName ?? model;
+  } catch {
+    return model;
+  }
+}
+function isReasoningCapableModel(model, _provider) {
+  const modelLower = model.toLowerCase();
+  if (modelLower.includes("codex")) {
+    return true;
+  }
+  if (modelLower.startsWith("o1") || modelLower.startsWith("o3") || modelLower.startsWith("o4")) {
+    return true;
+  }
+  if (modelLower.includes("gpt-5") || modelLower.includes("gpt-5.1") || modelLower.includes("gpt-5.2")) {
+    return true;
+  }
+  return false;
+}
+function calculateCost(usage, pricing) {
+  const inputCost = (usage.inputTokens ?? 0) * pricing.inputPerM / 1e6;
+  const outputCost = (usage.outputTokens ?? 0) * pricing.outputPerM / 1e6;
+  const cacheReadCost = (usage.cacheReadTokens ?? 0) * (pricing.cacheReadPerM ?? 0) / 1e6;
+  const cacheWriteCost = (usage.cacheWriteTokens ?? 0) * (pricing.cacheWritePerM ?? 0) / 1e6;
+  const reasoningCost = (usage.reasoningTokens ?? 0) * pricing.outputPerM / 1e6;
+  return inputCost + outputCost + cacheReadCost + cacheWriteCost + reasoningCost;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MAX_INPUT_TOKENS,
+  LLM_REGISTRY,
+  MIME_TYPE_TO_FILE_TYPE,
+  acceptsAnyModel,
+  calculateCost,
+  getAllModelsForProvider,
+  getAllSupportedModels,
+  getAllowedMimeTypes,
+  getDefaultModelForProvider,
+  getEffectiveMaxInputTokens,
+  getMaxInputTokensForModel,
+  getModelDisplayName,
+  getModelPricing,
+  getOpenRouterCandidateModelIds,
+  getProviderFromModel,
+  getSupportedFileTypesForModel,
+  getSupportedModels,
+  getSupportedProviders,
+  hasAllRegistryModelsSupport,
+  isModelValidForProvider,
+  isReasoningCapableModel,
+  isValidProviderModel,
+  modelSupportsFileType,
+  requiresApiKey,
+  requiresBaseURL,
+  stripBedrockRegionPrefix,
+  supportsBaseURL,
+  supportsCustomModels,
+  transformModelNameForProvider,
+  validateModelFileSupport
+});