@dexto/core 1.6.0 → 1.6.2

package/dist/llm/executor/provider-options.cjs

@@ -19,69 +19,264 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var provider_options_exports = {};
 __export(provider_options_exports, {
   buildProviderOptions: () => buildProviderOptions,
-  getDefaultReasoningEffort: () => getDefaultReasoningEffort
+  getEffectiveReasoningBudgetTokens: () => getEffectiveReasoningBudgetTokens
 });
 module.exports = __toCommonJS(provider_options_exports);
 var import_registry = require("../registry/index.js");
-function buildProviderOptions(config) {
-  const { provider, model, reasoningEffort } = config;
-  const modelLower = model.toLowerCase();
-  if (provider === "anthropic") {
+var import_anthropic_thinking = require("../reasoning/anthropic-thinking.js");
+var import_anthropic_betas = require("../reasoning/anthropic-betas.js");
+var import_profile = require("../reasoning/profile.js");
+var import_openrouter = require("../reasoning/profiles/openrouter.js");
+var import_openai_reasoning_effort = require("../reasoning/openai-reasoning-effort.js");
+const ANTHROPIC_MIN_THINKING_BUDGET_TOKENS = 1024;
+const ANTHROPIC_DEFAULT_BUDGET_TOKENS = 2048;
+const GOOGLE_DEFAULT_BUDGET_TOKENS = 2048;
+const BEDROCK_DEFAULT_BUDGET_TOKENS = 2048;
+const ANTHROPIC_CACHE_CONTROL = { type: "ephemeral" };
+function coerceBudgetTokens(tokens, minimum) {
+  if (tokens === void 0) return void 0;
+  if (!Number.isFinite(tokens)) return void 0;
+  return Math.max(minimum, Math.floor(tokens));
+}
+function toOpenAIReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "xhigh" ? reasoningVariant : void 0;
+}
+function toOpenAICompatibleReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+}
+function getSelectedReasoningVariant(config) {
+  const profile = (0, import_profile.getReasoningProfile)(config.provider, config.model);
+  const requested = config.reasoning?.variant;
+  if (requested !== void 0) {
+    const supported = profile.variants.some((entry) => entry.id === requested);
+    return {
+      reasoningVariant: supported ? requested : void 0,
+      hasInvalidRequestedReasoningVariant: !supported
+    };
+  }
+  return {
+    reasoningVariant: profile.defaultVariant,
+    hasInvalidRequestedReasoningVariant: false
+  };
+}
+function buildAnthropicProviderOptions(config) {
+  const { model, reasoningVariant, budgetTokens, capable } = config;
+  const adaptiveThinking = (0, import_anthropic_thinking.isAnthropicAdaptiveThinkingModel)(model);
+  if (adaptiveThinking) {
+    if (reasoningVariant === "disabled") {
+      return {
+        anthropic: {
+          cacheControl: ANTHROPIC_CACHE_CONTROL,
+          sendReasoning: false,
+          thinking: { type: "disabled" }
+        }
+      };
+    }
+    const effort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "max" ? reasoningVariant : void 0;
+    return {
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: true,
+        thinking: { type: "adaptive" },
+        ...effort !== void 0 && { effort }
+      }
+    };
+  }
+  if (!capable) {
     return {
       anthropic: {
-        // Enable prompt caching - saves money and improves latency
-        cacheControl: { type: "ephemeral" },
-        // Stream reasoning/thinking content when model supports it
-        sendReasoning: true
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        ...reasoningVariant === "disabled" ? { thinking: { type: "disabled" } } : {}
       }
     };
   }
-  if (provider === "bedrock" && modelLower.includes("claude")) {
+  if (reasoningVariant === "disabled") {
     return {
-      bedrock: {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        thinking: { type: "disabled" }
       }
     };
   }
-  if (provider === "vertex" && modelLower.includes("claude")) {
+  const effectiveBudgetTokens = coerceBudgetTokens(
+    budgetTokens ?? ANTHROPIC_DEFAULT_BUDGET_TOKENS,
+    ANTHROPIC_MIN_THINKING_BUDGET_TOKENS
+  );
+  return {
+    anthropic: {
+      cacheControl: ANTHROPIC_CACHE_CONTROL,
+      sendReasoning: true,
+      ...effectiveBudgetTokens !== void 0 ? { thinking: { type: "enabled", budgetTokens: effectiveBudgetTokens } } : {}
+    }
+  };
+}
+function buildOpenRouterProviderOptions(config) {
+  const { provider, model, reasoningVariant, budgetTokens } = config;
+  const profile = (0, import_profile.getReasoningProfile)(provider, model);
+  if (!profile.capable) {
+    return void 0;
+  }
+  if (reasoningVariant === "disabled") {
+    return { openrouter: { include_reasoning: false } };
+  }
+  if (budgetTokens !== void 0) {
     return {
-      "vertex-anthropic": {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      openrouter: {
+        include_reasoning: true,
+        reasoning: { enabled: true, max_tokens: budgetTokens }
       }
     };
   }
+  if (profile.paradigm === "budget") {
+    if (reasoningVariant === void 0 || reasoningVariant === "enabled") {
+      return {
+        openrouter: {
+          include_reasoning: true
+        }
+      };
+    }
+    return void 0;
+  }
+  const explicitEffort = toOpenAIReasoningEffort(reasoningVariant);
+  const effort = explicitEffort ?? (profile.paradigm === "adaptive-effort" && reasoningVariant === "max" ? "xhigh" : void 0);
+  return {
+    openrouter: {
+      include_reasoning: true,
+      ...effort !== void 0 ? { reasoning: { enabled: true, effort } } : {}
+    }
+  };
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function getEffectiveReasoningBudgetTokens(providerOptions) {
+  if (providerOptions === void 0) return void 0;
+  const anthropic = asRecord(providerOptions["anthropic"]);
+  const thinking = asRecord(anthropic?.["thinking"]);
+  if (thinking?.["type"] === "enabled" && typeof thinking["budgetTokens"] === "number") {
+    return thinking["budgetTokens"];
+  }
+  const google = asRecord(providerOptions["google"]);
+  const thinkingConfig = asRecord(google?.["thinkingConfig"]);
+  if (typeof thinkingConfig?.["thinkingBudget"] === "number") {
+    return thinkingConfig["thinkingBudget"];
+  }
+  const bedrock = asRecord(providerOptions["bedrock"]);
+  const reasoningConfig = asRecord(bedrock?.["reasoningConfig"]);
+  if (typeof reasoningConfig?.["budgetTokens"] === "number") {
+    return reasoningConfig["budgetTokens"];
+  }
+  const openrouter = asRecord(providerOptions["openrouter"]);
+  const reasoning = asRecord(openrouter?.["reasoning"]);
+  if (typeof reasoning?.["max_tokens"] === "number") {
+    return reasoning["max_tokens"];
+  }
+  return void 0;
+}
+function buildProviderOptions(config) {
+  const { provider, model, reasoning } = config;
+  const modelLower = model.toLowerCase();
+  const { reasoningVariant, hasInvalidRequestedReasoningVariant } = getSelectedReasoningVariant(config);
+  const budgetTokens = reasoning?.budgetTokens;
+  if (hasInvalidRequestedReasoningVariant) {
+    return void 0;
+  }
+  if (provider === "anthropic") {
+    const capable = (0, import_registry.isReasoningCapableModel)(model, "anthropic");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
+  if (provider === "bedrock") {
+    const capable = (0, import_registry.isReasoningCapableModel)(model, "bedrock");
+    if (!capable) {
+      return { bedrock: {} };
+    }
+    const isAnthropicModel = modelLower.includes("anthropic");
+    const isNovaModel = modelLower.includes("nova");
+    if (!isAnthropicModel && !isNovaModel) {
+      return { bedrock: {} };
+    }
+    const bedrock = {};
+    if (reasoningVariant === "disabled") {
+      bedrock["reasoningConfig"] = { type: "disabled" };
+      return { bedrock };
+    }
+    if (isAnthropicModel) {
+      const effectiveBudgetTokens = coerceBudgetTokens(
+        budgetTokens ?? BEDROCK_DEFAULT_BUDGET_TOKENS,
+        1
+      );
+      if (effectiveBudgetTokens === void 0) {
+        return { bedrock: {} };
+      }
+      bedrock["reasoningConfig"] = { type: "enabled", budgetTokens: effectiveBudgetTokens };
+      if ((0, import_anthropic_thinking.supportsAnthropicInterleavedThinking)(model)) {
+        bedrock["anthropicBeta"] = [import_anthropic_betas.ANTHROPIC_INTERLEAVED_THINKING_BETA];
+      }
+      return { bedrock };
+    }
+    const maxReasoningEffort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+    if (maxReasoningEffort !== void 0) {
+      bedrock["reasoningConfig"] = { type: "enabled", maxReasoningEffort };
+    }
+    return { bedrock };
+  }
+  if (provider === "vertex" && modelLower.includes("claude")) {
+    const capable = (0, import_registry.isReasoningCapableModel)(model, "vertex");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
   if (provider === "google" || provider === "vertex" && !modelLower.includes("claude")) {
+    const profile = (0, import_profile.getReasoningProfile)(provider, model);
+    const includeThoughts = profile.capable && reasoningVariant !== "disabled";
+    const isThinkingLevel = profile.paradigm === "thinking-level";
+    const thinkingLevel = includeThoughts && isThinkingLevel && (reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high") ? reasoningVariant : void 0;
+    const thinkingBudgetTokens = coerceBudgetTokens(
+      budgetTokens ?? GOOGLE_DEFAULT_BUDGET_TOKENS,
+      1
+    );
     return {
       google: {
         thinkingConfig: {
-          // Include thoughts in the response for transparency
-          includeThoughts: true
+          includeThoughts,
+          ...includeThoughts && isThinkingLevel && thinkingLevel !== void 0 && {
+            thinkingLevel
+          },
+          ...includeThoughts && profile.paradigm === "budget" && thinkingBudgetTokens !== void 0 && {
+            thinkingBudget: thinkingBudgetTokens
+          }
         }
       }
     };
   }
   if (provider === "openai") {
-    const effectiveEffort = reasoningEffort ?? getDefaultReasoningEffort(model);
-    if (effectiveEffort) {
+    const effortCandidate = toOpenAIReasoningEffort(reasoningVariant);
+    if (effortCandidate && (0, import_openai_reasoning_effort.supportsOpenAIReasoningEffort)(model, effortCandidate)) {
       return {
         openai: {
-          reasoningEffort: effectiveEffort
+          reasoningEffort: effortCandidate,
+          ...effortCandidate !== "none" && { reasoningSummary: "auto" }
         }
       };
     }
   }
-  return void 0;
-}
-function getDefaultReasoningEffort(model) {
-  if ((0, import_registry.isReasoningCapableModel)(model)) {
-    return "medium";
+  if ((0, import_openrouter.isOpenRouterGatewayProvider)(provider)) {
+    return buildOpenRouterProviderOptions({ provider, model, reasoningVariant, budgetTokens });
+  }
+  if (provider === "openai-compatible") {
+    const profile = (0, import_profile.getReasoningProfile)(provider, model);
+    if (!profile.capable) return void 0;
+    const reasoningEffort = toOpenAICompatibleReasoningEffort(reasoningVariant);
+    if (reasoningEffort === void 0) return void 0;
+    return {
+      openaiCompatible: { reasoningEffort }
+    };
   }
   return void 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildProviderOptions,
-  getDefaultReasoningEffort
+  getEffectiveReasoningBudgetTokens
 });

package/dist/llm/executor/provider-options.d.ts

@@ -1,49 +1,15 @@
 /**
  * Provider-specific options builder for Vercel AI SDK's streamText/generateText.
- *
- * Centralizes provider-specific configuration that requires explicit opt-in:
- * - Anthropic: cacheControl for prompt caching, sendReasoning for extended thinking
- * - Bedrock/Vertex Claude: Same as Anthropic (Claude models on these platforms)
- * - Google: thinkingConfig for Gemini thinking models
- * - OpenAI: reasoningEffort for o1/o3/codex/gpt-5 models
- *
- * Caching notes:
- * - Anthropic: Requires explicit cacheControl option (we enable it)
- * - OpenAI: Automatic for prompts ≥1024 tokens (no config needed)
- * - Google: Implicit caching automatic for Gemini 2.5+ (≥1024 tokens for Flash,
- *   ≥2048 for Pro). Explicit caching requires pre-created cachedContent IDs.
- * All providers return cached token counts in the response (cachedInputTokens).
  */
-import type { LLMProvider } from '../types.js';
-export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+import type { LLMProvider, LLMReasoningConfig } from '../types.js';
 export interface ProviderOptionsConfig {
     provider: LLMProvider;
     model: string;
-    reasoningEffort?: ReasoningEffort | undefined;
+    reasoning?: LLMReasoningConfig | undefined;
 }
+export declare function getEffectiveReasoningBudgetTokens(providerOptions: Record<string, Record<string, unknown>> | undefined): number | undefined;
 /**
  * Build provider-specific options for streamText/generateText.
- *
- * @param config Provider, model, and optional reasoning effort configuration
- * @returns Provider options object or undefined if no special options needed
  */
 export declare function buildProviderOptions(config: ProviderOptionsConfig): Record<string, Record<string, unknown>> | undefined;
-/**
- * Determine the default reasoning effort for OpenAI models.
- *
- * OpenAI reasoning effort levels (from lowest to highest):
- * - 'none': No reasoning, fastest responses
- * - 'low': Minimal 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
- *
- * Default strategy:
- * - Reasoning-capable models (codex, o1, o3, gpt-5): 'medium' - OpenAI's recommended default
- * - Other models: undefined (no reasoning effort needed)
- *
- * @param model The model name
- * @returns Reasoning effort level or undefined if not applicable
- */
-export declare function getDefaultReasoningEffort(model: string): Exclude<ReasoningEffort, 'none'> | undefined;
 //# sourceMappingURL=provider-options.d.ts.map

package/dist/llm/executor/provider-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider-options.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/provider-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AAEvF,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CACjD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAgErD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACrC,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,SAAS,CAS9C"}
+{"version":3,"file":"provider-options.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/provider-options.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAcnE,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CAC9C;AA4LD,wBAAgB,iCAAiC,CAC7C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GACrE,MAAM,GAAG,SAAS,CA4BpB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CA2IrD"}

package/dist/llm/executor/provider-options.js

@@ -1,63 +1,263 @@
 import "../../chunk-PTJYTZNU.js";
 import { isReasoningCapableModel } from "../registry/index.js";
-function buildProviderOptions(config) {
-  const { provider, model, reasoningEffort } = config;
-  const modelLower = model.toLowerCase();
-  if (provider === "anthropic") {
+import {
+  isAnthropicAdaptiveThinkingModel,
+  supportsAnthropicInterleavedThinking
+} from "../reasoning/anthropic-thinking.js";
+import { ANTHROPIC_INTERLEAVED_THINKING_BETA } from "../reasoning/anthropic-betas.js";
+import { getReasoningProfile } from "../reasoning/profile.js";
+import { isOpenRouterGatewayProvider } from "../reasoning/profiles/openrouter.js";
+import {
+  supportsOpenAIReasoningEffort
+} from "../reasoning/openai-reasoning-effort.js";
+const ANTHROPIC_MIN_THINKING_BUDGET_TOKENS = 1024;
+const ANTHROPIC_DEFAULT_BUDGET_TOKENS = 2048;
+const GOOGLE_DEFAULT_BUDGET_TOKENS = 2048;
+const BEDROCK_DEFAULT_BUDGET_TOKENS = 2048;
+const ANTHROPIC_CACHE_CONTROL = { type: "ephemeral" };
+function coerceBudgetTokens(tokens, minimum) {
+  if (tokens === void 0) return void 0;
+  if (!Number.isFinite(tokens)) return void 0;
+  return Math.max(minimum, Math.floor(tokens));
+}
+function toOpenAIReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "xhigh" ? reasoningVariant : void 0;
+}
+function toOpenAICompatibleReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+}
+function getSelectedReasoningVariant(config) {
+  const profile = getReasoningProfile(config.provider, config.model);
+  const requested = config.reasoning?.variant;
+  if (requested !== void 0) {
+    const supported = profile.variants.some((entry) => entry.id === requested);
+    return {
+      reasoningVariant: supported ? requested : void 0,
+      hasInvalidRequestedReasoningVariant: !supported
+    };
+  }
+  return {
+    reasoningVariant: profile.defaultVariant,
+    hasInvalidRequestedReasoningVariant: false
+  };
+}
+function buildAnthropicProviderOptions(config) {
+  const { model, reasoningVariant, budgetTokens, capable } = config;
+  const adaptiveThinking = isAnthropicAdaptiveThinkingModel(model);
+  if (adaptiveThinking) {
+    if (reasoningVariant === "disabled") {
+      return {
+        anthropic: {
+          cacheControl: ANTHROPIC_CACHE_CONTROL,
+          sendReasoning: false,
+          thinking: { type: "disabled" }
+        }
+      };
+    }
+    const effort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "max" ? reasoningVariant : void 0;
+    return {
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: true,
+        thinking: { type: "adaptive" },
+        ...effort !== void 0 && { effort }
+      }
+    };
+  }
+  if (!capable) {
     return {
       anthropic: {
-        // Enable prompt caching - saves money and improves latency
-        cacheControl: { type: "ephemeral" },
-        // Stream reasoning/thinking content when model supports it
-        sendReasoning: true
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        ...reasoningVariant === "disabled" ? { thinking: { type: "disabled" } } : {}
       }
     };
   }
-  if (provider === "bedrock" && modelLower.includes("claude")) {
+  if (reasoningVariant === "disabled") {
     return {
-      bedrock: {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        thinking: { type: "disabled" }
       }
     };
   }
-  if (provider === "vertex" && modelLower.includes("claude")) {
+  const effectiveBudgetTokens = coerceBudgetTokens(
+    budgetTokens ?? ANTHROPIC_DEFAULT_BUDGET_TOKENS,
+    ANTHROPIC_MIN_THINKING_BUDGET_TOKENS
+  );
+  return {
+    anthropic: {
+      cacheControl: ANTHROPIC_CACHE_CONTROL,
+      sendReasoning: true,
+      ...effectiveBudgetTokens !== void 0 ? { thinking: { type: "enabled", budgetTokens: effectiveBudgetTokens } } : {}
+    }
+  };
+}
+function buildOpenRouterProviderOptions(config) {
+  const { provider, model, reasoningVariant, budgetTokens } = config;
+  const profile = getReasoningProfile(provider, model);
+  if (!profile.capable) {
+    return void 0;
+  }
+  if (reasoningVariant === "disabled") {
+    return { openrouter: { include_reasoning: false } };
+  }
+  if (budgetTokens !== void 0) {
     return {
-      "vertex-anthropic": {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      openrouter: {
+        include_reasoning: true,
+        reasoning: { enabled: true, max_tokens: budgetTokens }
       }
     };
   }
+  if (profile.paradigm === "budget") {
+    if (reasoningVariant === void 0 || reasoningVariant === "enabled") {
+      return {
+        openrouter: {
+          include_reasoning: true
+        }
+      };
+    }
+    return void 0;
+  }
+  const explicitEffort = toOpenAIReasoningEffort(reasoningVariant);
+  const effort = explicitEffort ?? (profile.paradigm === "adaptive-effort" && reasoningVariant === "max" ? "xhigh" : void 0);
+  return {
+    openrouter: {
+      include_reasoning: true,
+      ...effort !== void 0 ? { reasoning: { enabled: true, effort } } : {}
+    }
+  };
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function getEffectiveReasoningBudgetTokens(providerOptions) {
+  if (providerOptions === void 0) return void 0;
+  const anthropic = asRecord(providerOptions["anthropic"]);
+  const thinking = asRecord(anthropic?.["thinking"]);
+  if (thinking?.["type"] === "enabled" && typeof thinking["budgetTokens"] === "number") {
+    return thinking["budgetTokens"];
+  }
+  const google = asRecord(providerOptions["google"]);
+  const thinkingConfig = asRecord(google?.["thinkingConfig"]);
+  if (typeof thinkingConfig?.["thinkingBudget"] === "number") {
+    return thinkingConfig["thinkingBudget"];
+  }
+  const bedrock = asRecord(providerOptions["bedrock"]);
+  const reasoningConfig = asRecord(bedrock?.["reasoningConfig"]);
+  if (typeof reasoningConfig?.["budgetTokens"] === "number") {
+    return reasoningConfig["budgetTokens"];
+  }
+  const openrouter = asRecord(providerOptions["openrouter"]);
+  const reasoning = asRecord(openrouter?.["reasoning"]);
+  if (typeof reasoning?.["max_tokens"] === "number") {
+    return reasoning["max_tokens"];
+  }
+  return void 0;
+}
+function buildProviderOptions(config) {
+  const { provider, model, reasoning } = config;
+  const modelLower = model.toLowerCase();
+  const { reasoningVariant, hasInvalidRequestedReasoningVariant } = getSelectedReasoningVariant(config);
+  const budgetTokens = reasoning?.budgetTokens;
+  if (hasInvalidRequestedReasoningVariant) {
+    return void 0;
+  }
+  if (provider === "anthropic") {
+    const capable = isReasoningCapableModel(model, "anthropic");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
+  if (provider === "bedrock") {
+    const capable = isReasoningCapableModel(model, "bedrock");
+    if (!capable) {
+      return { bedrock: {} };
+    }
+    const isAnthropicModel = modelLower.includes("anthropic");
+    const isNovaModel = modelLower.includes("nova");
+    if (!isAnthropicModel && !isNovaModel) {
+      return { bedrock: {} };
+    }
+    const bedrock = {};
+    if (reasoningVariant === "disabled") {
+      bedrock["reasoningConfig"] = { type: "disabled" };
+      return { bedrock };
+    }
+    if (isAnthropicModel) {
+      const effectiveBudgetTokens = coerceBudgetTokens(
+        budgetTokens ?? BEDROCK_DEFAULT_BUDGET_TOKENS,
+        1
+      );
+      if (effectiveBudgetTokens === void 0) {
+        return { bedrock: {} };
+      }
+      bedrock["reasoningConfig"] = { type: "enabled", budgetTokens: effectiveBudgetTokens };
+      if (supportsAnthropicInterleavedThinking(model)) {
+        bedrock["anthropicBeta"] = [ANTHROPIC_INTERLEAVED_THINKING_BETA];
+      }
+      return { bedrock };
+    }
+    const maxReasoningEffort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+    if (maxReasoningEffort !== void 0) {
+      bedrock["reasoningConfig"] = { type: "enabled", maxReasoningEffort };
+    }
+    return { bedrock };
+  }
+  if (provider === "vertex" && modelLower.includes("claude")) {
+    const capable = isReasoningCapableModel(model, "vertex");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
   if (provider === "google" || provider === "vertex" && !modelLower.includes("claude")) {
+    const profile = getReasoningProfile(provider, model);
+    const includeThoughts = profile.capable && reasoningVariant !== "disabled";
+    const isThinkingLevel = profile.paradigm === "thinking-level";
+    const thinkingLevel = includeThoughts && isThinkingLevel && (reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high") ? reasoningVariant : void 0;
+    const thinkingBudgetTokens = coerceBudgetTokens(
+      budgetTokens ?? GOOGLE_DEFAULT_BUDGET_TOKENS,
+      1
+    );
     return {
       google: {
         thinkingConfig: {
-          // Include thoughts in the response for transparency
-          includeThoughts: true
+          includeThoughts,
+          ...includeThoughts && isThinkingLevel && thinkingLevel !== void 0 && {
+            thinkingLevel
+          },
+          ...includeThoughts && profile.paradigm === "budget" && thinkingBudgetTokens !== void 0 && {
+            thinkingBudget: thinkingBudgetTokens
+          }
         }
       }
     };
   }
   if (provider === "openai") {
-    const effectiveEffort = reasoningEffort ?? getDefaultReasoningEffort(model);
-    if (effectiveEffort) {
+    const effortCandidate = toOpenAIReasoningEffort(reasoningVariant);
+    if (effortCandidate && supportsOpenAIReasoningEffort(model, effortCandidate)) {
       return {
         openai: {
-          reasoningEffort: effectiveEffort
+          reasoningEffort: effortCandidate,
+          ...effortCandidate !== "none" && { reasoningSummary: "auto" }
         }
       };
     }
   }
-  return void 0;
-}
-function getDefaultReasoningEffort(model) {
-  if (isReasoningCapableModel(model)) {
-    return "medium";
+  if (isOpenRouterGatewayProvider(provider)) {
+    return buildOpenRouterProviderOptions({ provider, model, reasoningVariant, budgetTokens });
+  }
+  if (provider === "openai-compatible") {
+    const profile = getReasoningProfile(provider, model);
+    if (!profile.capable) return void 0;
+    const reasoningEffort = toOpenAICompatibleReasoningEffort(reasoningVariant);
+    if (reasoningEffort === void 0) return void 0;
+    return {
+      openaiCompatible: { reasoningEffort }
+    };
   }
   return void 0;
 }
 export {
   buildProviderOptions,
-  getDefaultReasoningEffort
+  getEffectiveReasoningBudgetTokens
 };