@dexto/core 1.8.0 → 1.8.2

package/dist/llm/registry/index.cjs

@@ -18,584 +18,60 @@ var __copyProps = (to, from, except, desc) => {
 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,
-  calculateCostBreakdown: () => calculateCostBreakdown,
   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
+  modelSupportsFileType: () => modelSupportsFileType
 });
 module.exports = __toCommonJS(registry_exports);
+var import_llm = require("@dexto/llm");
 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",
-  "video/mp4": "video",
-  "video/webm": "video",
-  "video/ogg": "video",
-  "video/quicktime": "video",
-  "video/x-msvideo": "video",
-  "video/x-matroska": "video",
-  // Common image MIME types
-  "image/jpeg": "image",
-  "image/jpg": "image",
-  "image/png": "image",
-  "image/webp": "image",
-  "image/gif": "image",
-  // Common document, presentation, and spreadsheet MIME types
-  "text/plain": "document",
-  "text/markdown": "document",
-  "text/html": "document",
-  "text/xml": "document",
-  "text/csv": "document",
-  "text/tab-separated-values": "document",
-  "application/json": "document",
-  "application/xml": "document",
-  "application/msword": "document",
-  "application/rtf": "document",
-  "text/rtf": "document",
-  "application/vnd.oasis.opendocument.text": "document",
-  "application/vnd.ms-powerpoint": "document",
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "document",
-  "application/vnd.ms-excel": "document",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "document",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "document"
-};
-const GENERIC_UPLOAD_FILE_TYPES = [
-  "pdf",
-  "image",
-  "audio",
-  "video",
-  "document"
-];
-function getAllowedMimeTypes() {
-  return Object.keys(MIME_TYPE_TO_FILE_TYPE);
+function isUnknownCatalogModelError(error) {
+  return error instanceof import_llm.LlmCatalogError && error.code === "MODEL_UNKNOWN";
 }
-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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.openai
-  },
-  "openai-compatible": {
-    models: [],
-    // Empty - accepts any model name for custom endpoints
-    baseURLSupport: "required",
-    supportedFileTypes: GENERIC_UPLOAD_FILE_TYPES,
-    // Allow all generic file categories for custom endpoints
-    supportsCustomModels: true
-  },
-  anthropic: {
-    models: import_models_generated.MODELS_BY_PROVIDER.anthropic,
-    baseURLSupport: "none",
-    supportedFileTypes: [],
-    // No defaults - models must explicitly specify support
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.anthropic
-  },
-  google: {
-    models: import_models_generated.MODELS_BY_PROVIDER.google,
-    baseURLSupport: "none",
-    supportedFileTypes: [],
-    // No defaults - models must explicitly specify support
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.google
-  },
-  // 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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.groq
-  },
-  // 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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.xai
-  },
-  // 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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.cohere
-  },
-  // 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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.minimax
-  },
-  // 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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.glm
-  },
-  // 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: GENERIC_UPLOAD_FILE_TYPES,
-    // Allow all generic file categories - user assumes responsibility
-    supportsCustomModels: true,
-    supportsAllRegistryModels: true,
-    // Can serve models from all other providers
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.openrouter
-  },
-  // 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: GENERIC_UPLOAD_FILE_TYPES,
-    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: GENERIC_UPLOAD_FILE_TYPES,
-    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
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.vertex
-  },
-  // 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,
-    modelsDev: import_models_generated.MODELS_DEV_PROVIDER_METADATA_BY_PROVIDER.bedrock
-  },
-  // 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 Haiku 4.5",
-        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 Sonnet 4.5",
-        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 Opus 4.5",
-        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", "document"],
-        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", "document"],
-        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", "video", "document"]
-      },
-      {
-        name: "google/gemini-3-flash-preview",
-        displayName: "Gemini 3 Flash",
-        maxInputTokens: 1048576,
-        supportedFileTypes: ["pdf", "image", "audio", "video", "document"]
-      },
-      // 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.5",
-        displayName: "MiniMax M2.5",
-        maxInputTokens: 204800,
-        supportedFileTypes: [],
-        pricing: {
-          inputPerM: 0.3,
-          outputPerM: 1.2,
-          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"
-        }
+function cloneModel(model) {
+  return {
+    ...model,
+    supportedFileTypes: [...model.supportedFileTypes],
+    ...model.modalities ? {
+      modalities: {
+        input: [...model.modalities.input],
+        output: [...model.modalities.output]
       }
-    ],
-    baseURLSupport: "optional",
-    supportedFileTypes: GENERIC_UPLOAD_FILE_TYPES,
-    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;
+    } : {},
+    ...model.pricing ? {
+      pricing: {
+        ...model.pricing,
+        ...model.pricing.contextOver200kPerM ? { contextOver200kPerM: { ...model.pricing.contextOver200kPerM } } : {}
       }
-    }
-    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) {
-  if (provider === "openrouter" && model.includes("/")) {
-    const dynamicOpenRouterModel = getOpenRouterGatewayModelById(model);
-    if (dynamicOpenRouterModel) return dynamicOpenRouterModel;
-  }
-  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 = getOpenRouterGatewayModelById(model);
-    if (openrouterModel) return openrouterModel;
-  }
-  return null;
-}
-function ensureOpenRouterCatalogRefreshScheduled() {
-  const cacheInfo = (0, import_openrouter_model_registry.getOpenRouterModelCacheInfo)();
-  if (cacheInfo.modelCount === 0) {
-    (0, import_openrouter_model_registry.scheduleOpenRouterModelRefresh)({ force: true });
-  } else if (!cacheInfo.isFresh) {
-    (0, import_openrouter_model_registry.scheduleOpenRouterModelRefresh)();
-  }
+    } : {},
+    ...model.providerMetadata ? { providerMetadata: { ...model.providerMetadata } } : {},
+    ...model.interleaved && model.interleaved !== true ? { interleaved: { ...model.interleaved } } : {}
+  };
 }
 function findOpenRouterSnapshotModelById(modelId) {
   const normalized = modelId.toLowerCase();
-  return LLM_REGISTRY.openrouter.models.find((m) => m.name.toLowerCase() === normalized) ?? null;
+  return import_llm.LLM_REGISTRY.openrouter.models.find((m) => m.name.toLowerCase() === normalized) ?? null;
 }
 function buildOpenRouterGatewayModelInfo(cachedModel, snapshot) {
-  const providerDefaults = LLM_REGISTRY.openrouter.supportedFileTypes;
   const displayName = snapshot?.displayName ?? cachedModel.displayName;
-  const supportedFileTypes = snapshot?.supportedFileTypes ?? providerDefaults;
-  const maxInputTokens = typeof cachedModel.contextLength === "number" && cachedModel.contextLength > 0 ? cachedModel.contextLength : snapshot?.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
-  const inferredReasoning = cachedModel.supportedParameters?.includes("reasoning") === true ? true : void 0;
-  const inferredSupportsTemperature = cachedModel.supportedParameters?.includes("temperature") === true ? true : void 0;
-  return {
+  const supportedFileTypes = snapshot?.supportedFileTypes ?? import_llm.LLM_REGISTRY.openrouter.supportedFileTypes;
+  const maxInputTokens = cachedModel.contextLength > 0 ? cachedModel.contextLength : snapshot?.maxInputTokens ?? import_llm.DEFAULT_MAX_INPUT_TOKENS;
+  const inferredReasoning = cachedModel.supportedParameters?.includes("reasoning");
+  const inferredSupportsTemperature = cachedModel.supportedParameters?.includes("temperature");
+  return cloneModel({
     name: snapshot?.name ?? cachedModel.id,
     maxInputTokens,
     supportedFileTypes,
     ...snapshot?.default ? { default: true } : {},
     ...displayName ? { displayName } : {},
-    ...typeof snapshot?.reasoning === "boolean" ? { reasoning: snapshot.reasoning } : typeof inferredReasoning === "boolean" ? { reasoning: inferredReasoning } : {},
-    ...typeof snapshot?.supportsTemperature === "boolean" ? { supportsTemperature: snapshot.supportsTemperature } : typeof inferredSupportsTemperature === "boolean" ? { supportsTemperature: inferredSupportsTemperature } : {},
+    ...typeof snapshot?.reasoning === "boolean" ? { reasoning: snapshot.reasoning } : inferredReasoning === true ? { reasoning: true } : {},
+    ...typeof snapshot?.supportsTemperature === "boolean" ? { supportsTemperature: snapshot.supportsTemperature } : inferredSupportsTemperature === true ? { supportsTemperature: true } : {},
     ...typeof snapshot?.supportsInterleaved === "boolean" ? { supportsInterleaved: snapshot.supportsInterleaved } : {},
     ...snapshot?.releaseDate ? { releaseDate: snapshot.releaseDate } : {},
     ...typeof snapshot?.supportsToolCall === "boolean" ? { supportsToolCall: snapshot.supportsToolCall } : {},
@@ -604,155 +80,89 @@ function buildOpenRouterGatewayModelInfo(cachedModel, snapshot) {
     ...snapshot?.providerMetadata ? { providerMetadata: snapshot.providerMetadata } : {},
     ...snapshot?.interleaved ? { interleaved: snapshot.interleaved } : {},
     ...snapshot?.pricing ? { pricing: snapshot.pricing } : {}
-  };
-}
-function getOpenRouterGatewayModelById(modelId) {
-  ensureOpenRouterCatalogRefreshScheduled();
-  const snapshot = findOpenRouterSnapshotModelById(modelId);
-  const cached = (0, import_openrouter_model_registry.getCachedOpenRouterModelsWithInfo)();
-  if (!cached || cached.length === 0) {
-    return snapshot ? { ...snapshot } : null;
-  }
-  const normalized = modelId.toLowerCase();
-  const cachedModel = cached.find((m) => m.id.toLowerCase() === normalized);
-  if (!cachedModel) return snapshot ? { ...snapshot } : null;
-  return buildOpenRouterGatewayModelInfo(cachedModel, snapshot);
+  });
 }
 function getOpenRouterGatewayCatalogModels() {
-  ensureOpenRouterCatalogRefreshScheduled();
   const cached = (0, import_openrouter_model_registry.getCachedOpenRouterModelsWithInfo)();
   if (!cached || cached.length === 0) {
-    return LLM_REGISTRY.openrouter.models.map((m) => ({ ...m }));
+    return import_llm.LLM_REGISTRY.openrouter.models.map(cloneModel);
   }
-  const models = cached.map(
+  return cached.map(
     (cachedModel) => buildOpenRouterGatewayModelInfo(
       cachedModel,
       findOpenRouterSnapshotModelById(cachedModel.id)
     )
   ).sort((a, b) => a.name.localeCompare(b.name));
-  return models;
 }
 function getAllModelsForProvider(provider) {
-  const providerInfo = LLM_REGISTRY[provider];
   if (provider === "openrouter") {
-    return getOpenRouterGatewayCatalogModels().map((m) => ({
-      ...m,
+    return getOpenRouterGatewayCatalogModels().map((model) => ({
+      ...model,
       originalProvider: "openrouter"
     }));
   }
-  if (!providerInfo.supportsAllRegistryModels) {
-    return providerInfo.models.map((m) => ({ ...m }));
+  if (!(0, import_llm.hasAllRegistryModelsSupport)(provider)) {
+    return (0, import_llm.getAllModelsForProvider)(provider);
   }
   const allModels = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const model of providerInfo.models) {
+  for (const model of import_llm.LLM_REGISTRY[provider].models) {
     const key = model.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
-    allModels.push({ ...model, originalProvider: provider });
+    allModels.push({ ...cloneModel(model), originalProvider: provider });
   }
   for (const model of getOpenRouterGatewayCatalogModels()) {
     const key = model.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
-    allModels.push({ ...model, originalProvider: "openrouter" });
+    allModels.push({ ...cloneModel(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;
+function getProviderFromModel(model) {
+  try {
+    return (0, import_llm.getProviderFromModel)(model);
+  } catch (error) {
+    if (isUnknownCatalogModelError(error)) {
+      throw import_errors.LLMError.modelProviderUnknown(model);
+    }
+    throw error;
   }
-  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;
+  try {
+    return (0, import_llm.getSupportedFileTypesForModel)(provider, model);
+  } catch (error) {
+    if (isUnknownCatalogModelError(error)) {
+      throw import_errors.LLMError.unknownModel(provider, model);
+    }
+    throw error;
   }
-  throw import_errors.LLMError.unknownModel(provider, model);
 }
 function modelSupportsFileType(provider, model, fileType) {
-  const supportedTypes = getSupportedFileTypesForModel(provider, model);
-  return supportedTypes.includes(fileType);
+  return getSupportedFileTypesForModel(provider, model).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`
-      };
+function getMaxInputTokensForModel(provider, model, logger) {
+  const modelInfo = (0, import_llm.getModel)(provider, model);
+  if (modelInfo !== null) {
+    logger?.debug(`Found max tokens for ${provider}/${model}: ${modelInfo.maxInputTokens}`);
+    return modelInfo.maxInputTokens;
+  }
+  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;
     }
-    return {
-      isSupported: true,
-      fileType
-    };
-  } catch (error) {
-    return {
-      isSupported: false,
-      fileType,
-      error: error instanceof Error ? error.message : "Unknown error validating model file support"
-    };
   }
+  const supportedModels = (0, import_llm.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);
 }
 function getEffectiveMaxInputTokens(config, logger) {
   const configuredMaxInputTokens = config.maxInputTokens;
@@ -774,38 +184,36 @@ function getEffectiveMaxInputTokens(config, logger) {
           `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;
       }
+      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;
       }
+      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.`
+      `baseURL is set but maxInputTokens is missing. Defaulting to ${import_llm.DEFAULT_MAX_INPUT_TOKENS}. Provide 'maxInputTokens' in configuration to avoid default fallback.`
     );
-    return DEFAULT_MAX_INPUT_TOKENS;
+    return import_llm.DEFAULT_MAX_INPUT_TOKENS;
   }
-  if (acceptsAnyModel(config.provider)) {
+  if ((0, import_llm.acceptsAnyModel)(config.provider)) {
     logger.debug(
-      `Provider ${config.provider} accepts any model, defaulting to ${DEFAULT_MAX_INPUT_TOKENS} tokens`
+      `Provider ${config.provider} accepts any model, defaulting to ${import_llm.DEFAULT_MAX_INPUT_TOKENS} tokens`
     );
-    return DEFAULT_MAX_INPUT_TOKENS;
+    return import_llm.DEFAULT_MAX_INPUT_TOKENS;
   }
   try {
     const registryMaxInputTokens = getMaxInputTokensForModel(
@@ -819,131 +227,30 @@ function getEffectiveMaxInputTokens(config, logger) {
     return registryMaxInputTokens;
   } catch (error) {
     if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
-      if (supportsCustomModels(config.provider)) {
+      if ((0, import_llm.supportsCustomModels)(config.provider)) {
         logger.debug(
-          `Custom model ${config.model} not in ${config.provider} registry, defaulting to ${DEFAULT_MAX_INPUT_TOKENS} tokens`
+          `Custom model ${config.model} not in ${config.provider} registry, defaulting to ${import_llm.DEFAULT_MAX_INPUT_TOKENS} tokens`
         );
-        return DEFAULT_MAX_INPUT_TOKENS;
+        return import_llm.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 registryProvider = (() => {
-    if (model.includes("/")) return "openrouter";
-    if (provider) return provider;
-    try {
-      return getProviderFromModel(model);
-    } catch {
-      return void 0;
     }
-  })();
-  if (registryProvider === "openrouter" && model.includes("/")) {
-    const dynamicModel = getOpenRouterGatewayModelById(model);
-    if (dynamicModel?.reasoning === true) return true;
-    if (dynamicModel?.reasoning === false) return false;
-  }
-  if (registryProvider) {
-    const modelInfo = findModelInfo(registryProvider, model);
-    if (modelInfo?.reasoning === true) return true;
-    if (modelInfo?.reasoning === false) return false;
-  }
-  const modelIdForHeuristics = model.includes("/") ? model.split("/").pop() ?? model : model;
-  const modelLower = modelIdForHeuristics.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;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(
+      `getEffectiveMaxInputTokens: unexpected error during registry lookup for maxInputTokens: ${errorMessage}`
+    );
+    throw error;
   }
-  return false;
-}
-function calculateCost(usage, pricing) {
-  return calculateCostBreakdown(usage, pricing).totalUsd;
-}
-function calculateCostBreakdown(usage, pricing) {
-  const inputUsd = (usage.inputTokens ?? 0) * pricing.inputPerM / 1e6;
-  const outputUsd = (usage.outputTokens ?? 0) * pricing.outputPerM / 1e6;
-  const cacheReadUsd = (usage.cacheReadTokens ?? 0) * (pricing.cacheReadPerM ?? 0) / 1e6;
-  const cacheWriteUsd = (usage.cacheWriteTokens ?? 0) * (pricing.cacheWritePerM ?? 0) / 1e6;
-  const reasoningUsd = (usage.reasoningTokens ?? 0) * (pricing.reasoningPerM ?? pricing.outputPerM) / 1e6;
-  return {
-    inputUsd,
-    outputUsd,
-    reasoningUsd,
-    cacheReadUsd,
-    cacheWriteUsd,
-    totalUsd: inputUsd + outputUsd + cacheReadUsd + cacheWriteUsd + reasoningUsd
-  };
 }
 // 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,
-  calculateCostBreakdown,
   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
+  modelSupportsFileType
 });