@dexto/core 1.1.4 → 1.1.6

package/dist/{chunk-J6AXCN3H.js → llm/registry.js}

@@ -1,151 +1,11 @@
+import { LLMError } from "./errors.js";
+import { LLMErrorCode } from "./error-codes.js";
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
 import {
-  DextoValidationError
-} from "./chunk-XFQLRBHE.js";
-import {
-  getDextoGlobalPath,
-  logger
-} from "./chunk-D62MHQBE.js";
-import {
-  DextoRuntimeError
-} from "./chunk-TPERKLLN.js";
-import {
-  init_esm_shims
-} from "./chunk-MVKLS3LM.js";
-
-// src/preferences/loader.ts
-init_esm_shims();
-import { existsSync } from "fs";
-import { promises as fs } from "fs";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-
-// src/preferences/schemas.ts
-init_esm_shims();
-import { z as z2 } from "zod";
-
-// src/llm/registry.ts
-init_esm_shims();
-
-// src/llm/errors.ts
-init_esm_shims();
-
-// src/llm/error-codes.ts
-init_esm_shims();
-var LLMErrorCode = /* @__PURE__ */ ((LLMErrorCode2) => {
-  LLMErrorCode2["API_KEY_MISSING"] = "llm_api_key_missing";
-  LLMErrorCode2["API_KEY_INVALID"] = "llm_api_key_invalid";
-  LLMErrorCode2["API_KEY_CANDIDATE_MISSING"] = "llm_api_key_candidate_missing";
-  LLMErrorCode2["BASE_URL_MISSING"] = "llm_base_url_missing";
-  LLMErrorCode2["BASE_URL_INVALID"] = "llm_base_url_invalid";
-  LLMErrorCode2["MODEL_INCOMPATIBLE"] = "llm_model_incompatible";
-  LLMErrorCode2["MODEL_UNKNOWN"] = "llm_model_unknown";
-  LLMErrorCode2["PROVIDER_UNSUPPORTED"] = "llm_provider_unsupported";
-  LLMErrorCode2["ROUTER_UNSUPPORTED"] = "llm_router_unsupported";
-  LLMErrorCode2["INPUT_FILE_UNSUPPORTED"] = "llm_input_file_unsupported";
-  LLMErrorCode2["INPUT_IMAGE_UNSUPPORTED"] = "llm_input_image_unsupported";
-  LLMErrorCode2["INPUT_TEXT_INVALID"] = "llm_input_text_invalid";
-  LLMErrorCode2["TOKENS_EXCEEDED"] = "llm_tokens_exceeded";
-  LLMErrorCode2["RATE_LIMIT_EXCEEDED"] = "llm_rate_limit_exceeded";
-  LLMErrorCode2["SWITCH_FAILED"] = "llm_switch_failed";
-  LLMErrorCode2["GENERATION_FAILED"] = "llm_generation_failed";
-  LLMErrorCode2["SWITCH_INPUT_MISSING"] = "llm_switch_input_missing";
-  LLMErrorCode2["REQUEST_INVALID_SCHEMA"] = "llm_request_invalid_schema";
-  return LLMErrorCode2;
-})(LLMErrorCode || {});
-
-// src/llm/errors.ts
-var LLMError = class {
-  // Runtime model/provider lookup errors
-  static unknownModel(provider, model) {
-    return new DextoRuntimeError(
-      "llm_model_unknown" /* MODEL_UNKNOWN */,
-      "llm" /* LLM */,
-      "user" /* USER */,
-      `Unknown model '${model}' for provider '${provider}'`,
-      { provider, model }
-    );
-  }
-  static baseUrlMissing(provider) {
-    return new DextoRuntimeError(
-      "llm_base_url_missing" /* BASE_URL_MISSING */,
-      "llm" /* LLM */,
-      "user" /* USER */,
-      `Provider '${provider}' requires a baseURL (set config.baseURL or OPENAI_BASE_URL environment variable)`,
-      { provider }
-    );
-  }
-  static modelProviderUnknown(model) {
-    const availableProviders = getSupportedProviders();
-    return new DextoRuntimeError(
-      "llm_model_unknown" /* MODEL_UNKNOWN */,
-      "llm" /* LLM */,
-      "user" /* USER */,
-      `Unknown model '${model}' - could not infer provider. Available providers: ${availableProviders.join(", ")}`,
-      { model, availableProviders },
-      "Specify the provider explicitly or use a recognized model name"
-    );
-  }
-  static unsupportedRouter(router, provider) {
-    const supportedRouters = getSupportedRoutersForProvider(provider).map((r) => r);
-    return new DextoRuntimeError(
-      "llm_router_unsupported" /* ROUTER_UNSUPPORTED */,
-      "llm" /* LLM */,
-      "user" /* USER */,
-      `Router '${router}' not supported for provider '${provider}'. Supported: ${supportedRouters.join(", ")}`,
-      { router, provider, supportedRouters }
-    );
-  }
-  // Runtime service errors
-  static rateLimitExceeded(provider, retryAfter) {
-    return new DextoRuntimeError(
-      "llm_rate_limit_exceeded" /* RATE_LIMIT_EXCEEDED */,
-      "llm" /* LLM */,
-      "rate_limit" /* RATE_LIMIT */,
-      `Rate limit exceeded for ${provider}`,
-      {
-        details: { provider, retryAfter },
-        recovery: retryAfter ? `Wait ${retryAfter} seconds before retrying` : "Wait before retrying or upgrade your plan"
-      }
-    );
-  }
-  // Runtime operation errors
-  static generationFailed(error, provider, model) {
-    return new DextoRuntimeError(
-      "llm_generation_failed" /* GENERATION_FAILED */,
-      "llm" /* LLM */,
-      "third_party" /* THIRD_PARTY */,
-      `Generation failed: ${error}`,
-      { details: { error, provider, model } }
-    );
-  }
-  // Switch operation errors (runtime checks not covered by Zod)
-  static switchInputMissing() {
-    return new DextoRuntimeError(
-      "llm_switch_input_missing" /* SWITCH_INPUT_MISSING */,
-      "llm" /* LLM */,
-      "user" /* USER */,
-      "At least model or provider must be specified for LLM switch",
-      {},
-      "Provide either a model name, provider, or both"
-    );
-  }
-};
-
-// src/llm/types.ts
-init_esm_shims();
-var LLM_PROVIDERS = [
-  "openai",
-  "openai-compatible",
-  "anthropic",
-  "google",
-  "groq",
-  "xai",
-  "cohere"
-];
-var LLM_ROUTERS = ["vercel", "in-built"];
-var SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
-
-// src/llm/registry.ts
-var MIME_TYPE_TO_FILE_TYPE = {
+  LLM_PROVIDERS
+} from "./types.js";
+import { logger } from "../logger/index.js";
+const MIME_TYPE_TO_FILE_TYPE = {
   "application/pdf": "pdf",
   "audio/mp3": "audio",
   "audio/mpeg": "audio",
@@ -166,8 +26,8 @@ var MIME_TYPE_TO_FILE_TYPE = {
 function getAllowedMimeTypes() {
   return Object.keys(MIME_TYPE_TO_FILE_TYPE);
 }
-var DEFAULT_MAX_INPUT_TOKENS = 128e3;
-var LLM_REGISTRY = {
+const DEFAULT_MAX_INPUT_TOKENS = 128e3;
+const LLM_REGISTRY = {
   openai: {
     models: [
       {
@@ -909,7 +769,7 @@ function getEffectiveMaxInputTokens(config) {
         return configuredMaxInputTokens;
       }
     } catch (error) {
-      if (error instanceof DextoRuntimeError && error.code === "llm_model_unknown" /* MODEL_UNKNOWN */) {
+      if (error instanceof DextoRuntimeError && error.code === 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.`
         );
@@ -941,7 +801,7 @@ function getEffectiveMaxInputTokens(config) {
     );
     return registryMaxInputTokens;
   } catch (error) {
-    if (error instanceof DextoRuntimeError && error.code === "llm_model_unknown" /* MODEL_UNKNOWN */) {
+    if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
       logger.error(
         `Registry lookup failed for ${config.provider}/${config.model}: ${error.message}. Effective maxInputTokens cannot be determined.`
       );
@@ -952,317 +812,27 @@ function getEffectiveMaxInputTokens(config) {
     }
   }
 }
-
-// src/utils/result.ts
-init_esm_shims();
-import { z } from "zod";
-var NonEmptyTrimmed = z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
-function isValidUrl(s) {
-  try {
-    const u = new URL(s);
-    return u.protocol === "http:" || u.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-var OptionalURL = z.string().transform((s) => s.trim()).refine((s) => s === "" || isValidUrl(s), { message: "Invalid URL" }).transform((s) => s === "" ? void 0 : s).optional();
-var EnvExpandedString = (env) => z.string().transform((input) => {
-  if (typeof input !== "string") return "";
-  const envToUse = env ?? process.env;
-  const out = input.replace(
-    /\$([A-Z_][A-Z0-9_]*)|\${([A-Z_][A-Z0-9_]*)}/gi,
-    (_, a, b) => envToUse[a || b] ?? ""
-  );
-  return out.trim();
-});
-var NonEmptyEnvExpandedString = (env) => EnvExpandedString(env).refine((s) => s.length > 0, {
-  message: "Value is required"
-});
-var RequiredEnvURL = (env) => EnvExpandedString(env).refine(
-  (s) => {
-    try {
-      const u = new URL(s);
-      return u.protocol === "http:" || u.protocol === "https:";
-    } catch {
-      return false;
-    }
-  },
-  { message: "Invalid URL" }
-);
-var ok = (data, issues = []) => ({
-  ok: true,
-  data,
-  issues
-  // warnings live alongside errors here
-});
-var fail = (issues) => ({
-  ok: false,
-  issues
-});
-function hasErrors(issues) {
-  return issues.some((i) => i.severity !== "warning");
-}
-function splitIssues(issues) {
-  return {
-    errors: issues.filter((i) => i.severity !== "warning"),
-    warnings: issues.filter((i) => i.severity === "warning")
-  };
-}
-function zodToIssues(err, severity = "error") {
-  return err.errors.map((e) => {
-    const params = e.params || {};
-    return {
-      code: params.code ?? "schema_validation",
-      message: e.message,
-      scope: params.scope ?? "agent" /* AGENT */,
-      // Fallback for non-custom Zod errors
-      // Treat plain Zod schema failures as USER errors by default
-      type: params.type ?? "user" /* USER */,
-      path: e.path,
-      severity,
-      context: params
-    };
-  });
-}
-
-// src/preferences/error-codes.ts
-init_esm_shims();
-var PreferenceErrorCode = /* @__PURE__ */ ((PreferenceErrorCode2) => {
-  PreferenceErrorCode2["FILE_NOT_FOUND"] = "preference_file_not_found";
-  PreferenceErrorCode2["FILE_READ_ERROR"] = "preference_file_read_error";
-  PreferenceErrorCode2["FILE_WRITE_ERROR"] = "preference_file_write_error";
-  PreferenceErrorCode2["VALIDATION_ERROR"] = "preference_validation_error";
-  PreferenceErrorCode2["MODEL_INCOMPATIBLE"] = "preference_model_incompatible";
-  return PreferenceErrorCode2;
-})(PreferenceErrorCode || {});
-
-// src/preferences/schemas.ts
-var PreferenceLLMSchema = z2.object({
-  provider: z2.enum(LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
-  model: NonEmptyTrimmed.describe("Model name for the provider"),
-  apiKey: z2.string().regex(
-    /^\$[A-Z_][A-Z0-9_]*$/,
-    "Must be environment variable reference (e.g., $OPENAI_API_KEY)"
-  ).describe("Environment variable reference for API key")
-}).strict().superRefine((data, ctx) => {
-  if (!isValidProviderModel(data.provider, data.model)) {
-    const supportedModels = getSupportedModels(data.provider);
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      path: ["model"],
-      message: `Model '${data.model}' is not supported by provider '${data.provider}'. Supported models: ${supportedModels.join(", ")}`,
-      params: {
-        code: "preference_model_incompatible" /* MODEL_INCOMPATIBLE */,
-        scope: "preference" /* PREFERENCE */,
-        type: "user" /* USER */
-      }
-    });
-  }
-});
-var PreferenceDefaultsSchema = z2.object({
-  defaultAgent: z2.string().min(1).describe("Default agent name for global CLI usage (required)")
-}).strict();
-var PreferenceSetupSchema = z2.object({
-  completed: z2.boolean().default(false).describe("Whether initial setup has been completed")
-}).strict();
-var GlobalPreferencesSchema = z2.object({
-  llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
-  defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
-  setup: PreferenceSetupSchema.default({ completed: false }).describe(
-    "Setup completion tracking"
-  )
-}).strict();
-
-// src/preferences/constants.ts
-init_esm_shims();
-var PREFERENCES_FILE = "preferences.yml";
-
-// src/preferences/errors.ts
-init_esm_shims();
-var PreferenceError = class {
-  static fileNotFound(preferencesPath) {
-    return new DextoRuntimeError(
-      "preference_file_not_found" /* FILE_NOT_FOUND */,
-      "preference" /* PREFERENCE */,
-      "user" /* USER */,
-      `Preferences file not found: ${preferencesPath}`,
-      { preferencesPath },
-      "Run `dexto setup` to create preferences"
-    );
-  }
-  static fileReadError(preferencesPath, cause) {
-    return new DextoRuntimeError(
-      "preference_file_read_error" /* FILE_READ_ERROR */,
-      "preference" /* PREFERENCE */,
-      "system" /* SYSTEM */,
-      `Failed to read preferences: ${cause}`,
-      { preferencesPath, cause },
-      "Check file permissions and ensure the file is not corrupted"
-    );
-  }
-  static fileWriteError(preferencesPath, cause) {
-    return new DextoRuntimeError(
-      "preference_file_write_error" /* FILE_WRITE_ERROR */,
-      "preference" /* PREFERENCE */,
-      "system" /* SYSTEM */,
-      `Failed to save preferences: ${cause}`,
-      { preferencesPath, cause },
-      "Check file permissions and available disk space"
-    );
-  }
-  static validationFailed(zodError) {
-    const issues = zodError.issues.map((issue) => ({
-      code: "preference_validation_error" /* VALIDATION_ERROR */,
-      message: `${issue.path.join(".")}: ${issue.message}`,
-      scope: "preference" /* PREFERENCE */,
-      type: "user" /* USER */,
-      severity: "error"
-    }));
-    return new DextoValidationError(issues);
-  }
-};
-
-// src/preferences/loader.ts
-async function loadGlobalPreferences() {
-  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
-  if (!existsSync(preferencesPath)) {
-    throw PreferenceError.fileNotFound(preferencesPath);
-  }
-  try {
-    const fileContent = await fs.readFile(preferencesPath, "utf-8");
-    const rawPreferences = parseYaml(fileContent);
-    const validation = GlobalPreferencesSchema.safeParse(rawPreferences);
-    if (!validation.success) {
-      throw PreferenceError.validationFailed(validation.error);
-    }
-    logger.debug(`Loaded global preferences from: ${preferencesPath}`);
-    return validation.data;
-  } catch (error) {
-    if (error instanceof DextoValidationError || error instanceof DextoRuntimeError) {
-      throw error;
-    }
-    throw PreferenceError.fileReadError(
-      preferencesPath,
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-async function saveGlobalPreferences(preferences) {
-  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
-  const validation = GlobalPreferencesSchema.safeParse(preferences);
-  if (!validation.success) {
-    throw PreferenceError.validationFailed(validation.error);
-  }
-  try {
-    logger.info(`Saving global preferences to: ${preferencesPath}`);
-    const dextoDir = getDextoGlobalPath("");
-    await fs.mkdir(dextoDir, { recursive: true });
-    const yamlContent = stringifyYaml(preferences, {
-      indent: 2,
-      lineWidth: 100,
-      minContentWidth: 20
-    });
-    await fs.writeFile(preferencesPath, yamlContent, "utf-8");
-    logger.info(
-      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
-    );
-  } catch (error) {
-    throw PreferenceError.fileWriteError(
-      preferencesPath,
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-function globalPreferencesExist() {
-  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
-  return existsSync(preferencesPath);
-}
-function getGlobalPreferencesPath() {
-  return getDextoGlobalPath(PREFERENCES_FILE);
-}
-function createInitialPreferences(provider, model, apiKeyVar, defaultAgent = "default-agent") {
-  return {
-    llm: {
-      provider,
-      model,
-      apiKey: `$${apiKeyVar}`
-    },
-    defaults: {
-      defaultAgent
-    },
-    setup: {
-      completed: true
-    }
-  };
-}
-async function updateGlobalPreferences(updates) {
-  const existing = await loadGlobalPreferences();
-  const merged = {
-    ...existing,
-    ...updates,
-    // LLM section requires complete replacement (high coherence - provider/model/apiKey must match)
-    llm: updates.llm || existing.llm,
-    // Defaults and setup sections allow partial updates (low coherence - independent fields)
-    defaults: updates.defaults ? { ...existing.defaults, ...updates.defaults } : existing.defaults,
-    setup: updates.setup ? { ...existing.setup, ...updates.setup } : existing.setup
-  };
-  const validation = GlobalPreferencesSchema.safeParse(merged);
-  if (!validation.success) {
-    throw PreferenceError.validationFailed(validation.error);
-  }
-  await saveGlobalPreferences(validation.data);
-  return validation.data;
-}
-
 export {
-  LLMErrorCode,
-  LLM_PROVIDERS,
-  LLM_ROUTERS,
-  SUPPORTED_FILE_TYPES,
-  MIME_TYPE_TO_FILE_TYPE,
-  getAllowedMimeTypes,
   DEFAULT_MAX_INPUT_TOKENS,
   LLM_REGISTRY,
+  MIME_TYPE_TO_FILE_TYPE,
+  acceptsAnyModel,
+  getAllSupportedModels,
+  getAllowedMimeTypes,
   getDefaultModelForProvider,
-  getSupportedProviders,
-  getSupportedModels,
+  getEffectiveMaxInputTokens,
   getMaxInputTokensForModel,
-  isValidProviderModel,
   getProviderFromModel,
-  getAllSupportedModels,
-  getSupportedRoutersForProvider,
-  supportsBaseURL,
-  requiresBaseURL,
-  acceptsAnyModel,
   getSupportedFileTypesForModel,
-  modelSupportsFileType,
-  validateModelFileSupport,
-  isRouterSupportedForModel,
+  getSupportedModels,
+  getSupportedProviders,
   getSupportedRoutersForModel,
+  getSupportedRoutersForProvider,
+  isRouterSupportedForModel,
   isRouterSupportedForProvider,
-  getEffectiveMaxInputTokens,
-  LLMError,
-  NonEmptyTrimmed,
-  OptionalURL,
-  EnvExpandedString,
-  NonEmptyEnvExpandedString,
-  RequiredEnvURL,
-  ok,
-  fail,
-  hasErrors,
-  splitIssues,
-  zodToIssues,
-  PreferenceErrorCode,
-  PreferenceLLMSchema,
-  PreferenceDefaultsSchema,
-  PreferenceSetupSchema,
-  GlobalPreferencesSchema,
-  PREFERENCES_FILE,
-  PreferenceError,
-  loadGlobalPreferences,
-  saveGlobalPreferences,
-  globalPreferencesExist,
-  getGlobalPreferencesPath,
-  createInitialPreferences,
-  updateGlobalPreferences
+  isValidProviderModel,
+  modelSupportsFileType,
+  requiresBaseURL,
+  supportsBaseURL,
+  validateModelFileSupport
 };

package/dist/llm/resolver.cjs

@@ -0,0 +1,154 @@
+"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 resolver_exports = {};
+__export(resolver_exports, {
+  resolveAndValidateLLMConfig: () => resolveAndValidateLLMConfig,
+  resolveLLMConfig: () => resolveLLMConfig,
+  validateLLMConfig: () => validateLLMConfig
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_result = require("../utils/result.js");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+var import_schemas2 = require("./schemas.js");
+var import_registry = require("./registry.js");
+var import_api_key_resolver = require("../utils/api-key-resolver.cjs");
+function resolveAndValidateLLMConfig(previous, updates) {
+  const { candidate, warnings } = resolveLLMConfig(previous, updates);
+  if ((0, import_result.hasErrors)(warnings)) {
+    const { errors } = (0, import_result.splitIssues)(warnings);
+    return (0, import_result.fail)(errors);
+  }
+  const result = validateLLMConfig(candidate, warnings);
+  return result;
+}
+function resolveLLMConfig(previous, updates) {
+  const warnings = [];
+  const provider = updates.provider ?? (updates.model ? (() => {
+    try {
+      return (0, import_registry.getProviderFromModel)(updates.model);
+    } catch {
+      return previous.provider;
+    }
+  })() : previous.provider);
+  const envKey = (0, import_api_key_resolver.resolveApiKeyForProvider)(provider);
+  const apiKey = updates.apiKey ?? (provider !== previous.provider ? envKey : previous.apiKey) ?? "";
+  if (!apiKey) {
+    warnings.push({
+      code: import_error_codes.LLMErrorCode.API_KEY_CANDIDATE_MISSING,
+      message: "API key not provided or found in environment",
+      severity: "warning",
+      scope: import_types.ErrorScope.LLM,
+      type: import_types.ErrorType.USER,
+      context: { provider }
+    });
+  } else if (typeof apiKey === "string" && apiKey.length < 10) {
+    warnings.push({
+      code: import_error_codes.LLMErrorCode.API_KEY_INVALID,
+      message: "API key looks unusually short",
+      severity: "warning",
+      scope: import_types.ErrorScope.LLM,
+      type: import_types.ErrorType.USER,
+      context: { provider }
+    });
+  }
+  let model = updates.model ?? previous.model;
+  if (provider !== previous.provider && !(0, import_registry.acceptsAnyModel)(provider) && !(0, import_registry.isValidProviderModel)(provider, model)) {
+    model = (0, import_registry.getDefaultModelForProvider)(provider) ?? previous.model;
+    warnings.push({
+      code: import_error_codes.LLMErrorCode.MODEL_INCOMPATIBLE,
+      message: `Model set to default '${model}' for provider '${provider}'`,
+      severity: "warning",
+      scope: import_types.ErrorScope.LLM,
+      type: import_types.ErrorType.USER,
+      context: { provider, model }
+    });
+  }
+  let router = updates.router;
+  if (!router) {
+    if (provider !== previous.provider && !(0, import_registry.isRouterSupportedForModel)(provider, model, previous.router)) {
+      const supported = (0, import_registry.getSupportedRoutersForModel)(provider, model);
+      if (supported.length === 0) {
+        warnings.push({
+          code: import_error_codes.LLMErrorCode.ROUTER_UNSUPPORTED,
+          message: `No routers supported for model '${model}' (${provider})`,
+          severity: "error",
+          scope: import_types.ErrorScope.LLM,
+          type: import_types.ErrorType.USER,
+          context: router ? { provider, model, router } : { provider, model }
+        });
+      } else {
+        router = supported.includes("vercel") ? "vercel" : supported[0];
+        warnings.push({
+          code: import_error_codes.LLMErrorCode.ROUTER_UNSUPPORTED,
+          message: `Router changed to '${router}' for model '${model}' (${provider})`,
+          severity: "warning",
+          scope: import_types.ErrorScope.LLM,
+          type: import_types.ErrorType.USER,
+          context: { provider, model, router }
+        });
+      }
+    } else {
+      router = previous.router;
+    }
+  }
+  const maxInputTokens = updates.maxInputTokens ?? (0, import_registry.getEffectiveMaxInputTokens)({ provider, model, apiKey: apiKey || previous.apiKey });
+  return {
+    candidate: {
+      provider,
+      model,
+      apiKey,
+      router,
+      baseURL: updates.baseURL ?? previous.baseURL,
+      maxIterations: updates.maxIterations ?? previous.maxIterations,
+      maxInputTokens,
+      maxOutputTokens: updates.maxOutputTokens ?? previous.maxOutputTokens,
+      temperature: updates.temperature ?? previous.temperature
+    },
+    warnings
+  };
+}
+function validateLLMConfig(candidate, warnings) {
+  const parsed = import_schemas2.LLMConfigSchema.safeParse(candidate);
+  if (!parsed.success) {
+    return (0, import_result.fail)((0, import_result.zodToIssues)(parsed.error, "error"));
+  }
+  if (parsed.data.apiKey && parsed.data.apiKey.length < 10) {
+    warnings.push({
+      code: import_error_codes.LLMErrorCode.API_KEY_INVALID,
+      message: "API key seems too short - please verify it is correct",
+      path: ["apiKey"],
+      severity: "warning",
+      scope: import_types.ErrorScope.LLM,
+      type: import_types.ErrorType.USER,
+      context: {
+        provider: candidate.provider,
+        model: candidate.model,
+        ...candidate.router && { router: candidate.router }
+      }
+    });
+  }
+  return (0, import_result.ok)(parsed.data, warnings);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAndValidateLLMConfig,
+  resolveLLMConfig,
+  validateLLMConfig
+});