@dexto/core 1.1.4

package/dist/chunk-J6AXCN3H.js

@@ -0,0 +1,1268 @@
+import {
+  DextoValidationError
+} from "./chunk-XFQLRBHE.js";
+import {
+  getDextoGlobalPath,
+  logger
+} from "./chunk-D62MHQBE.js";
+import {
+  DextoRuntimeError
+} from "./chunk-TPERKLLN.js";
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/preferences/loader.ts
+init_esm_shims();
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/preferences/schemas.ts
+init_esm_shims();
+import { z as z2 } from "zod";
+
+// src/llm/registry.ts
+init_esm_shims();
+
+// src/llm/errors.ts
+init_esm_shims();
+
+// src/llm/error-codes.ts
+init_esm_shims();
+var LLMErrorCode = /* @__PURE__ */ ((LLMErrorCode2) => {
+  LLMErrorCode2["API_KEY_MISSING"] = "llm_api_key_missing";
+  LLMErrorCode2["API_KEY_INVALID"] = "llm_api_key_invalid";
+  LLMErrorCode2["API_KEY_CANDIDATE_MISSING"] = "llm_api_key_candidate_missing";
+  LLMErrorCode2["BASE_URL_MISSING"] = "llm_base_url_missing";
+  LLMErrorCode2["BASE_URL_INVALID"] = "llm_base_url_invalid";
+  LLMErrorCode2["MODEL_INCOMPATIBLE"] = "llm_model_incompatible";
+  LLMErrorCode2["MODEL_UNKNOWN"] = "llm_model_unknown";
+  LLMErrorCode2["PROVIDER_UNSUPPORTED"] = "llm_provider_unsupported";
+  LLMErrorCode2["ROUTER_UNSUPPORTED"] = "llm_router_unsupported";
+  LLMErrorCode2["INPUT_FILE_UNSUPPORTED"] = "llm_input_file_unsupported";
+  LLMErrorCode2["INPUT_IMAGE_UNSUPPORTED"] = "llm_input_image_unsupported";
+  LLMErrorCode2["INPUT_TEXT_INVALID"] = "llm_input_text_invalid";
+  LLMErrorCode2["TOKENS_EXCEEDED"] = "llm_tokens_exceeded";
+  LLMErrorCode2["RATE_LIMIT_EXCEEDED"] = "llm_rate_limit_exceeded";
+  LLMErrorCode2["SWITCH_FAILED"] = "llm_switch_failed";
+  LLMErrorCode2["GENERATION_FAILED"] = "llm_generation_failed";
+  LLMErrorCode2["SWITCH_INPUT_MISSING"] = "llm_switch_input_missing";
+  LLMErrorCode2["REQUEST_INVALID_SCHEMA"] = "llm_request_invalid_schema";
+  return LLMErrorCode2;
+})(LLMErrorCode || {});
+
+// src/llm/errors.ts
+var LLMError = class {
+  // Runtime model/provider lookup errors
+  static unknownModel(provider, model) {
+    return new DextoRuntimeError(
+      "llm_model_unknown" /* MODEL_UNKNOWN */,
+      "llm" /* LLM */,
+      "user" /* USER */,
+      `Unknown model '${model}' for provider '${provider}'`,
+      { provider, model }
+    );
+  }
+  static baseUrlMissing(provider) {
+    return new DextoRuntimeError(
+      "llm_base_url_missing" /* BASE_URL_MISSING */,
+      "llm" /* LLM */,
+      "user" /* USER */,
+      `Provider '${provider}' requires a baseURL (set config.baseURL or OPENAI_BASE_URL environment variable)`,
+      { provider }
+    );
+  }
+  static modelProviderUnknown(model) {
+    const availableProviders = getSupportedProviders();
+    return new DextoRuntimeError(
+      "llm_model_unknown" /* MODEL_UNKNOWN */,
+      "llm" /* LLM */,
+      "user" /* USER */,
+      `Unknown model '${model}' - could not infer provider. Available providers: ${availableProviders.join(", ")}`,
+      { model, availableProviders },
+      "Specify the provider explicitly or use a recognized model name"
+    );
+  }
+  static unsupportedRouter(router, provider) {
+    const supportedRouters = getSupportedRoutersForProvider(provider).map((r) => r);
+    return new DextoRuntimeError(
+      "llm_router_unsupported" /* ROUTER_UNSUPPORTED */,
+      "llm" /* LLM */,
+      "user" /* USER */,
+      `Router '${router}' not supported for provider '${provider}'. Supported: ${supportedRouters.join(", ")}`,
+      { router, provider, supportedRouters }
+    );
+  }
+  // Runtime service errors
+  static rateLimitExceeded(provider, retryAfter) {
+    return new DextoRuntimeError(
+      "llm_rate_limit_exceeded" /* RATE_LIMIT_EXCEEDED */,
+      "llm" /* LLM */,
+      "rate_limit" /* RATE_LIMIT */,
+      `Rate limit exceeded for ${provider}`,
+      {
+        details: { provider, retryAfter },
+        recovery: retryAfter ? `Wait ${retryAfter} seconds before retrying` : "Wait before retrying or upgrade your plan"
+      }
+    );
+  }
+  // Runtime operation errors
+  static generationFailed(error, provider, model) {
+    return new DextoRuntimeError(
+      "llm_generation_failed" /* GENERATION_FAILED */,
+      "llm" /* LLM */,
+      "third_party" /* THIRD_PARTY */,
+      `Generation failed: ${error}`,
+      { details: { error, provider, model } }
+    );
+  }
+  // Switch operation errors (runtime checks not covered by Zod)
+  static switchInputMissing() {
+    return new DextoRuntimeError(
+      "llm_switch_input_missing" /* SWITCH_INPUT_MISSING */,
+      "llm" /* LLM */,
+      "user" /* USER */,
+      "At least model or provider must be specified for LLM switch",
+      {},
+      "Provide either a model name, provider, or both"
+    );
+  }
+};
+
+// src/llm/types.ts
+init_esm_shims();
+var LLM_PROVIDERS = [
+  "openai",
+  "openai-compatible",
+  "anthropic",
+  "google",
+  "groq",
+  "xai",
+  "cohere"
+];
+var LLM_ROUTERS = ["vercel", "in-built"];
+var SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
+
+// src/llm/registry.ts
+var MIME_TYPE_TO_FILE_TYPE = {
+  "application/pdf": "pdf",
+  "audio/mp3": "audio",
+  "audio/mpeg": "audio",
+  "audio/wav": "audio",
+  "audio/x-wav": "audio",
+  "audio/wave": "audio",
+  "audio/webm": "audio",
+  "audio/ogg": "audio",
+  "audio/m4a": "audio",
+  "audio/aac": "audio",
+  // Common image MIME types
+  "image/jpeg": "image",
+  "image/jpg": "image",
+  "image/png": "image",
+  "image/webp": "image",
+  "image/gif": "image"
+};
+function getAllowedMimeTypes() {
+  return Object.keys(MIME_TYPE_TO_FILE_TYPE);
+}
+var DEFAULT_MAX_INPUT_TOKENS = 128e3;
+var LLM_REGISTRY = {
+  openai: {
+    models: [
+      {
+        name: "gpt-5",
+        displayName: "GPT-5",
+        maxInputTokens: 4e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 1.25,
+          outputPerM: 10,
+          cacheReadPerM: 0.125,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-5-mini",
+        displayName: "GPT-5 Mini",
+        maxInputTokens: 4e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.25,
+          outputPerM: 2,
+          cacheReadPerM: 0.025,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-5-nano",
+        displayName: "GPT-5 Nano",
+        maxInputTokens: 4e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.05,
+          outputPerM: 0.4,
+          cacheReadPerM: 5e-3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4.1",
+        displayName: "GPT-4.1",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 2,
+          outputPerM: 8,
+          cacheReadPerM: 0.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4.1-mini",
+        displayName: "GPT-4.1 Mini",
+        maxInputTokens: 1048576,
+        default: true,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.4,
+          outputPerM: 1.6,
+          cacheReadPerM: 0.1,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4.1-nano",
+        displayName: "GPT-4.1 Nano",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.1,
+          outputPerM: 0.4,
+          cacheReadPerM: 0.025,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4o",
+        displayName: "GPT-4o",
+        maxInputTokens: 128e3,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 2.5,
+          outputPerM: 10,
+          cacheReadPerM: 1.25,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4o-mini",
+        displayName: "GPT-4o Mini",
+        maxInputTokens: 128e3,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.15,
+          outputPerM: 0.6,
+          cacheReadPerM: 0.075,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gpt-4o-audio-preview",
+        displayName: "GPT-4o Audio Preview",
+        maxInputTokens: 128e3,
+        supportedFileTypes: ["audio"],
+        pricing: {
+          inputPerM: 2.5,
+          outputPerM: 10,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "o4-mini",
+        displayName: "O4 Mini",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 1.1,
+          outputPerM: 4.4,
+          cacheReadPerM: 0.275,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "o3",
+        displayName: "O3",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 2,
+          outputPerM: 8,
+          cacheReadPerM: 0.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "o3-mini",
+        displayName: "O3 Mini",
+        maxInputTokens: 2e5,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 1.1,
+          outputPerM: 4.4,
+          cacheReadPerM: 0.55,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "o1",
+        displayName: "O1",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 15,
+          outputPerM: 60,
+          cacheReadPerM: 7.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel", "in-built"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  "openai-compatible": {
+    models: [],
+    // Empty - accepts any model name for custom endpoints
+    supportedRouters: ["vercel", "in-built"],
+    baseURLSupport: "required",
+    supportedFileTypes: ["pdf", "image", "audio"]
+    // Allow all types for custom endpoints - user assumes responsibility for model capabilities
+  },
+  anthropic: {
+    models: [
+      {
+        name: "claude-opus-4-1-20250805",
+        displayName: "Claude 4.1 Opus",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 15,
+          outputPerM: 75,
+          cacheWritePerM: 18.75,
+          cacheReadPerM: 1.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "claude-4-opus-20250514",
+        displayName: "Claude 4 Opus",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 15,
+          outputPerM: 75,
+          cacheWritePerM: 18.75,
+          cacheReadPerM: 1.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "claude-4-sonnet-20250514",
+        displayName: "Claude 4 Sonnet",
+        maxInputTokens: 2e5,
+        default: true,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheWritePerM: 3.75,
+          cacheReadPerM: 0.3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "claude-3-7-sonnet-20250219",
+        displayName: "Claude 3.7 Sonnet",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheWritePerM: 3.75,
+          cacheReadPerM: 0.3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "claude-3-5-sonnet-20240620",
+        displayName: "Claude 3.5 Sonnet",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheWritePerM: 3.75,
+          cacheReadPerM: 0.3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "claude-3-5-haiku-20241022",
+        displayName: "Claude 3.5 Haiku",
+        maxInputTokens: 2e5,
+        supportedFileTypes: ["pdf", "image"],
+        pricing: {
+          inputPerM: 0.8,
+          outputPerM: 4,
+          cacheWritePerM: 1,
+          cacheReadPerM: 0.08,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel", "in-built"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  google: {
+    models: [
+      {
+        name: "gemini-2.5-pro",
+        displayName: "Gemini 2.5 Pro",
+        maxInputTokens: 1048576,
+        default: true,
+        supportedFileTypes: ["pdf", "image", "audio"],
+        pricing: {
+          inputPerM: 1.25,
+          outputPerM: 10,
+          cacheReadPerM: 0.31,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gemini-2.5-flash",
+        displayName: "Gemini 2.5 Flash",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"],
+        pricing: {
+          inputPerM: 0.3,
+          outputPerM: 2.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gemini-2.5-flash-lite",
+        displayName: "Gemini 2.5 Flash Lite",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"],
+        pricing: {
+          inputPerM: 0.1,
+          outputPerM: 0.4,
+          cacheReadPerM: 0.025,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gemini-2.0-flash",
+        displayName: "Gemini 2.0 Flash",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"],
+        pricing: {
+          inputPerM: 0.15,
+          outputPerM: 0.6,
+          cacheReadPerM: 0.025,
+          cacheWritePerM: 1,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "gemini-2.0-flash-lite",
+        displayName: "Gemini 2.0 Flash Lite",
+        maxInputTokens: 1048576,
+        supportedFileTypes: ["pdf", "image", "audio"],
+        pricing: {
+          inputPerM: 0.075,
+          outputPerM: 0.3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // No defaults - models must explicitly specify support
+  },
+  // https://console.groq.com/docs/models
+  groq: {
+    models: [
+      {
+        name: "gemma-2-9b-it",
+        displayName: "Gemma 2 9B Instruct",
+        maxInputTokens: 8192,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.2,
+          outputPerM: 0.2,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "openai/gpt-oss-20b",
+        displayName: "GPT OSS 20B 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.1,
+          outputPerM: 0.5,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "openai/gpt-oss-120b",
+        displayName: "GPT OSS 120B 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.15,
+          outputPerM: 0.75,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "moonshotai/kimi-k2-instruct",
+        displayName: "Kimi K2 1T 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 1,
+          outputPerM: 3,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "meta-llama/llama-4-scout-17b-16e-instruct",
+        displayName: "Llama 4 Scout (17Bx16E) 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.11,
+          outputPerM: 0.34,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "meta-llama/llama-4-maverick-17b-128e-instruct",
+        displayName: "Llama 4 Maverick (17Bx128E) 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.2,
+          outputPerM: 0.6,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "deepseek-r1-distill-llama-70b",
+        displayName: "DeepSeek R1 Distill Llama 70B 128k",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.75,
+          outputPerM: 0.9,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "qwen/qwen3-32b",
+        displayName: "Qwen3 32B 131k",
+        maxInputTokens: 131e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.29,
+          outputPerM: 0.59,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "llama-3.3-70b-versatile",
+        displayName: "Llama 3.3 70B Versatile",
+        maxInputTokens: 128e3,
+        default: true,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.59,
+          outputPerM: 0.79,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // Groq currently doesn't support file uploads
+  },
+  // https://docs.x.ai/docs/models
+  // Note: XAI API only supports image uploads (JPG/PNG up to 20MB), not PDFs
+  xai: {
+    models: [
+      {
+        name: "grok-4",
+        displayName: "Grok 4",
+        maxInputTokens: 256e3,
+        default: true,
+        supportedFileTypes: ["image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheReadPerM: 0.75,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "grok-3",
+        displayName: "Grok 3",
+        maxInputTokens: 131072,
+        supportedFileTypes: ["image"],
+        pricing: {
+          inputPerM: 3,
+          outputPerM: 15,
+          cacheReadPerM: 0.75,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "grok-3-mini",
+        displayName: "Grok 3 Mini",
+        maxInputTokens: 131072,
+        supportedFileTypes: ["image"],
+        pricing: {
+          inputPerM: 0.3,
+          outputPerM: 0.5,
+          cacheReadPerM: 0.075,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "grok-code-fast-1",
+        displayName: "Grok Code Fast",
+        maxInputTokens: 131072,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.2,
+          outputPerM: 1.5,
+          cacheReadPerM: 0.02,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // XAI currently doesn't support file uploads
+  },
+  // https://docs.cohere.com/reference/models
+  cohere: {
+    models: [
+      {
+        name: "command-a-03-2025",
+        displayName: "Command A (03-2025)",
+        maxInputTokens: 256e3,
+        default: true,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 2.5,
+          outputPerM: 10,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "command-r-plus",
+        displayName: "Command R+",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 2.5,
+          outputPerM: 10,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "command-r",
+        displayName: "Command R",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.15,
+          outputPerM: 0.6,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      },
+      {
+        name: "command-r7b",
+        displayName: "Command R7B",
+        maxInputTokens: 128e3,
+        supportedFileTypes: [],
+        pricing: {
+          inputPerM: 0.0375,
+          outputPerM: 0.15,
+          currency: "USD",
+          unit: "per_million_tokens"
+        }
+      }
+    ],
+    supportedRouters: ["vercel"],
+    baseURLSupport: "none",
+    supportedFileTypes: []
+    // Cohere currently doesn't support file uploads
+  }
+};
+function getDefaultModelForProvider(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.find((m) => m.default)?.name || null;
+}
+function getSupportedProviders() {
+  return [...LLM_PROVIDERS];
+}
+function getSupportedModels(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.map((m) => m.name);
+}
+function getMaxInputTokensForModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const modelInfo = providerInfo.models.find((m) => m.name.toLowerCase() === model.toLowerCase());
+  if (!modelInfo) {
+    const supportedModels = getSupportedModels(provider).join(", ");
+    logger.error(
+      `Model '${model}' not found for provider '${provider}' in LLM registry. Supported models: ${supportedModels}`
+    );
+    throw LLMError.unknownModel(provider, model);
+  }
+  logger.debug(`Found max tokens for ${provider}/${model}: ${modelInfo.maxInputTokens}`);
+  return modelInfo.maxInputTokens;
+}
+function isValidProviderModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.some((m) => m.name.toLowerCase() === model.toLowerCase());
+}
+function getProviderFromModel(model) {
+  const lowerModel = model.toLowerCase();
+  for (const provider of LLM_PROVIDERS) {
+    const info = LLM_REGISTRY[provider];
+    if (info.models.some((m) => m.name.toLowerCase() === lowerModel)) {
+      return provider;
+    }
+  }
+  throw LLMError.modelProviderUnknown(model);
+}
+function getAllSupportedModels() {
+  return Object.values(LLM_REGISTRY).flatMap((info) => info.models.map((m) => m.name));
+}
+function getSupportedRoutersForProvider(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.supportedRouters;
+}
+function supportsBaseURL(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.baseURLSupport !== "none";
+}
+function requiresBaseURL(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.baseURLSupport === "required";
+}
+function acceptsAnyModel(provider) {
+  const providerInfo = LLM_REGISTRY[provider];
+  return providerInfo.models.length === 0;
+}
+function getSupportedFileTypesForModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  if (acceptsAnyModel(provider)) {
+    return providerInfo.supportedFileTypes;
+  }
+  const modelInfo = providerInfo.models.find((m) => m.name.toLowerCase() === model.toLowerCase());
+  if (!modelInfo) {
+    throw LLMError.unknownModel(provider, model);
+  }
+  return modelInfo.supportedFileTypes;
+}
+function modelSupportsFileType(provider, model, fileType) {
+  const supportedTypes = getSupportedFileTypesForModel(provider, model);
+  return supportedTypes.includes(fileType);
+}
+function validateModelFileSupport(provider, model, mimeType) {
+  const baseMimeType = mimeType.toLowerCase().split(";")[0]?.trim() || mimeType.toLowerCase();
+  const fileType = MIME_TYPE_TO_FILE_TYPE[baseMimeType];
+  if (!fileType) {
+    return {
+      isSupported: false,
+      error: `Unsupported file type: ${mimeType}`
+    };
+  }
+  try {
+    if (!modelSupportsFileType(provider, model, fileType)) {
+      return {
+        isSupported: false,
+        fileType,
+        error: `Model '${model}' (${provider}) does not support ${fileType} files`
+      };
+    }
+    return {
+      isSupported: true,
+      fileType
+    };
+  } catch (error) {
+    return {
+      isSupported: false,
+      fileType,
+      error: error instanceof Error ? error.message : "Unknown error validating model file support"
+    };
+  }
+}
+function isRouterSupportedForModel(provider, model, router) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const modelInfo = providerInfo.models.find((m) => m.name.toLowerCase() === model.toLowerCase());
+  if (!modelInfo) {
+    return isRouterSupportedForProvider(provider, router);
+  }
+  if (modelInfo.supportedRouters) {
+    return modelInfo.supportedRouters.includes(router);
+  }
+  return isRouterSupportedForProvider(provider, router);
+}
+function getSupportedRoutersForModel(provider, model) {
+  const providerInfo = LLM_REGISTRY[provider];
+  const modelInfo = providerInfo.models.find((m) => m.name.toLowerCase() === model.toLowerCase());
+  if (!modelInfo) {
+    return getSupportedRoutersForProvider(provider);
+  }
+  if (modelInfo.supportedRouters) {
+    return modelInfo.supportedRouters;
+  }
+  return getSupportedRoutersForProvider(provider);
+}
+function isRouterSupportedForProvider(provider, router) {
+  const supportedRouters = getSupportedRoutersForProvider(provider);
+  return supportedRouters.includes(router);
+}
+function getEffectiveMaxInputTokens(config) {
+  const configuredMaxInputTokens = config.maxInputTokens;
+  if (configuredMaxInputTokens != null) {
+    if (config.baseURL) {
+      logger.debug(
+        `Using maxInputTokens from configuration (with baseURL): ${configuredMaxInputTokens}`
+      );
+      return configuredMaxInputTokens;
+    }
+    try {
+      const registryMaxInputTokens = getMaxInputTokensForModel(config.provider, config.model);
+      if (configuredMaxInputTokens > registryMaxInputTokens) {
+        logger.warn(
+          `Provided maxInputTokens (${configuredMaxInputTokens}) for ${config.provider}/${config.model} exceeds the known limit (${registryMaxInputTokens}) for model ${config.model}. Capping to registry limit.`
+        );
+        return registryMaxInputTokens;
+      } else {
+        logger.debug(
+          `Using valid maxInputTokens override from configuration: ${configuredMaxInputTokens} (Registry limit: ${registryMaxInputTokens})`
+        );
+        return configuredMaxInputTokens;
+      }
+    } catch (error) {
+      if (error instanceof DextoRuntimeError && error.code === "llm_model_unknown" /* MODEL_UNKNOWN */) {
+        logger.warn(
+          `Registry lookup failed during maxInputTokens override check for ${config.provider}/${config.model}: ${error.message}. Proceeding with the provided maxInputTokens value (${configuredMaxInputTokens}), but it might be invalid.`
+        );
+        return configuredMaxInputTokens;
+      } else {
+        logger.error(
+          `Unexpected error during registry lookup for maxInputTokens override check: ${error}`
+        );
+        throw error;
+      }
+    }
+  }
+  if (config.baseURL) {
+    logger.warn(
+      `baseURL is set but maxInputTokens is missing. Defaulting to ${DEFAULT_MAX_INPUT_TOKENS}. Provide 'maxInputTokens' in configuration to avoid default fallback.`
+    );
+    return DEFAULT_MAX_INPUT_TOKENS;
+  }
+  if (acceptsAnyModel(config.provider)) {
+    logger.debug(
+      `Provider ${config.provider} accepts any model, defaulting to ${DEFAULT_MAX_INPUT_TOKENS} tokens`
+    );
+    return DEFAULT_MAX_INPUT_TOKENS;
+  }
+  try {
+    const registryMaxInputTokens = getMaxInputTokensForModel(config.provider, config.model);
+    logger.debug(
+      `Using maxInputTokens from registry for ${config.provider}/${config.model}: ${registryMaxInputTokens}`
+    );
+    return registryMaxInputTokens;
+  } catch (error) {
+    if (error instanceof DextoRuntimeError && error.code === "llm_model_unknown" /* MODEL_UNKNOWN */) {
+      logger.error(
+        `Registry lookup failed for ${config.provider}/${config.model}: ${error.message}. Effective maxInputTokens cannot be determined.`
+      );
+      throw LLMError.unknownModel(config.provider, config.model);
+    } else {
+      logger.error(`Unexpected error during registry lookup for maxInputTokens: ${error}`);
+      throw error;
+    }
+  }
+}
+
+// src/utils/result.ts
+init_esm_shims();
+import { z } from "zod";
+var NonEmptyTrimmed = z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
+function isValidUrl(s) {
+  try {
+    const u = new URL(s);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var OptionalURL = z.string().transform((s) => s.trim()).refine((s) => s === "" || isValidUrl(s), { message: "Invalid URL" }).transform((s) => s === "" ? void 0 : s).optional();
+var EnvExpandedString = (env) => z.string().transform((input) => {
+  if (typeof input !== "string") return "";
+  const envToUse = env ?? process.env;
+  const out = input.replace(
+    /\$([A-Z_][A-Z0-9_]*)|\${([A-Z_][A-Z0-9_]*)}/gi,
+    (_, a, b) => envToUse[a || b] ?? ""
+  );
+  return out.trim();
+});
+var NonEmptyEnvExpandedString = (env) => EnvExpandedString(env).refine((s) => s.length > 0, {
+  message: "Value is required"
+});
+var RequiredEnvURL = (env) => EnvExpandedString(env).refine(
+  (s) => {
+    try {
+      const u = new URL(s);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  { message: "Invalid URL" }
+);
+var ok = (data, issues = []) => ({
+  ok: true,
+  data,
+  issues
+  // warnings live alongside errors here
+});
+var fail = (issues) => ({
+  ok: false,
+  issues
+});
+function hasErrors(issues) {
+  return issues.some((i) => i.severity !== "warning");
+}
+function splitIssues(issues) {
+  return {
+    errors: issues.filter((i) => i.severity !== "warning"),
+    warnings: issues.filter((i) => i.severity === "warning")
+  };
+}
+function zodToIssues(err, severity = "error") {
+  return err.errors.map((e) => {
+    const params = e.params || {};
+    return {
+      code: params.code ?? "schema_validation",
+      message: e.message,
+      scope: params.scope ?? "agent" /* AGENT */,
+      // Fallback for non-custom Zod errors
+      // Treat plain Zod schema failures as USER errors by default
+      type: params.type ?? "user" /* USER */,
+      path: e.path,
+      severity,
+      context: params
+    };
+  });
+}
+
+// src/preferences/error-codes.ts
+init_esm_shims();
+var PreferenceErrorCode = /* @__PURE__ */ ((PreferenceErrorCode2) => {
+  PreferenceErrorCode2["FILE_NOT_FOUND"] = "preference_file_not_found";
+  PreferenceErrorCode2["FILE_READ_ERROR"] = "preference_file_read_error";
+  PreferenceErrorCode2["FILE_WRITE_ERROR"] = "preference_file_write_error";
+  PreferenceErrorCode2["VALIDATION_ERROR"] = "preference_validation_error";
+  PreferenceErrorCode2["MODEL_INCOMPATIBLE"] = "preference_model_incompatible";
+  return PreferenceErrorCode2;
+})(PreferenceErrorCode || {});
+
+// src/preferences/schemas.ts
+var PreferenceLLMSchema = z2.object({
+  provider: z2.enum(LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
+  model: NonEmptyTrimmed.describe("Model name for the provider"),
+  apiKey: z2.string().regex(
+    /^\$[A-Z_][A-Z0-9_]*$/,
+    "Must be environment variable reference (e.g., $OPENAI_API_KEY)"
+  ).describe("Environment variable reference for API key")
+}).strict().superRefine((data, ctx) => {
+  if (!isValidProviderModel(data.provider, data.model)) {
+    const supportedModels = getSupportedModels(data.provider);
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["model"],
+      message: `Model '${data.model}' is not supported by provider '${data.provider}'. Supported models: ${supportedModels.join(", ")}`,
+      params: {
+        code: "preference_model_incompatible" /* MODEL_INCOMPATIBLE */,
+        scope: "preference" /* PREFERENCE */,
+        type: "user" /* USER */
+      }
+    });
+  }
+});
+var PreferenceDefaultsSchema = z2.object({
+  defaultAgent: z2.string().min(1).describe("Default agent name for global CLI usage (required)")
+}).strict();
+var PreferenceSetupSchema = z2.object({
+  completed: z2.boolean().default(false).describe("Whether initial setup has been completed")
+}).strict();
+var GlobalPreferencesSchema = z2.object({
+  llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
+  defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
+  setup: PreferenceSetupSchema.default({ completed: false }).describe(
+    "Setup completion tracking"
+  )
+}).strict();
+
+// src/preferences/constants.ts
+init_esm_shims();
+var PREFERENCES_FILE = "preferences.yml";
+
+// src/preferences/errors.ts
+init_esm_shims();
+var PreferenceError = class {
+  static fileNotFound(preferencesPath) {
+    return new DextoRuntimeError(
+      "preference_file_not_found" /* FILE_NOT_FOUND */,
+      "preference" /* PREFERENCE */,
+      "user" /* USER */,
+      `Preferences file not found: ${preferencesPath}`,
+      { preferencesPath },
+      "Run `dexto setup` to create preferences"
+    );
+  }
+  static fileReadError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      "preference_file_read_error" /* FILE_READ_ERROR */,
+      "preference" /* PREFERENCE */,
+      "system" /* SYSTEM */,
+      `Failed to read preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and ensure the file is not corrupted"
+    );
+  }
+  static fileWriteError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      "preference_file_write_error" /* FILE_WRITE_ERROR */,
+      "preference" /* PREFERENCE */,
+      "system" /* SYSTEM */,
+      `Failed to save preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
+  static validationFailed(zodError) {
+    const issues = zodError.issues.map((issue) => ({
+      code: "preference_validation_error" /* VALIDATION_ERROR */,
+      message: `${issue.path.join(".")}: ${issue.message}`,
+      scope: "preference" /* PREFERENCE */,
+      type: "user" /* USER */,
+      severity: "error"
+    }));
+    return new DextoValidationError(issues);
+  }
+};
+
+// src/preferences/loader.ts
+async function loadGlobalPreferences() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  if (!existsSync(preferencesPath)) {
+    throw PreferenceError.fileNotFound(preferencesPath);
+  }
+  try {
+    const fileContent = await fs.readFile(preferencesPath, "utf-8");
+    const rawPreferences = parseYaml(fileContent);
+    const validation = GlobalPreferencesSchema.safeParse(rawPreferences);
+    if (!validation.success) {
+      throw PreferenceError.validationFailed(validation.error);
+    }
+    logger.debug(`Loaded global preferences from: ${preferencesPath}`);
+    return validation.data;
+  } catch (error) {
+    if (error instanceof DextoValidationError || error instanceof DextoRuntimeError) {
+      throw error;
+    }
+    throw PreferenceError.fileReadError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveGlobalPreferences(preferences) {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  const validation = GlobalPreferencesSchema.safeParse(preferences);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  try {
+    logger.info(`Saving global preferences to: ${preferencesPath}`);
+    const dextoDir = getDextoGlobalPath("");
+    await fs.mkdir(dextoDir, { recursive: true });
+    const yamlContent = stringifyYaml(preferences, {
+      indent: 2,
+      lineWidth: 100,
+      minContentWidth: 20
+    });
+    await fs.writeFile(preferencesPath, yamlContent, "utf-8");
+    logger.info(
+      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
+    );
+  } catch (error) {
+    throw PreferenceError.fileWriteError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function globalPreferencesExist() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  return existsSync(preferencesPath);
+}
+function getGlobalPreferencesPath() {
+  return getDextoGlobalPath(PREFERENCES_FILE);
+}
+function createInitialPreferences(provider, model, apiKeyVar, defaultAgent = "default-agent") {
+  return {
+    llm: {
+      provider,
+      model,
+      apiKey: `$${apiKeyVar}`
+    },
+    defaults: {
+      defaultAgent
+    },
+    setup: {
+      completed: true
+    }
+  };
+}
+async function updateGlobalPreferences(updates) {
+  const existing = await loadGlobalPreferences();
+  const merged = {
+    ...existing,
+    ...updates,
+    // LLM section requires complete replacement (high coherence - provider/model/apiKey must match)
+    llm: updates.llm || existing.llm,
+    // Defaults and setup sections allow partial updates (low coherence - independent fields)
+    defaults: updates.defaults ? { ...existing.defaults, ...updates.defaults } : existing.defaults,
+    setup: updates.setup ? { ...existing.setup, ...updates.setup } : existing.setup
+  };
+  const validation = GlobalPreferencesSchema.safeParse(merged);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  await saveGlobalPreferences(validation.data);
+  return validation.data;
+}
+
+export {
+  LLMErrorCode,
+  LLM_PROVIDERS,
+  LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES,
+  MIME_TYPE_TO_FILE_TYPE,
+  getAllowedMimeTypes,
+  DEFAULT_MAX_INPUT_TOKENS,
+  LLM_REGISTRY,
+  getDefaultModelForProvider,
+  getSupportedProviders,
+  getSupportedModels,
+  getMaxInputTokensForModel,
+  isValidProviderModel,
+  getProviderFromModel,
+  getAllSupportedModels,
+  getSupportedRoutersForProvider,
+  supportsBaseURL,
+  requiresBaseURL,
+  acceptsAnyModel,
+  getSupportedFileTypesForModel,
+  modelSupportsFileType,
+  validateModelFileSupport,
+  isRouterSupportedForModel,
+  getSupportedRoutersForModel,
+  isRouterSupportedForProvider,
+  getEffectiveMaxInputTokens,
+  LLMError,
+  NonEmptyTrimmed,
+  OptionalURL,
+  EnvExpandedString,
+  NonEmptyEnvExpandedString,
+  RequiredEnvURL,
+  ok,
+  fail,
+  hasErrors,
+  splitIssues,
+  zodToIssues,
+  PreferenceErrorCode,
+  PreferenceLLMSchema,
+  PreferenceDefaultsSchema,
+  PreferenceSetupSchema,
+  GlobalPreferencesSchema,
+  PREFERENCES_FILE,
+  PreferenceError,
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  globalPreferencesExist,
+  getGlobalPreferencesPath,
+  createInitialPreferences,
+  updateGlobalPreferences
+};