@dexto/core 1.3.0 → 1.5.0

package/dist/llm/schemas.d.ts

@@ -1,32 +1,49 @@
 import { z } from 'zod';
+/**
+ * Options for LLM config validation
+ */
+export interface LLMValidationOptions {
+    /**
+     * When true, enforces API key and baseURL requirements.
+     * When false (relaxed mode), allows missing API keys/baseURLs for interactive configuration.
+     *
+     * Use strict mode for:
+     * - Server/API mode (headless, needs full config)
+     * - MCP mode (headless)
+     *
+     * Use relaxed mode for:
+     * - Web UI (user can configure via settings)
+     * - CLI (user can configure interactively)
+     *
+     * @default true
+     */
+    strict?: boolean;
+}
 /** Business rules + compatibility checks */
 export declare const LLMConfigBaseSchema: z.ZodObject<{
-    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>;
     model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    apiKey: z.ZodEffects<z.ZodString, string, string>;
+    apiKey: z.ZodOptional<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>;
     allowedMediaTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router: "vercel" | "in-built";
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
     maxIterations: number;
+    apiKey?: string | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router?: "vercel" | "in-built" | undefined;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -34,33 +51,91 @@ export declare const LLMConfigBaseSchema: z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }>;
+/**
+ * Creates an LLM config schema with configurable validation strictness.
+ *
+ * @param options.strict - When true (default), enforces API key and baseURL requirements.
+ *                         When false, allows missing credentials for interactive configuration.
+ */
+export declare function createLLMConfigSchema(options?: LLMValidationOptions): z.ZodBranded<z.ZodEffects<z.ZodObject<{
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>;
+    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    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>;
+    allowedMediaTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    maxIterations: number;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
+    maxIterations?: number | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}>, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    maxIterations: number;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
+    maxIterations?: number | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}>, "ValidatedLLMConfig">;
+/**
+ * Default LLM config schema with strict validation (backwards compatible).
+ * Use createLLMConfigSchema({ strict: false }) for relaxed validation.
+ */
 export declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
-    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>;
     model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    apiKey: z.ZodEffects<z.ZodString, string, string>;
+    apiKey: z.ZodOptional<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>;
     allowedMediaTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router: "vercel" | "in-built";
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
     maxIterations: number;
+    apiKey?: string | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router?: "vercel" | "in-built" | undefined;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -68,21 +143,74 @@ export declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }>, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router: "vercel" | "in-built";
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
     maxIterations: number;
+    apiKey?: string | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }, {
-    apiKey: string;
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    router?: "vercel" | "in-built" | undefined;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
+    maxIterations?: number | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}>, "ValidatedLLMConfig">;
+/**
+ * Relaxed LLM config schema that allows missing API keys and baseURLs.
+ * Use this for interactive modes (CLI, WebUI) where users can configure later.
+ */
+export declare const LLMConfigSchemaRelaxed: z.ZodBranded<z.ZodEffects<z.ZodObject<{
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>;
+    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    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>;
+    allowedMediaTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    maxIterations: number;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
+    maxIterations?: number | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}>, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    maxIterations: number;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    temperature?: number | undefined;
+    allowedMediaTypes?: string[] | undefined;
+}, {
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -93,21 +221,19 @@ export declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
 export type LLMConfig = z.input<typeof LLMConfigSchema>;
 export type ValidatedLLMConfig = z.output<typeof LLMConfigSchema>;
 export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
-    provider: z.ZodOptional<z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>>;
+    provider: z.ZodOptional<z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>>;
     model: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
-    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    apiKey: z.ZodOptional<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>>;
     allowedMediaTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
-    apiKey?: string | undefined;
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    router?: "vercel" | "in-built" | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -115,10 +241,9 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }, {
-    apiKey?: string | undefined;
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    router?: "vercel" | "in-built" | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -126,10 +251,9 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }>, {
-    apiKey?: string | undefined;
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    router?: "vercel" | "in-built" | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;
@@ -137,10 +261,9 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
 }, {
-    apiKey?: string | undefined;
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-    router?: "vercel" | "in-built" | undefined;
+    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+    apiKey?: string | undefined;
     maxIterations?: number | undefined;
     baseURL?: string | undefined;
     maxInputTokens?: number | undefined;

package/dist/llm/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/llm/schemas.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkExB,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcnB,CAAC;AAEd,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAsIM,CAAC;AAGnC,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAIlE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvB,CAAC;AACP,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/llm/schemas.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAsDD,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcnB,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,oBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4IvE;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA0C,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA2C,CAAC;AAG/E,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAIlE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvB,CAAC;AACP,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/llm/schemas.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { LLMErrorCode } from "./error-codes.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { DextoRuntimeError } from "../errors/index.js";
@@ -9,22 +9,20 @@ import {
   supportsBaseURL,
   requiresBaseURL,
   acceptsAnyModel,
+  supportsCustomModels,
   getSupportedModels,
   isValidProviderModel,
   getMaxInputTokensForModel,
-  isRouterSupportedForModel,
-  getSupportedRoutersForModel
+  requiresApiKey
 } from "./registry.js";
-import { LLM_PROVIDERS, LLM_ROUTERS } from "./types.js";
+import { LLM_PROVIDERS } from "./types.js";
 const LLMConfigFields = {
   provider: z.enum(LLM_PROVIDERS).describe("LLM provider (e.g., 'openai', 'anthropic', 'google', 'groq')"),
   model: NonEmptyTrimmed.describe("Specific model name for the selected provider"),
   // Expand $ENV refs and trim; final validation happens with provider context
-  apiKey: EnvExpandedString().describe(
-    "API key for provider; can be given directly or via $ENV reference"
-  ),
+  // Optional for providers that don't need API keys (Ollama, vLLM, etc.)
+  apiKey: EnvExpandedString().optional().describe("API key for provider; can be given directly or via $ENV reference"),
   maxIterations: z.coerce.number().int().positive().describe("Max iterations for agentic loops"),
-  router: z.enum(LLM_ROUTERS).describe("Router to use (vercel | in-built)"),
   baseURL: OptionalURL.describe(
     "Base URL for provider (e.g., https://api.openai.com/v1). Only certain providers support this."
   ),
@@ -38,136 +36,129 @@ const LLMConfigFields = {
 const LLMConfigBaseSchema = z.object({
   provider: LLMConfigFields.provider,
   model: LLMConfigFields.model,
+  // apiKey is optional at schema level - validated based on provider in superRefine
   apiKey: LLMConfigFields.apiKey,
   // Apply defaults only for complete config validation
   maxIterations: z.coerce.number().int().positive().default(50),
-  router: z.enum(LLM_ROUTERS).default("vercel"),
   baseURL: LLMConfigFields.baseURL,
   maxInputTokens: LLMConfigFields.maxInputTokens,
   maxOutputTokens: LLMConfigFields.maxOutputTokens,
   temperature: LLMConfigFields.temperature,
   allowedMediaTypes: LLMConfigFields.allowedMediaTypes
 }).strict();
-const LLMConfigSchema = LLMConfigBaseSchema.superRefine((data, ctx) => {
-  const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
-  const maxInputTokensIsSet = data.maxInputTokens != null;
-  if (!data.apiKey?.trim()) {
-    const primaryVar = getPrimaryApiKeyEnvVar(data.provider);
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["apiKey"],
-      message: `Missing API key for provider '${data.provider}' \u2013 set $${primaryVar}`,
-      params: {
-        code: LLMErrorCode.API_KEY_MISSING,
-        scope: ErrorScope.LLM,
-        type: ErrorType.USER,
-        provider: data.provider,
-        envVar: primaryVar
-      }
-    });
-  }
-  if (baseURLIsSet) {
-    if (!supportsBaseURL(data.provider)) {
+function createLLMConfigSchema(options = {}) {
+  const { strict = true } = options;
+  return LLMConfigBaseSchema.superRefine((data, ctx) => {
+    const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
+    const maxInputTokensIsSet = data.maxInputTokens != null;
+    if (strict && requiresApiKey(data.provider) && !data.apiKey?.trim()) {
+      const primaryVar = getPrimaryApiKeyEnvVar(data.provider);
       ctx.addIssue({
         code: 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.`,
+        path: ["apiKey"],
+        message: `Missing API key for provider '${data.provider}' \u2013 set $${primaryVar}`,
         params: {
-          code: LLMErrorCode.BASE_URL_INVALID,
+          code: LLMErrorCode.API_KEY_MISSING,
           scope: ErrorScope.LLM,
-          type: ErrorType.USER
+          type: ErrorType.USER,
+          provider: data.provider,
+          envVar: primaryVar
         }
       });
     }
-  } else if (requiresBaseURL(data.provider)) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["baseURL"],
-      message: `Provider '${data.provider}' requires a 'baseURL'.`,
-      params: {
-        code: LLMErrorCode.BASE_URL_MISSING,
-        scope: ErrorScope.LLM,
-        type: ErrorType.USER
-      }
-    });
-  } else {
-    if (!acceptsAnyModel(data.provider)) {
-      const supportedModelsList = getSupportedModels(data.provider);
-      if (!isValidProviderModel(data.provider, data.model)) {
+    if (baseURLIsSet) {
+      if (!supportsBaseURL(data.provider)) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          path: ["model"],
-          message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
+          path: ["provider"],
+          message: `Provider '${data.provider}' does not support baseURL. Use an 'openai-compatible' provider if you need a custom base URL.`,
           params: {
-            code: LLMErrorCode.MODEL_INCOMPATIBLE,
+            code: LLMErrorCode.BASE_URL_INVALID,
             scope: ErrorScope.LLM,
             type: ErrorType.USER
           }
         });
       }
+    } else if (strict && requiresBaseURL(data.provider)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["baseURL"],
+        message: `Provider '${data.provider}' requires a 'baseURL'.`,
+        params: {
+          code: LLMErrorCode.BASE_URL_MISSING,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
     }
-    if (maxInputTokensIsSet && !acceptsAnyModel(data.provider)) {
-      try {
-        const cap = getMaxInputTokensForModel(data.provider, data.model);
-        if (data.maxInputTokens > cap) {
+    if (!baseURLIsSet || supportsBaseURL(data.provider)) {
+      if (!acceptsAnyModel(data.provider) && !supportsCustomModels(data.provider)) {
+        const supportedModelsList = getSupportedModels(data.provider);
+        if (!isValidProviderModel(data.provider, data.model)) {
           ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            path: ["maxInputTokens"],
-            message: `Max input tokens for model '${data.model}' is ${cap}. You provided ${data.maxInputTokens}`,
+            path: ["model"],
+            message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
             params: {
-              code: LLMErrorCode.TOKENS_EXCEEDED,
+              code: LLMErrorCode.MODEL_INCOMPATIBLE,
               scope: ErrorScope.LLM,
               type: ErrorType.USER
             }
           });
         }
-      } catch (error) {
-        if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
-          ctx.addIssue({
-            code: 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: z.ZodIssueCode.custom,
-            path: ["model"],
-            message,
-            params: {
-              code: LLMErrorCode.REQUEST_INVALID_SCHEMA,
-              scope: ErrorScope.LLM,
-              type: ErrorType.SYSTEM
-            }
-          });
+      }
+      if (maxInputTokensIsSet && !acceptsAnyModel(data.provider) && !supportsCustomModels(data.provider)) {
+        try {
+          const cap = getMaxInputTokensForModel(data.provider, data.model);
+          if (data.maxInputTokens > cap) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              path: ["maxInputTokens"],
+              message: `Max input tokens for model '${data.model}' is ${cap}. You provided ${data.maxInputTokens}`,
+              params: {
+                code: LLMErrorCode.TOKENS_EXCEEDED,
+                scope: ErrorScope.LLM,
+                type: ErrorType.USER
+              }
+            });
+          }
+        } catch (error) {
+          if (error instanceof DextoRuntimeError && error.code === LLMErrorCode.MODEL_UNKNOWN) {
+            ctx.addIssue({
+              code: 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: z.ZodIssueCode.custom,
+              path: ["model"],
+              message,
+              params: {
+                code: LLMErrorCode.REQUEST_INVALID_SCHEMA,
+                scope: ErrorScope.LLM,
+                type: ErrorType.SYSTEM
+              }
+            });
+          }
         }
       }
     }
-  }
-  if (!isRouterSupportedForModel(data.provider, data.model, data.router)) {
-    const supportedRouters = getSupportedRoutersForModel(data.provider, data.model);
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["router"],
-      message: `Model '${data.model}' (${data.provider}) does not support router '${data.router}'. Supported: ${supportedRouters.join(", ")}`,
-      params: {
-        code: LLMErrorCode.ROUTER_UNSUPPORTED,
-        scope: ErrorScope.LLM,
-        type: ErrorType.USER
-      }
-    });
-  }
-}).brand();
+  }).brand();
+}
+const LLMConfigSchema = createLLMConfigSchema({ strict: true });
+const LLMConfigSchemaRelaxed = createLLMConfigSchema({ strict: false });
 const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().superRefine((data, ctx) => {
-  if (!data.model && !data.provider && !data.router) {
+  if (!data.model && !data.provider) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
-      message: "At least model, provider, or router must be specified for LLM switch",
+      message: "At least model or provider must be specified for LLM switch",
       path: []
     });
   }
@@ -175,5 +166,7 @@ const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().superRefine(
 export {
   LLMConfigBaseSchema,
   LLMConfigSchema,
-  LLMUpdatesSchema
+  LLMConfigSchemaRelaxed,
+  LLMUpdatesSchema,
+  createLLMConfigSchema
 };