@dexto/core 1.6.0 → 1.6.2

package/dist/llm/schemas.d.ts

@@ -10,29 +10,44 @@ export declare const LLMConfigBaseSchema: z.ZodObject<{
     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"]>>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        variant: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }>>;
 }, "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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
 }>;
 /**
  * LLM config schema.
@@ -51,55 +66,86 @@ export declare const LLMConfigSchema: z.ZodEffects<z.ZodObject<{
     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"]>>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        variant: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }>>;
 }, "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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | undefined;
+    temperature?: 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;
 }>;
 export type LLMConfig = z.input<typeof LLMConfigSchema>;
 export type ValidatedLLMConfig = z.output<typeof LLMConfigSchema>;
 export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
+    reasoning: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        variant: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }, {
+        variant: string;
+        budgetTokens?: number | undefined;
+    }>>>>;
     provider: z.ZodOptional<z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "minimax", "glm", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama", "dexto-nova"]>>;
     model: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
     apiKey: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>>;
@@ -109,51 +155,62 @@ export declare const LLMUpdatesSchema: z.ZodEffects<z.ZodObject<{
     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, {
+    apiKey?: string | undefined;
     model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
-    apiKey?: string | undefined;
     maxInputTokens?: number | undefined;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | null | undefined;
+    temperature?: 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;
 }, {
+    apiKey?: string | undefined;
     model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
-    apiKey?: string | undefined;
     maxInputTokens?: number | undefined;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | null | undefined;
+    temperature?: 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;
 }>, {
+    apiKey?: string | undefined;
     model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
-    apiKey?: string | undefined;
     maxInputTokens?: number | undefined;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | null | undefined;
+    temperature?: 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;
 }, {
+    apiKey?: string | undefined;
     model?: string | undefined;
     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
-    apiKey?: string | undefined;
     maxInputTokens?: number | undefined;
+    reasoning?: {
+        variant: string;
+        budgetTokens?: number | undefined;
+    } | null | undefined;
+    temperature?: 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;
 }>;
 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":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/llm/schemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuFxB,4CAA4C;AAG5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnB,CAAC;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyJ1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DvB,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

@@ -14,6 +14,7 @@ import {
   getMaxInputTokensForModel
 } from "./registry/index.js";
 import { LLM_PROVIDERS } from "./types.js";
+import { getReasoningProfile, supportsReasoningVariant } from "./reasoning/profile.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"),
@@ -31,18 +32,15 @@ const LLMConfigFields = {
     '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'"
+  reasoning: z.object({
+    variant: NonEmptyTrimmed.describe(
+      "Model/provider-native reasoning variant (resolved by reasoning profile for the selected model)."
+    ),
+    budgetTokens: z.coerce.number().int().positive().optional().describe(
+      "Advanced escape hatch for budget-based providers (e.g., Anthropic/Gemini/Bedrock/OpenRouter)."
+    )
+  }).strict().optional().describe(
+    "Reasoning configuration using model/provider-native variants (tuning only; display is controlled separately)."
   )
 };
 const LLMConfigBaseSchema = z.object({
@@ -57,7 +55,7 @@ const LLMConfigBaseSchema = z.object({
   temperature: LLMConfigFields.temperature,
   allowedMediaTypes: LLMConfigFields.allowedMediaTypes,
   // Provider-specific options
-  reasoningEffort: LLMConfigFields.reasoningEffort
+  reasoning: LLMConfigFields.reasoning
 }).strict();
 const LLMConfigSchema = LLMConfigBaseSchema.superRefine((data, ctx) => {
   const baseURLIsSet = data.baseURL != null && data.baseURL.trim() !== "";
@@ -147,8 +145,42 @@ const LLMConfigSchema = LLMConfigBaseSchema.superRefine((data, ctx) => {
       }
     }
   }
+  if (data.reasoning) {
+    const profile = getReasoningProfile(data.provider, data.model);
+    const variant = data.reasoning.variant;
+    const budgetTokens = data.reasoning.budgetTokens;
+    if (!supportsReasoningVariant(profile, variant)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["reasoning", "variant"],
+        message: `Reasoning variant '${variant}' is not supported for provider '${data.provider}' model '${data.model}'. Supported: ${profile.variants.map((entry) => entry.id).join(", ")}`,
+        params: {
+          code: LLMErrorCode.MODEL_INCOMPATIBLE,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
+    }
+    if (typeof budgetTokens === "number" && !profile.supportsBudgetTokens) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["reasoning", "budgetTokens"],
+        message: `Reasoning budgetTokens are not supported for provider '${data.provider}' model '${data.model}'. Remove reasoning.budgetTokens to use provider defaults.`,
+        params: {
+          code: LLMErrorCode.MODEL_INCOMPATIBLE,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
 });
-const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().superRefine((data, ctx) => {
+const LLMUpdatesSchema = z.object({
+  ...LLMConfigFields,
+  // Special-case: allow `null` as an explicit "clear reasoning config" sentinel for switch flows.
+  // Full configs (LLMConfigSchema) still require `reasoning` to be an object when present.
+  reasoning: LLMConfigFields.reasoning.nullable()
+}).partial().superRefine((data, ctx) => {
   if (!data.model && !data.provider) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
@@ -156,6 +188,35 @@ const LLMUpdatesSchema = z.object({ ...LLMConfigFields }).partial().superRefine(
       path: []
     });
   }
+  if (data.reasoning && data.reasoning !== null && typeof data.provider === "string" && typeof data.model === "string") {
+    const profile = getReasoningProfile(data.provider, data.model);
+    const variant = data.reasoning.variant;
+    const budgetTokens = data.reasoning.budgetTokens;
+    if (!supportsReasoningVariant(profile, variant)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["reasoning", "variant"],
+        message: `Reasoning variant '${variant}' is not supported for provider '${data.provider}' model '${data.model}'. Supported: ${profile.variants.map((entry) => entry.id).join(", ")}`,
+        params: {
+          code: LLMErrorCode.MODEL_INCOMPATIBLE,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
+    }
+    if (typeof budgetTokens === "number" && !profile.supportsBudgetTokens) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["reasoning", "budgetTokens"],
+        message: `Reasoning budgetTokens are not supported for provider '${data.provider}' model '${data.model}'. Remove reasoning.budgetTokens to use provider defaults.`,
+        params: {
+          code: LLMErrorCode.MODEL_INCOMPATIBLE,
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
 });
 export {
   LLMConfigBaseSchema,

package/dist/llm/services/factory.cjs

@@ -24,6 +24,7 @@ __export(factory_exports, {
 module.exports = __toCommonJS(factory_exports);
 var import_errors = require("../errors.js");
 var import_openai = require("@ai-sdk/openai");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
 var import_google = require("@ai-sdk/google");
 var import_anthropic = require("@ai-sdk/anthropic");
 var import_groq = require("@ai-sdk/groq");
@@ -31,11 +32,19 @@ var import_xai = require("@ai-sdk/xai");
 var import_google_vertex = require("@ai-sdk/google-vertex");
 var import_anthropic2 = require("@ai-sdk/google-vertex/anthropic");
 var import_amazon_bedrock = require("@ai-sdk/amazon-bedrock");
+var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
 var import_vercel = require("./vercel.js");
 var import_cohere = require("@ai-sdk/cohere");
 var import_ai_sdk_adapter = require("../providers/local/ai-sdk-adapter.js");
 var import_registry = require("../registry/index.js");
 var import_api_key_resolver = require("../../utils/api-key-resolver.js");
+var import_anthropic_betas = require("../reasoning/anthropic-betas.js");
+var import_anthropic_thinking = require("../reasoning/anthropic-thinking.js");
+function isLanguageModel(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate["modelId"] === "string" && (typeof candidate["doGenerate"] === "function" || typeof candidate["doStream"] === "function");
+}
 const DEXTO_GATEWAY_HEADERS = {
   SESSION_ID: "X-Dexto-Session-ID",
   CLIENT_SOURCE: "X-Dexto-Source",
@@ -57,11 +66,29 @@ function createVercelModel(llmConfig, context) {
       if (!compatibleBaseURL) {
         throw import_errors.LLMError.baseUrlMissing("openai-compatible");
       }
-      return (0, import_openai.createOpenAI)({ apiKey: apiKey ?? "", baseURL: compatibleBaseURL }).chat(model);
+      const provider2 = (0, import_openai_compatible.createOpenAICompatible)({
+        name: "openaiCompatible",
+        baseURL: compatibleBaseURL,
+        ...apiKey?.trim() ? { apiKey } : {}
+      });
+      return provider2.chatModel(model);
     }
     case "openrouter": {
       const orBaseURL = baseURL || "https://openrouter.ai/api/v1";
-      return (0, import_openai.createOpenAI)({ apiKey: apiKey ?? "", baseURL: orBaseURL }).responses(model);
+      const provider2 = (0, import_ai_sdk_provider.createOpenRouter)({
+        apiKey: apiKey ?? "",
+        baseURL: orBaseURL,
+        compatibility: "strict"
+      });
+      const chatModel = provider2.chat(model);
+      if (!isLanguageModel(chatModel)) {
+        throw import_errors.LLMError.generationFailed(
+          "OpenRouter provider returned an invalid language model instance",
+          "openrouter",
+          model
+        );
+      }
+      return chatModel;
     }
     case "minimax": {
       const minimaxBaseURL = baseURL || "https://api.minimax.chat/v1";
@@ -92,9 +119,22 @@ function createVercelModel(llmConfig, context) {
       if (process.env.DEXTO_CLI_VERSION) {
         headers[DEXTO_GATEWAY_HEADERS.CLIENT_VERSION] = process.env.DEXTO_CLI_VERSION;
       }
-      return (0, import_openai.createOpenAI)({ apiKey: apiKey ?? "", baseURL: dextoBaseURL, headers }).chat(
-        model
-      );
+      const provider2 = (0, import_ai_sdk_provider.createOpenRouter)({
+        apiKey: apiKey ?? "",
+        baseURL: dextoBaseURL,
+        headers,
+        // This is an OpenRouter-compatible gateway; keep strict mode to enable OR features.
+        compatibility: "strict"
+      });
+      const chatModel = provider2.chat(model);
+      if (!isLanguageModel(chatModel)) {
+        throw import_errors.LLMError.generationFailed(
+          "Dexto gateway provider returned an invalid language model instance",
+          "dexto-nova",
+          model
+        );
+      }
+      return chatModel;
     }
     case "vertex": {
       const projectId = process.env.GOOGLE_VERTEX_PROJECT;
@@ -106,9 +146,11 @@ function createVercelModel(llmConfig, context) {
       }
       const location = process.env.GOOGLE_VERTEX_LOCATION;
       if (model.includes("claude")) {
+        const headers = (0, import_anthropic_thinking.supportsAnthropicInterleavedThinking)(model) ? { [import_anthropic_betas.ANTHROPIC_BETA_HEADER]: import_anthropic_betas.ANTHROPIC_INTERLEAVED_THINKING_BETA } : void 0;
         return (0, import_anthropic2.createVertexAnthropic)({
           project: projectId,
-          location: location || "us-east5"
+          location: location || "us-east5",
+          ...headers ? { headers } : {}
         })(model);
       }
       return (0, import_google_vertex.createVertex)({
@@ -132,8 +174,13 @@ function createVercelModel(llmConfig, context) {
       }
       return (0, import_amazon_bedrock.createAmazonBedrock)({ region })(modelId);
     }
-    case "anthropic":
-      return (0, import_anthropic.createAnthropic)({ apiKey: apiKey ?? "" })(model);
+    case "anthropic": {
+      const headers = (0, import_anthropic_thinking.supportsAnthropicInterleavedThinking)(model) ? { [import_anthropic_betas.ANTHROPIC_BETA_HEADER]: import_anthropic_betas.ANTHROPIC_INTERLEAVED_THINKING_BETA } : void 0;
+      return (0, import_anthropic.createAnthropic)({
+        apiKey: apiKey ?? "",
+        ...headers ? { headers } : {}
+      })(model);
+    }
     case "google":
       return (0, import_google.createGoogleGenerativeAI)({ apiKey: apiKey ?? "" })(model);
     case "groq":

package/dist/llm/services/factory.d.ts

@@ -1,7 +1,7 @@
 import { ToolManager } from '../../tools/tool-manager.js';
 import { ValidatedLLMConfig } from '../schemas.js';
 import { VercelLLMService } from './vercel.js';
-import { LanguageModel } from 'ai';
+import type { LanguageModel } from 'ai';
 import { SessionEventBus } from '../../events/index.js';
 import type { ConversationHistoryProvider } from '../../session/history/types.js';
 import type { SystemPromptManager } from '../../systemPrompt/manager.js';

package/dist/llm/services/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/services/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAUnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAClF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAWvD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,oBAAoB,GAC/B,aAAa,CAoLf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,mBAAmB,EACxC,eAAe,EAAE,2BAA2B,EAC5C,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,OAAO,0BAA0B,EAAE,eAAe,EACnE,MAAM,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,OAAO,mCAAmC,EAAE,kBAAkB,GAAG,IAAI,GAC3F,gBAAgB,CAelB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/services/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAYnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAClF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AA0BvD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,oBAAoB,GAC/B,aAAa,CA6Nf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,mBAAmB,EACxC,eAAe,EAAE,2BAA2B,EAC5C,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,OAAO,0BAA0B,EAAE,eAAe,EACnE,MAAM,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,OAAO,mCAAmC,EAAE,kBAAkB,GAAG,IAAI,GAC3F,gBAAgB,CAelB"}

package/dist/llm/services/factory.js

@@ -1,6 +1,7 @@
 import "../../chunk-PTJYTZNU.js";
 import { LLMError } from "../errors.js";
 import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createGroq } from "@ai-sdk/groq";
@@ -8,11 +9,22 @@ import { createXai } from "@ai-sdk/xai";
 import { createVertex } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic";
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { VercelLLMService } from "./vercel.js";
 import { createCohere } from "@ai-sdk/cohere";
 import { createLocalLanguageModel } from "../providers/local/ai-sdk-adapter.js";
 import { requiresApiKey } from "../registry/index.js";
 import { getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from "../../utils/api-key-resolver.js";
+import {
+  ANTHROPIC_BETA_HEADER,
+  ANTHROPIC_INTERLEAVED_THINKING_BETA
+} from "../reasoning/anthropic-betas.js";
+import { supportsAnthropicInterleavedThinking } from "../reasoning/anthropic-thinking.js";
+function isLanguageModel(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate["modelId"] === "string" && (typeof candidate["doGenerate"] === "function" || typeof candidate["doStream"] === "function");
+}
 const DEXTO_GATEWAY_HEADERS = {
   SESSION_ID: "X-Dexto-Session-ID",
   CLIENT_SOURCE: "X-Dexto-Source",
@@ -34,11 +46,29 @@ function createVercelModel(llmConfig, context) {
       if (!compatibleBaseURL) {
         throw LLMError.baseUrlMissing("openai-compatible");
       }
-      return createOpenAI({ apiKey: apiKey ?? "", baseURL: compatibleBaseURL }).chat(model);
+      const provider2 = createOpenAICompatible({
+        name: "openaiCompatible",
+        baseURL: compatibleBaseURL,
+        ...apiKey?.trim() ? { apiKey } : {}
+      });
+      return provider2.chatModel(model);
     }
     case "openrouter": {
       const orBaseURL = baseURL || "https://openrouter.ai/api/v1";
-      return createOpenAI({ apiKey: apiKey ?? "", baseURL: orBaseURL }).responses(model);
+      const provider2 = createOpenRouter({
+        apiKey: apiKey ?? "",
+        baseURL: orBaseURL,
+        compatibility: "strict"
+      });
+      const chatModel = provider2.chat(model);
+      if (!isLanguageModel(chatModel)) {
+        throw LLMError.generationFailed(
+          "OpenRouter provider returned an invalid language model instance",
+          "openrouter",
+          model
+        );
+      }
+      return chatModel;
     }
     case "minimax": {
       const minimaxBaseURL = baseURL || "https://api.minimax.chat/v1";
@@ -69,9 +99,22 @@ function createVercelModel(llmConfig, context) {
       if (process.env.DEXTO_CLI_VERSION) {
         headers[DEXTO_GATEWAY_HEADERS.CLIENT_VERSION] = process.env.DEXTO_CLI_VERSION;
       }
-      return createOpenAI({ apiKey: apiKey ?? "", baseURL: dextoBaseURL, headers }).chat(
-        model
-      );
+      const provider2 = createOpenRouter({
+        apiKey: apiKey ?? "",
+        baseURL: dextoBaseURL,
+        headers,
+        // This is an OpenRouter-compatible gateway; keep strict mode to enable OR features.
+        compatibility: "strict"
+      });
+      const chatModel = provider2.chat(model);
+      if (!isLanguageModel(chatModel)) {
+        throw LLMError.generationFailed(
+          "Dexto gateway provider returned an invalid language model instance",
+          "dexto-nova",
+          model
+        );
+      }
+      return chatModel;
     }
     case "vertex": {
       const projectId = process.env.GOOGLE_VERTEX_PROJECT;
@@ -83,9 +126,11 @@ function createVercelModel(llmConfig, context) {
       }
       const location = process.env.GOOGLE_VERTEX_LOCATION;
       if (model.includes("claude")) {
+        const headers = supportsAnthropicInterleavedThinking(model) ? { [ANTHROPIC_BETA_HEADER]: ANTHROPIC_INTERLEAVED_THINKING_BETA } : void 0;
         return createVertexAnthropic({
           project: projectId,
-          location: location || "us-east5"
+          location: location || "us-east5",
+          ...headers ? { headers } : {}
         })(model);
       }
       return createVertex({
@@ -109,8 +154,13 @@ function createVercelModel(llmConfig, context) {
       }
       return createAmazonBedrock({ region })(modelId);
     }
-    case "anthropic":
-      return createAnthropic({ apiKey: apiKey ?? "" })(model);
+    case "anthropic": {
+      const headers = supportsAnthropicInterleavedThinking(model) ? { [ANTHROPIC_BETA_HEADER]: ANTHROPIC_INTERLEAVED_THINKING_BETA } : void 0;
+      return createAnthropic({
+        apiKey: apiKey ?? "",
+        ...headers ? { headers } : {}
+      })(model);
+    }
     case "google":
       return createGoogleGenerativeAI({ apiKey: apiKey ?? "" })(model);
     case "groq":

package/dist/llm/services/vercel.cjs

@@ -151,7 +151,7 @@ class VercelLLMService {
         temperature: this.config.temperature,
         baseURL: this.config.baseURL,
         // Provider-specific options
-        reasoningEffort: this.config.reasoningEffort
+        reasoning: this.config.reasoning
       },
       { provider: this.config.provider, model: this.getModelId() },
       this.logger,
@@ -199,7 +199,7 @@ class VercelLLMService {
       const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
       await this.contextManager.addUserMessage(parts);
       const executor = this.createTurnExecutor(options?.signal);
-      const contributorContext = { mcpManager: this.toolManager.getMcpManager() };
+      const contributorContext = await this.toolManager.buildContributorContext();
       const result = await executor.execute(contributorContext, true);
       return {
         text: result.text ?? ""

package/dist/llm/services/vercel.js

@@ -88,7 +88,7 @@ class VercelLLMService {
         temperature: this.config.temperature,
         baseURL: this.config.baseURL,
         // Provider-specific options
-        reasoningEffort: this.config.reasoningEffort
+        reasoning: this.config.reasoning
       },
       { provider: this.config.provider, model: this.getModelId() },
       this.logger,
@@ -136,7 +136,7 @@ class VercelLLMService {
       const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
       await this.contextManager.addUserMessage(parts);
       const executor = this.createTurnExecutor(options?.signal);
-      const contributorContext = { mcpManager: this.toolManager.getMcpManager() };
+      const contributorContext = await this.toolManager.buildContributorContext();
       const result = await executor.execute(contributorContext, true);
       return {
         text: result.text ?? ""