@dexto/core 1.1.4 → 1.1.6

package/dist/llm/resolver.d.cts

@@ -0,0 +1,34 @@
+import { Result } from '../utils/result.cjs';
+import { Issue } from '../errors/types.cjs';
+import { ValidatedLLMConfig, LLMUpdates, LLMConfig } from './schemas.cjs';
+import { LLMUpdateContext } from './types.cjs';
+import 'zod';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import './error-codes.cjs';
+import '../mcp/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+
+/**
+ * Convenience function that combines resolveLLM and validateLLM
+ */
+declare function resolveAndValidateLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates): Result<ValidatedLLMConfig, LLMUpdateContext>;
+/**
+ * Infers the LLM config from the provided updates
+ * @param previous - The previous LLM config
+ * @param updates - The updates to the LLM config
+ * @returns The resolved LLM config
+ */
+declare function resolveLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates): {
+    candidate: LLMConfig;
+    warnings: Issue<LLMUpdateContext>[];
+};
+declare function validateLLMConfig(candidate: LLMConfig, warnings: Issue<LLMUpdateContext>[]): Result<ValidatedLLMConfig, LLMUpdateContext>;
+
+export { resolveAndValidateLLMConfig, resolveLLMConfig, validateLLMConfig };

package/dist/llm/resolver.d.ts

@@ -0,0 +1,34 @@
+import { Result } from '../utils/result.js';
+import { Issue } from '../errors/types.js';
+import { ValidatedLLMConfig, LLMUpdates, LLMConfig } from './schemas.js';
+import { LLMUpdateContext } from './types.js';
+import 'zod';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import './error-codes.js';
+import '../mcp/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+
+/**
+ * Convenience function that combines resolveLLM and validateLLM
+ */
+declare function resolveAndValidateLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates): Result<ValidatedLLMConfig, LLMUpdateContext>;
+/**
+ * Infers the LLM config from the provided updates
+ * @param previous - The previous LLM config
+ * @param updates - The updates to the LLM config
+ * @returns The resolved LLM config
+ */
+declare function resolveLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates): {
+    candidate: LLMConfig;
+    warnings: Issue<LLMUpdateContext>[];
+};
+declare function validateLLMConfig(candidate: LLMConfig, warnings: Issue<LLMUpdateContext>[]): Result<ValidatedLLMConfig, LLMUpdateContext>;
+
+export { resolveAndValidateLLMConfig, resolveLLMConfig, validateLLMConfig };

package/dist/llm/resolver.js

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

package/dist/llm/schemas.cjs

@@ -0,0 +1,188 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  LLMConfigSchema: () => LLMConfigSchema,
+  LLMUpdatesSchema: () => LLMUpdatesSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_error_codes = require("./error-codes.js");
+var import_types = require("../errors/types.cjs");
+var import_errors = require("../errors/index.cjs");
+var import_result = require("../utils/result.cjs");
+var import_api_key_resolver = require("../utils/api-key-resolver.cjs");
+var import_zod = require("zod");
+var import_registry = require("./registry.js");
+var import_types2 = require("./types.js");
+const LLMConfigFields = {
+  provider: import_zod.z.enum(import_types2.LLM_PROVIDERS).describe("LLM provider (e.g., 'openai', 'anthropic', 'google', 'groq')"),
+  model: import_result.NonEmptyTrimmed.describe("Specific model name for the selected provider"),
+  // Expand $ENV refs and trim; final validation happens with provider context
+  apiKey: (0, import_result.EnvExpandedString)().describe(
+    "API key for provider; can be given directly or via $ENV reference"
+  ),
+  maxIterations: import_zod.z.coerce.number().int().positive().describe("Max iterations for agentic loops"),
+  router: import_zod.z.enum(import_types2.LLM_ROUTERS).describe("Router to use (vercel | in-built)"),
+  baseURL: import_result.OptionalURL.describe(
+    "Base URL for provider (e.g., https://api.openai.com/v1). Only certain providers support this."
+  ),
+  maxInputTokens: import_zod.z.coerce.number().int().positive().optional().describe("Max input tokens for history; required for unknown models"),
+  maxOutputTokens: import_zod.z.coerce.number().int().positive().optional().describe("Max tokens for model output"),
+  temperature: import_zod.z.coerce.number().min(0).max(1).optional().describe("Randomness: 0 deterministic, 1 creative")
+};
+const LLMConfigSchema = import_zod.z.object({
+  provider: LLMConfigFields.provider,
+  model: LLMConfigFields.model,
+  apiKey: LLMConfigFields.apiKey,
+  // Apply defaults only for complete config validation
+  maxIterations: import_zod.z.coerce.number().int().positive().default(50),
+  router: import_zod.z.enum(import_types2.LLM_ROUTERS).default("vercel"),
+  baseURL: LLMConfigFields.baseURL,
+  maxInputTokens: LLMConfigFields.maxInputTokens,
+  maxOutputTokens: LLMConfigFields.maxOutputTokens,
+  temperature: LLMConfigFields.temperature
+}).strict().superRefine((data, ctx) => {
+  const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
+  const maxInputTokensIsSet = data.maxInputTokens != null;
+  if (!data.apiKey?.trim()) {
+    const primaryVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(data.provider);
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["apiKey"],
+      message: `Missing API key for provider '${data.provider}' \u2013 set $${primaryVar}`,
+      params: {
+        code: import_error_codes.LLMErrorCode.API_KEY_MISSING,
+        scope: import_types.ErrorScope.LLM,
+        type: import_types.ErrorType.USER,
+        provider: data.provider,
+        envVar: primaryVar
+      }
+    });
+  }
+  if (baseURLIsSet) {
+    if (!(0, import_registry.supportsBaseURL)(data.provider)) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["provider"],
+        message: `Provider '${data.provider}' does not support baseURL. Use an 'openai-compatible' provider if you need a custom base URL.`,
+        params: {
+          code: import_error_codes.LLMErrorCode.BASE_URL_INVALID,
+          scope: import_types.ErrorScope.LLM,
+          type: import_types.ErrorType.USER
+        }
+      });
+    }
+  } else if ((0, import_registry.requiresBaseURL)(data.provider)) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["baseURL"],
+      message: `Provider '${data.provider}' requires a 'baseURL'.`,
+      params: {
+        code: import_error_codes.LLMErrorCode.BASE_URL_MISSING,
+        scope: import_types.ErrorScope.LLM,
+        type: import_types.ErrorType.USER
+      }
+    });
+  } else {
+    if (!(0, import_registry.acceptsAnyModel)(data.provider)) {
+      const supportedModelsList = (0, import_registry.getSupportedModels)(data.provider);
+      if (!(0, import_registry.isValidProviderModel)(data.provider, data.model)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          path: ["model"],
+          message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
+          params: {
+            code: import_error_codes.LLMErrorCode.MODEL_INCOMPATIBLE,
+            scope: import_types.ErrorScope.LLM,
+            type: import_types.ErrorType.USER
+          }
+        });
+      }
+    }
+    if (maxInputTokensIsSet && !(0, import_registry.acceptsAnyModel)(data.provider)) {
+      try {
+        const cap = (0, import_registry.getMaxInputTokensForModel)(data.provider, data.model);
+        if (data.maxInputTokens > cap) {
+          ctx.addIssue({
+            code: import_zod.z.ZodIssueCode.custom,
+            path: ["maxInputTokens"],
+            message: `Max input tokens for model '${data.model}' is ${cap}. You provided ${data.maxInputTokens}`,
+            params: {
+              code: import_error_codes.LLMErrorCode.TOKENS_EXCEEDED,
+              scope: import_types.ErrorScope.LLM,
+              type: import_types.ErrorType.USER
+            }
+          });
+        }
+      } catch (error) {
+        if (error instanceof import_errors.DextoRuntimeError && error.code === import_error_codes.LLMErrorCode.MODEL_UNKNOWN) {
+          ctx.addIssue({
+            code: import_zod.z.ZodIssueCode.custom,
+            path: ["model"],
+            message: error.message,
+            params: {
+              code: error.code,
+              scope: error.scope,
+              type: error.type
+            }
+          });
+        } else {
+          const message = error instanceof Error ? error.message : "Unknown error occurred";
+          ctx.addIssue({
+            code: import_zod.z.ZodIssueCode.custom,
+            path: ["model"],
+            message,
+            params: {
+              code: import_error_codes.LLMErrorCode.REQUEST_INVALID_SCHEMA,
+              scope: import_types.ErrorScope.LLM,
+              type: import_types.ErrorType.SYSTEM
+            }
+          });
+        }
+      }
+    }
+  }
+  if (!(0, import_registry.isRouterSupportedForModel)(data.provider, data.model, data.router)) {
+    const supportedRouters = (0, import_registry.getSupportedRoutersForModel)(data.provider, data.model);
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["router"],
+      message: `Model '${data.model}' (${data.provider}) does not support router '${data.router}'. Supported: ${supportedRouters.join(", ")}`,
+      params: {
+        code: import_error_codes.LLMErrorCode.ROUTER_UNSUPPORTED,
+        scope: import_types.ErrorScope.LLM,
+        type: import_types.ErrorType.USER
+      }
+    });
+  }
+}).brand();
+const LLMUpdatesSchema = import_zod.z.object({ ...LLMConfigFields }).partial().strict().superRefine((data, ctx) => {
+  if (!data.model && !data.provider && !data.router) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "At least model, provider, or router must be specified for LLM switch",
+      path: []
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLMConfigSchema,
+  LLMUpdatesSchema
+});

package/dist/llm/schemas.d.cts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export { LLMUpdateContext } from './types.cjs';
+
+/** Business rules + compatibility checks */
+declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    apiKey: z.ZodEffects<z.ZodString, string, string>;
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    router: z.ZodDefault<z.ZodEnum<["vercel", "in-built"]>>;
+    baseURL: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations: number;
+    router: "vercel" | "in-built";
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations: number;
+    router: "vercel" | "in-built";
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, "ValidatedLLMConfig">;
+type LLMConfig = z.input<typeof LLMConfigSchema>;
+type ValidatedLLMConfig = z.output<typeof LLMConfigSchema>;
+declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>>;
+    model: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    router: z.ZodOptional<z.ZodEnum<["vercel", "in-built"]>>;
+    baseURL: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>>;
+    maxInputTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxOutputTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    temperature: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>;
+type LLMUpdates = z.input<typeof LLMUpdatesSchema>;
+
+export { type LLMConfig, LLMConfigSchema, type LLMUpdates, LLMUpdatesSchema, type ValidatedLLMConfig };

package/dist/llm/schemas.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export { LLMUpdateContext } from './types.js';
+
+/** Business rules + compatibility checks */
+declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    apiKey: z.ZodEffects<z.ZodString, string, string>;
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    router: z.ZodDefault<z.ZodEnum<["vercel", "in-built"]>>;
+    baseURL: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations: number;
+    router: "vercel" | "in-built";
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations: number;
+    router: "vercel" | "in-built";
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, "ValidatedLLMConfig">;
+type LLMConfig = z.input<typeof LLMConfigSchema>;
+type ValidatedLLMConfig = z.output<typeof LLMConfigSchema>;
+declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>>;
+    model: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    router: z.ZodOptional<z.ZodEnum<["vercel", "in-built"]>>;
+    baseURL: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>>;
+    maxInputTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxOutputTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    temperature: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    apiKey?: string | undefined;
+    model?: string | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+    maxIterations?: number | undefined;
+    router?: "vercel" | "in-built" | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+}>;
+type LLMUpdates = z.input<typeof LLMUpdatesSchema>;
+
+export { type LLMConfig, LLMConfigSchema, type LLMUpdates, LLMUpdatesSchema, type ValidatedLLMConfig };