@dexto/core 1.4.0 → 1.5.1

package/dist/llm/schemas.d.ts

@@ -1,102 +1,257 @@
 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>;
     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">>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh"]>>;
 }, "strict", z.ZodTypeAny, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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">>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh"]>>;
+}, "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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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>;
     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">>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh"]>>;
 }, "strict", z.ZodTypeAny, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }>, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }, {
     model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    apiKey: 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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">>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh"]>>;
+}, "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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | 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;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }>, "ValidatedLLMConfig">;
 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>;
     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">>>;
+    reasoningEffort: z.ZodOptional<z.ZodOptional<z.ZodEnum<["none", "minimal", "low", "medium", "high", "xhigh"]>>>;
 }, "strip", z.ZodTypeAny, {
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | 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;
@@ -104,9 +259,10 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }, {
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | 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;
@@ -114,9 +270,10 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }>, {
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | 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;
@@ -124,9 +281,10 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }, {
     model?: string | undefined;
-    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | 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;
@@ -134,6 +292,7 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     maxOutputTokens?: number | undefined;
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
 }>;
 export type LLMUpdates = z.input<typeof LLMUpdatesSchema>;
 export type { LLMUpdateContext } from '../llm/types.js';

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;AA8DxB,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAanB,CAAC;AAEd,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAsHM,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;AA0ED,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,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

@@ -9,18 +9,19 @@ import {
   supportsBaseURL,
   requiresBaseURL,
   acceptsAnyModel,
+  supportsCustomModels,
   getSupportedModels,
   isValidProviderModel,
-  getMaxInputTokensForModel
+  getMaxInputTokensForModel,
+  requiresApiKey
 } from "./registry.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"),
   baseURL: OptionalURL.describe(
     "Base URL for provider (e.g., https://api.openai.com/v1). Only certain providers support this."
@@ -30,11 +31,26 @@ const LLMConfigFields = {
   temperature: z.coerce.number().min(0).max(1).optional().describe("Randomness: 0 deterministic, 1 creative"),
   allowedMediaTypes: z.array(z.string()).optional().describe(
     'MIME type patterns for media expansion (e.g., "image/*", "application/pdf"). If omitted, uses model capabilities from registry. Supports wildcards.'
+  ),
+  // Provider-specific options
+  /**
+   * OpenAI reasoning effort level for reasoning-capable models (o1, o3, codex, gpt-5.x).
+   * Controls how many reasoning tokens the model generates before producing a response.
+   * - 'none': No reasoning, fastest responses
+   * - 'minimal': Barely any reasoning, very fast responses
+   * - 'low': Light reasoning, fast responses
+   * - 'medium': Balanced reasoning (OpenAI's recommended daily driver)
+   * - 'high': Thorough reasoning for complex tasks
+   * - 'xhigh': Extra high reasoning for quality-critical, non-latency-sensitive tasks
+   */
+  reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional().describe(
+    "OpenAI reasoning effort level for reasoning models (o1, o3, codex). Options: 'none', 'minimal', 'low', 'medium' (recommended), 'high', 'xhigh'"
   )
 };
 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),
@@ -42,110 +58,118 @@ const LLMConfigBaseSchema = z.object({
   maxInputTokens: LLMConfigFields.maxInputTokens,
   maxOutputTokens: LLMConfigFields.maxOutputTokens,
   temperature: LLMConfigFields.temperature,
-  allowedMediaTypes: LLMConfigFields.allowedMediaTypes
+  allowedMediaTypes: LLMConfigFields.allowedMediaTypes,
+  // Provider-specific options
+  reasoningEffort: LLMConfigFields.reasoningEffort
 }).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
+              }
+            });
+          }
         }
       }
     }
-  }
-}).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) {
     ctx.addIssue({
@@ -158,5 +182,7 @@ const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().superRefine(
 export {
   LLMConfigBaseSchema,
   LLMConfigSchema,
-  LLMUpdatesSchema
+  LLMConfigSchemaRelaxed,
+  LLMUpdatesSchema,
+  createLLMConfigSchema
 };