@dexto/core 1.5.8 → 1.6.0

package/dist/llm/resolver.d.ts

@@ -2,20 +2,20 @@ import { Result } from '../utils/result.js';
 import { Issue } from '../errors/types.js';
 import { type ValidatedLLMConfig, type LLMUpdates, type LLMConfig } from './schemas.js';
 import type { LLMUpdateContext } from './types.js';
-import type { IDextoLogger } from '../logger/v2/types.js';
+import type { Logger } from '../logger/v2/types.js';
 /**
  * Convenience function that combines resolveLLM and validateLLM
  */
-export declare function resolveAndValidateLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates, logger: IDextoLogger): Promise<Result<ValidatedLLMConfig, LLMUpdateContext>>;
+export declare function resolveAndValidateLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates, logger: Logger): Promise<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
  */
-export declare function resolveLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates, logger: IDextoLogger): Promise<{
+export declare function resolveLLMConfig(previous: ValidatedLLMConfig, updates: LLMUpdates, logger: Logger): Promise<{
     candidate: LLMConfig;
     warnings: Issue<LLMUpdateContext>[];
 }>;
-export declare function validateLLMConfig(candidate: LLMConfig, warnings: Issue<LLMUpdateContext>[], logger: IDextoLogger): Result<ValidatedLLMConfig, LLMUpdateContext>;
+export declare function validateLLMConfig(candidate: LLMConfig, warnings: Issue<LLMUpdateContext>[], logger: Logger): Result<ValidatedLLMConfig, LLMUpdateContext>;
 //# sourceMappingURL=resolver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/llm/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiD,MAAM,oBAAoB,CAAC;AAC3F,OAAO,EAAE,KAAK,EAAyB,MAAM,uBAAuB,CAAC;AAGrE,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAgBxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAM7D;;GAEG;AACH,wBAAsB,2BAA2B,CAC7C,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC,CAUvD;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAA;CAAE,CAAC,CAoLxE;AAGD,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,EAAE,EACnC,MAAM,EAAE,YAAY,GACrB,MAAM,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAuC9C"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/llm/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiD,MAAM,oBAAoB,CAAC;AAC3F,OAAO,EAAE,KAAK,EAAyB,MAAM,oBAAoB,CAAC;AAGlE,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAgBxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAMpD;;GAEG;AACH,wBAAsB,2BAA2B,CAC7C,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC,CAUvD;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAA;CAAE,CAAC,CAoLxE;AAGD,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,EAAE,EACnC,MAAM,EAAE,MAAM,GACf,MAAM,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAuC9C"}

package/dist/llm/schemas.cjs

@@ -20,16 +20,13 @@ var schemas_exports = {};
 __export(schemas_exports, {
   LLMConfigBaseSchema: () => LLMConfigBaseSchema,
   LLMConfigSchema: () => LLMConfigSchema,
-  LLMConfigSchemaRelaxed: () => LLMConfigSchemaRelaxed,
-  LLMUpdatesSchema: () => LLMUpdatesSchema,
-  createLLMConfigSchema: () => createLLMConfigSchema
+  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_types = require("../errors/types.js");
+var import_errors = require("../errors/index.js");
+var import_result = require("../utils/result.js");
 var import_zod = require("zod");
 var import_registry = require("./registry/index.js");
 var import_types2 = require("./types.js");
@@ -69,8 +66,7 @@ const LLMConfigBaseSchema = import_zod.z.object({
   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: import_zod.z.coerce.number().int().positive().optional(),
+  maxIterations: LLMConfigFields.maxIterations.optional().describe("Max outer-loop tool-call iterations per agent turn"),
   baseURL: LLMConfigFields.baseURL,
   maxInputTokens: LLMConfigFields.maxInputTokens,
   maxOutputTokens: LLMConfigFields.maxOutputTokens,
@@ -79,126 +75,95 @@ const LLMConfigBaseSchema = import_zod.z.object({
   // Provider-specific options
   reasoningEffort: LLMConfigFields.reasoningEffort
 }).strict();
-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 ((0, import_registry.hasAllRegistryModelsSupport)(data.provider) && !data.model.includes("/")) {
+const LLMConfigSchema = LLMConfigBaseSchema.superRefine((data, ctx) => {
+  const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
+  const maxInputTokensIsSet = data.maxInputTokens != null;
+  if ((0, import_registry.hasAllRegistryModelsSupport)(data.provider) && !data.model.includes("/")) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["model"],
+      message: `Provider '${data.provider}' requires OpenRouter-format model IDs (e.g. 'openai/gpt-5-mini' or 'anthropic/claude-sonnet-4.5'). You provided '${data.model}'.`,
+      params: {
+        code: import_error_codes.LLMErrorCode.MODEL_INCOMPATIBLE,
+        scope: import_types.ErrorScope.LLM,
+        type: import_types.ErrorType.USER
+      }
+    });
+  }
+  if (baseURLIsSet) {
+    if (!(0, import_registry.supportsBaseURL)(data.provider)) {
       ctx.addIssue({
         code: import_zod.z.ZodIssueCode.custom,
-        path: ["model"],
-        message: `Provider '${data.provider}' requires OpenRouter-format model IDs (e.g. 'openai/gpt-5-mini' or 'anthropic/claude-sonnet-4.5'). You provided '${data.model}'.`,
+        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.MODEL_INCOMPATIBLE,
+          code: import_error_codes.LLMErrorCode.BASE_URL_INVALID,
           scope: import_types.ErrorScope.LLM,
           type: import_types.ErrorType.USER
         }
       });
     }
-    if (strict && (0, import_registry.requiresApiKey)(data.provider) && !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)) {
+  }
+  if (!baseURLIsSet || (0, import_registry.supportsBaseURL)(data.provider)) {
+    if (!(0, import_registry.acceptsAnyModel)(data.provider) && !(0, import_registry.supportsCustomModels)(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: ["provider"],
-          message: `Provider '${data.provider}' does not support baseURL. Use an 'openai-compatible' provider if you need a custom base URL.`,
+          path: ["model"],
+          message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
           params: {
-            code: import_error_codes.LLMErrorCode.BASE_URL_INVALID,
+            code: import_error_codes.LLMErrorCode.MODEL_INCOMPATIBLE,
             scope: import_types.ErrorScope.LLM,
             type: import_types.ErrorType.USER
           }
         });
       }
-    } else if (strict && (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
-        }
-      });
     }
-    if (!baseURLIsSet || (0, import_registry.supportsBaseURL)(data.provider)) {
-      if (!(0, import_registry.acceptsAnyModel)(data.provider) && !(0, import_registry.supportsCustomModels)(data.provider)) {
-        const supportedModelsList = (0, import_registry.getSupportedModels)(data.provider);
-        if (!(0, import_registry.isValidProviderModel)(data.provider, data.model)) {
+    if (maxInputTokensIsSet && !(0, import_registry.acceptsAnyModel)(data.provider) && !(0, import_registry.supportsCustomModels)(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: ["model"],
-            message: `Model '${data.model}' is not supported for provider '${data.provider}'. Supported: ${supportedModelsList.join(", ")}`,
+            path: ["maxInputTokens"],
+            message: `Max input tokens for model '${data.model}' is ${cap}. You provided ${data.maxInputTokens}`,
             params: {
-              code: import_error_codes.LLMErrorCode.MODEL_INCOMPATIBLE,
+              code: import_error_codes.LLMErrorCode.TOKENS_EXCEEDED,
               scope: import_types.ErrorScope.LLM,
               type: import_types.ErrorType.USER
             }
           });
         }
-      }
-      if (maxInputTokensIsSet && !(0, import_registry.acceptsAnyModel)(data.provider) && !(0, import_registry.supportsCustomModels)(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
-              }
-            });
-          }
+      } 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
+            }
+          });
         }
       }
     }
-  }).brand();
-}
-const LLMConfigSchema = createLLMConfigSchema({ strict: true });
-const LLMConfigSchemaRelaxed = createLLMConfigSchema({ strict: false });
+  }
+});
 const LLMUpdatesSchema = import_zod.z.object({ ...LLMConfigFields }).partial().superRefine((data, ctx) => {
   if (!data.model && !data.provider) {
     ctx.addIssue({
@@ -212,7 +177,5 @@ const LLMUpdatesSchema = import_zod.z.object({ ...LLMConfigFields }).partial().s
 0 && (module.exports = {
   LLMConfigBaseSchema,
   LLMConfigSchema,
-  LLMConfigSchemaRelaxed,
-  LLMUpdatesSchema,
-  createLLMConfigSchema
+  LLMUpdatesSchema
 });

package/dist/llm/schemas.d.ts

@@ -1,24 +1,4 @@
 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", "minimax", "glm", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama", "dexto-nova"]>;
@@ -55,72 +35,13 @@ export declare const LLMConfigBaseSchema: z.ZodObject<{
     reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
 }>;
 /**
- * Creates an LLM config schema with configurable validation strictness.
+ * LLM config schema.
  *
- * @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", "minimax", "glm", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama", "dexto-nova"]>;
-    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    maxIterations: z.ZodOptional<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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}>, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}>, "ValidatedLLMConfig">;
-/**
- * Default LLM config schema with strict validation (backwards compatible).
- * Use createLLMConfigSchema({ strict: false }) for relaxed validation.
+ * Notes:
+ * - API keys and base URLs are validated at runtime (when creating a provider client), not at parse time.
+ * - This keeps programmatic construction (code-first DI) ergonomic: you can omit credentials and rely on env.
  */
-export declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
+export declare const LLMConfigSchema: z.ZodEffects<z.ZodObject<{
     provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "minimax", "glm", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama", "dexto-nova"]>;
     model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
@@ -175,67 +96,7 @@ export declare const LLMConfigSchema: z.ZodBranded<z.ZodEffects<z.ZodObject<{
     temperature?: number | undefined;
     allowedMediaTypes?: string[] | undefined;
     reasoningEffort?: "low" | "none" | "minimal" | "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", "minimax", "glm", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama", "dexto-nova"]>;
-    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    apiKey: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    maxIterations: z.ZodOptional<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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}>, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
-}, {
-    model: string;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
-    apiKey?: string | undefined;
-    maxInputTokens?: number | undefined;
-    maxIterations?: number | undefined;
-    baseURL?: string | undefined;
-    maxOutputTokens?: number | undefined;
-    temperature?: number | undefined;
-    allowedMediaTypes?: string[] | undefined;
-    reasoningEffort?: "low" | "none" | "minimal" | "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<{

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;AAcxB;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA6JvE;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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/llm/schemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoFxB,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnB,CAAC;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqH1B,CAAC;AAGH,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"}