@dexto/core 1.6.1 → 1.6.2

package/dist/llm/reasoning/openai-reasoning-effort.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openai_reasoning_effort_exports = {};
+__export(openai_reasoning_effort_exports, {
+  coerceOpenAIReasoningEffort: () => coerceOpenAIReasoningEffort,
+  getSupportedOpenAIReasoningEfforts: () => getSupportedOpenAIReasoningEfforts,
+  supportsOpenAIReasoningEffort: () => supportsOpenAIReasoningEffort
+});
+module.exports = __toCommonJS(openai_reasoning_effort_exports);
+function normalizeOpenAIModelId(model) {
+  const id = model.split("/").pop() ?? model;
+  return id.toLowerCase();
+}
+function getSupportedOpenAIReasoningEfforts(model) {
+  const id = normalizeOpenAIModelId(model);
+  if (id.includes("gpt-5-pro")) {
+    return ["high"];
+  }
+  if (id.startsWith("gpt-5.3")) {
+    return ["low", "medium", "high", "xhigh"];
+  }
+  if (id.startsWith("gpt-5.2")) {
+    return ["low", "medium", "high", "xhigh"];
+  }
+  if (id.includes("gpt-5.1-codex-max")) {
+    return ["none", "low", "medium", "high", "xhigh"];
+  }
+  if (id.startsWith("gpt-5.1")) {
+    return ["none", "low", "medium", "high"];
+  }
+  if (id.startsWith("gpt-5")) {
+    return ["minimal", "low", "medium", "high"];
+  }
+  if (id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4")) {
+    return ["low", "medium", "high"];
+  }
+  return ["low", "medium", "high"];
+}
+function getFallbackOrder(requested) {
+  switch (requested) {
+    case "none":
+      return ["none", "minimal", "low", "medium", "high", "xhigh"];
+    case "minimal":
+      return ["minimal", "low", "medium", "high", "xhigh"];
+    case "low":
+      return ["low", "medium", "high", "xhigh"];
+    case "medium":
+      return ["medium", "high", "xhigh"];
+    case "high":
+      return ["high", "xhigh"];
+    case "xhigh":
+      return ["xhigh", "high", "medium", "low", "minimal", "none"];
+  }
+}
+function coerceOpenAIReasoningEffort(model, requested) {
+  const supported = getSupportedOpenAIReasoningEfforts(model);
+  for (const candidate of getFallbackOrder(requested)) {
+    if (supported.includes(candidate)) return candidate;
+  }
+  return void 0;
+}
+function supportsOpenAIReasoningEffort(model, effort) {
+  return getSupportedOpenAIReasoningEfforts(model).includes(effort);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  coerceOpenAIReasoningEffort,
+  getSupportedOpenAIReasoningEfforts,
+  supportsOpenAIReasoningEffort
+});

package/dist/llm/reasoning/openai-reasoning-effort.d.ts

@@ -0,0 +1,5 @@
+export type OpenAIReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export declare function getSupportedOpenAIReasoningEfforts(model: string): OpenAIReasoningEffort[];
+export declare function coerceOpenAIReasoningEffort(model: string, requested: OpenAIReasoningEffort): OpenAIReasoningEffort | undefined;
+export declare function supportsOpenAIReasoningEffort(model: string, effort: OpenAIReasoningEffort): boolean;
+//# sourceMappingURL=openai-reasoning-effort.d.ts.map

package/dist/llm/reasoning/openai-reasoning-effort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-reasoning-effort.d.ts","sourceRoot":"","sources":["../../../src/llm/reasoning/openai-reasoning-effort.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AAO7F,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAoCzF;AAmBD,wBAAgB,2BAA2B,CACvC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,qBAAqB,GACjC,qBAAqB,GAAG,SAAS,CAMnC;AAED,wBAAgB,6BAA6B,CACzC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,qBAAqB,GAC9B,OAAO,CAET"}

package/dist/llm/reasoning/openai-reasoning-effort.js

@@ -0,0 +1,61 @@
+import "../../chunk-PTJYTZNU.js";
+function normalizeOpenAIModelId(model) {
+  const id = model.split("/").pop() ?? model;
+  return id.toLowerCase();
+}
+function getSupportedOpenAIReasoningEfforts(model) {
+  const id = normalizeOpenAIModelId(model);
+  if (id.includes("gpt-5-pro")) {
+    return ["high"];
+  }
+  if (id.startsWith("gpt-5.3")) {
+    return ["low", "medium", "high", "xhigh"];
+  }
+  if (id.startsWith("gpt-5.2")) {
+    return ["low", "medium", "high", "xhigh"];
+  }
+  if (id.includes("gpt-5.1-codex-max")) {
+    return ["none", "low", "medium", "high", "xhigh"];
+  }
+  if (id.startsWith("gpt-5.1")) {
+    return ["none", "low", "medium", "high"];
+  }
+  if (id.startsWith("gpt-5")) {
+    return ["minimal", "low", "medium", "high"];
+  }
+  if (id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4")) {
+    return ["low", "medium", "high"];
+  }
+  return ["low", "medium", "high"];
+}
+function getFallbackOrder(requested) {
+  switch (requested) {
+    case "none":
+      return ["none", "minimal", "low", "medium", "high", "xhigh"];
+    case "minimal":
+      return ["minimal", "low", "medium", "high", "xhigh"];
+    case "low":
+      return ["low", "medium", "high", "xhigh"];
+    case "medium":
+      return ["medium", "high", "xhigh"];
+    case "high":
+      return ["high", "xhigh"];
+    case "xhigh":
+      return ["xhigh", "high", "medium", "low", "minimal", "none"];
+  }
+}
+function coerceOpenAIReasoningEffort(model, requested) {
+  const supported = getSupportedOpenAIReasoningEfforts(model);
+  for (const candidate of getFallbackOrder(requested)) {
+    if (supported.includes(candidate)) return candidate;
+  }
+  return void 0;
+}
+function supportsOpenAIReasoningEffort(model, effort) {
+  return getSupportedOpenAIReasoningEfforts(model).includes(effort);
+}
+export {
+  coerceOpenAIReasoningEffort,
+  getSupportedOpenAIReasoningEfforts,
+  supportsOpenAIReasoningEffort
+};

package/dist/llm/reasoning/profile.cjs

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var profile_exports = {};
+__export(profile_exports, {
+  getReasoningProfile: () => getReasoningProfile,
+  supportsReasoningVariant: () => supportsReasoningVariant
+});
+module.exports = __toCommonJS(profile_exports);
+var import_registry = require("../registry/index.js");
+var import_anthropic_thinking = require("./anthropic-thinking.js");
+var import_anthropic = require("./profiles/anthropic.js");
+var import_bedrock = require("./profiles/bedrock.js");
+var import_google = require("./profiles/google.js");
+var import_openai_compatible = require("./profiles/openai-compatible.js");
+var import_openai = require("./profiles/openai.js");
+var import_openrouter = require("./profiles/openrouter.js");
+var import_vertex = require("./profiles/vertex.js");
+var import_shared = require("./profiles/shared.js");
+const ANTHROPIC_PROFILE_CONFIG = {
+  includeDisabled: true,
+  supportsBudgetTokensForBudgetParadigm: true,
+  supportsBudgetTokensForAdaptiveParadigm: false
+};
+const GOOGLE_PROFILE_CONFIG = {
+  includeDisabled: true,
+  supportsBudgetTokensForBudgetParadigm: true,
+  supportsBudgetTokensForThinkingLevelParadigm: false
+};
+function isAnthropicStyleReasoningCapable(provider, model) {
+  return (0, import_registry.isReasoningCapableModel)(model, provider) || (0, import_anthropic_thinking.parseClaudeVersion)(model) !== null || (0, import_anthropic_thinking.isAnthropicAdaptiveThinkingModel)(model);
+}
+function getNativeReasoningProfile(provider, model) {
+  switch (provider) {
+    case "openai":
+      if (!(0, import_registry.isReasoningCapableModel)(model, "openai")) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_openai.buildOpenAIReasoningProfile)(model);
+    case "anthropic":
+      if (!isAnthropicStyleReasoningCapable("anthropic", model)) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_anthropic.buildAnthropicReasoningProfile)({ model, ...ANTHROPIC_PROFILE_CONFIG });
+    case "bedrock":
+      if (!(0, import_registry.isReasoningCapableModel)(model, "bedrock")) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_bedrock.buildBedrockReasoningProfile)(model);
+    case "google":
+      if (!(0, import_registry.isReasoningCapableModel)(model, "google")) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_google.buildGoogleReasoningProfile)({ model, ...GOOGLE_PROFILE_CONFIG });
+    case "vertex":
+      if (!isAnthropicStyleReasoningCapable("vertex", model)) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_vertex.buildVertexReasoningProfile)(model);
+    case "openai-compatible":
+      if (!(0, import_registry.isReasoningCapableModel)(model, "openai-compatible")) {
+        return (0, import_shared.nonCapableProfile)();
+      }
+      return (0, import_openai_compatible.buildOpenAICompatibleReasoningProfile)();
+    default:
+      return (0, import_shared.nonCapableProfile)();
+  }
+}
+function toGatewayReasoningProfile(nativeProfile) {
+  if (!nativeProfile.capable) {
+    return (0, import_shared.nonCapableProfile)();
+  }
+  return {
+    ...nativeProfile,
+    variants: nativeProfile.variants.map((variant) => ({ ...variant })),
+    supportedVariants: [...nativeProfile.supportedVariants],
+    supportsBudgetTokens: true
+  };
+}
+function getReasoningProfile(provider, model) {
+  if ((0, import_openrouter.isOpenRouterGatewayProvider)(provider)) {
+    const target = (0, import_openrouter.getOpenRouterReasoningTarget)(model);
+    if (!target) {
+      return (0, import_shared.nonCapableProfile)();
+    }
+    const nativeProfile = getNativeReasoningProfile(target.upstreamProvider, target.modelId);
+    return toGatewayReasoningProfile(nativeProfile);
+  }
+  return getNativeReasoningProfile(provider, model);
+}
+function supportsReasoningVariant(profile, variant) {
+  return profile.variants.some((entry) => entry.id === variant);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getReasoningProfile,
+  supportsReasoningVariant
+});

package/dist/llm/reasoning/profile.d.ts

@@ -0,0 +1,13 @@
+import type { LLMProvider } from '../types.js';
+import { type ReasoningProfile } from './profiles/shared.js';
+export type { ReasoningParadigm, ReasoningProfile, ReasoningVariantOption, } from './profiles/shared.js';
+/**
+ * Returns exact, model/provider-native reasoning controls available for this model.
+ *
+ * This is intentionally strict:
+ * - No generic preset abstraction at this layer
+ * - No guessed variants for unknown paradigms
+ */
+export declare function getReasoningProfile(provider: LLMProvider, model: string): ReasoningProfile;
+export declare function supportsReasoningVariant(profile: ReasoningProfile, variant: string): boolean;
+//# sourceMappingURL=profile.d.ts.map

package/dist/llm/reasoning/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../src/llm/reasoning/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAa/C,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEhF,YAAY,EACR,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,GACzB,MAAM,sBAAsB,CAAC;AAiF9B;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAY1F;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5F"}

package/dist/llm/reasoning/profile.js

@@ -0,0 +1,92 @@
+import "../../chunk-PTJYTZNU.js";
+import { isReasoningCapableModel } from "../registry/index.js";
+import { isAnthropicAdaptiveThinkingModel, parseClaudeVersion } from "./anthropic-thinking.js";
+import { buildAnthropicReasoningProfile } from "./profiles/anthropic.js";
+import { buildBedrockReasoningProfile } from "./profiles/bedrock.js";
+import { buildGoogleReasoningProfile } from "./profiles/google.js";
+import { buildOpenAICompatibleReasoningProfile } from "./profiles/openai-compatible.js";
+import { buildOpenAIReasoningProfile } from "./profiles/openai.js";
+import {
+  getOpenRouterReasoningTarget,
+  isOpenRouterGatewayProvider
+} from "./profiles/openrouter.js";
+import { buildVertexReasoningProfile } from "./profiles/vertex.js";
+import { nonCapableProfile } from "./profiles/shared.js";
+const ANTHROPIC_PROFILE_CONFIG = {
+  includeDisabled: true,
+  supportsBudgetTokensForBudgetParadigm: true,
+  supportsBudgetTokensForAdaptiveParadigm: false
+};
+const GOOGLE_PROFILE_CONFIG = {
+  includeDisabled: true,
+  supportsBudgetTokensForBudgetParadigm: true,
+  supportsBudgetTokensForThinkingLevelParadigm: false
+};
+function isAnthropicStyleReasoningCapable(provider, model) {
+  return isReasoningCapableModel(model, provider) || parseClaudeVersion(model) !== null || isAnthropicAdaptiveThinkingModel(model);
+}
+function getNativeReasoningProfile(provider, model) {
+  switch (provider) {
+    case "openai":
+      if (!isReasoningCapableModel(model, "openai")) {
+        return nonCapableProfile();
+      }
+      return buildOpenAIReasoningProfile(model);
+    case "anthropic":
+      if (!isAnthropicStyleReasoningCapable("anthropic", model)) {
+        return nonCapableProfile();
+      }
+      return buildAnthropicReasoningProfile({ model, ...ANTHROPIC_PROFILE_CONFIG });
+    case "bedrock":
+      if (!isReasoningCapableModel(model, "bedrock")) {
+        return nonCapableProfile();
+      }
+      return buildBedrockReasoningProfile(model);
+    case "google":
+      if (!isReasoningCapableModel(model, "google")) {
+        return nonCapableProfile();
+      }
+      return buildGoogleReasoningProfile({ model, ...GOOGLE_PROFILE_CONFIG });
+    case "vertex":
+      if (!isAnthropicStyleReasoningCapable("vertex", model)) {
+        return nonCapableProfile();
+      }
+      return buildVertexReasoningProfile(model);
+    case "openai-compatible":
+      if (!isReasoningCapableModel(model, "openai-compatible")) {
+        return nonCapableProfile();
+      }
+      return buildOpenAICompatibleReasoningProfile();
+    default:
+      return nonCapableProfile();
+  }
+}
+function toGatewayReasoningProfile(nativeProfile) {
+  if (!nativeProfile.capable) {
+    return nonCapableProfile();
+  }
+  return {
+    ...nativeProfile,
+    variants: nativeProfile.variants.map((variant) => ({ ...variant })),
+    supportedVariants: [...nativeProfile.supportedVariants],
+    supportsBudgetTokens: true
+  };
+}
+function getReasoningProfile(provider, model) {
+  if (isOpenRouterGatewayProvider(provider)) {
+    const target = getOpenRouterReasoningTarget(model);
+    if (!target) {
+      return nonCapableProfile();
+    }
+    const nativeProfile = getNativeReasoningProfile(target.upstreamProvider, target.modelId);
+    return toGatewayReasoningProfile(nativeProfile);
+  }
+  return getNativeReasoningProfile(provider, model);
+}
+function supportsReasoningVariant(profile, variant) {
+  return profile.variants.some((entry) => entry.id === variant);
+}
+export {
+  getReasoningProfile,
+  supportsReasoningVariant
+};

package/dist/llm/reasoning/profiles/anthropic.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  buildAnthropicReasoningProfile: () => buildAnthropicReasoningProfile
+});
+module.exports = __toCommonJS(anthropic_exports);
+var import_anthropic_thinking = require("../anthropic-thinking.js");
+var import_shared = require("./shared.js");
+function buildAnthropicAdaptiveProfile(config) {
+  const variants = [];
+  if (config.includeDisabled) {
+    variants.push((0, import_shared.option)("disabled"));
+  }
+  variants.push((0, import_shared.option)("low"), (0, import_shared.option)("medium"), (0, import_shared.option)("high"));
+  if ((0, import_anthropic_thinking.isAnthropicOpusAdaptiveThinkingModel)(config.model)) {
+    variants.push((0, import_shared.option)("max"));
+  }
+  return (0, import_shared.withDefault)(
+    {
+      capable: true,
+      paradigm: "adaptive-effort",
+      variants,
+      supportsBudgetTokens: config.supportsBudgetTokens
+    },
+    "medium"
+  );
+}
+function buildAnthropicReasoningProfile(config) {
+  if ((0, import_anthropic_thinking.isAnthropicAdaptiveThinkingModel)(config.model)) {
+    return buildAnthropicAdaptiveProfile({
+      model: config.model,
+      includeDisabled: config.includeDisabled,
+      supportsBudgetTokens: config.supportsBudgetTokensForAdaptiveParadigm
+    });
+  }
+  return (0, import_shared.buildBudgetProfile)({
+    includeDisabled: config.includeDisabled,
+    supportsBudgetTokens: config.supportsBudgetTokensForBudgetParadigm
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAnthropicReasoningProfile
+});

package/dist/llm/reasoning/profiles/anthropic.d.ts

@@ -0,0 +1,8 @@
+import { type ReasoningProfile } from './shared.js';
+export declare function buildAnthropicReasoningProfile(config: {
+    model: string;
+    includeDisabled: boolean;
+    supportsBudgetTokensForBudgetParadigm: boolean;
+    supportsBudgetTokensForAdaptiveParadigm: boolean;
+}): ReasoningProfile;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/llm/reasoning/profiles/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../../src/llm/reasoning/profiles/anthropic.ts"],"names":[],"mappings":"AAIA,OAAO,EAGH,KAAK,gBAAgB,EAGxB,MAAM,aAAa,CAAC;AA4BrB,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,OAAO,CAAC;IACzB,qCAAqC,EAAE,OAAO,CAAC;IAC/C,uCAAuC,EAAE,OAAO,CAAC;CACpD,GAAG,gBAAgB,CAanB"}

package/dist/llm/reasoning/profiles/anthropic.js

@@ -0,0 +1,45 @@
+import "../../../chunk-PTJYTZNU.js";
+import {
+  isAnthropicAdaptiveThinkingModel,
+  isAnthropicOpusAdaptiveThinkingModel
+} from "../anthropic-thinking.js";
+import {
+  buildBudgetProfile,
+  option,
+  withDefault
+} from "./shared.js";
+function buildAnthropicAdaptiveProfile(config) {
+  const variants = [];
+  if (config.includeDisabled) {
+    variants.push(option("disabled"));
+  }
+  variants.push(option("low"), option("medium"), option("high"));
+  if (isAnthropicOpusAdaptiveThinkingModel(config.model)) {
+    variants.push(option("max"));
+  }
+  return withDefault(
+    {
+      capable: true,
+      paradigm: "adaptive-effort",
+      variants,
+      supportsBudgetTokens: config.supportsBudgetTokens
+    },
+    "medium"
+  );
+}
+function buildAnthropicReasoningProfile(config) {
+  if (isAnthropicAdaptiveThinkingModel(config.model)) {
+    return buildAnthropicAdaptiveProfile({
+      model: config.model,
+      includeDisabled: config.includeDisabled,
+      supportsBudgetTokens: config.supportsBudgetTokensForAdaptiveParadigm
+    });
+  }
+  return buildBudgetProfile({
+    includeDisabled: config.includeDisabled,
+    supportsBudgetTokens: config.supportsBudgetTokensForBudgetParadigm
+  });
+}
+export {
+  buildAnthropicReasoningProfile
+};

package/dist/llm/reasoning/profiles/bedrock.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bedrock_exports = {};
+__export(bedrock_exports, {
+  buildBedrockReasoningProfile: () => buildBedrockReasoningProfile
+});
+module.exports = __toCommonJS(bedrock_exports);
+var import_shared = require("./shared.js");
+function isBedrockAnthropicModel(model) {
+  return model.toLowerCase().includes("anthropic");
+}
+function isBedrockNovaModel(model) {
+  return model.toLowerCase().includes("nova");
+}
+function buildBedrockReasoningProfile(model) {
+  if (isBedrockAnthropicModel(model)) {
+    return (0, import_shared.buildBudgetProfile)({
+      includeDisabled: true,
+      supportsBudgetTokens: true
+    });
+  }
+  if (isBedrockNovaModel(model)) {
+    return (0, import_shared.withDefault)(
+      {
+        capable: true,
+        paradigm: "effort",
+        variants: [(0, import_shared.option)("disabled"), (0, import_shared.option)("low"), (0, import_shared.option)("medium"), (0, import_shared.option)("high")],
+        supportsBudgetTokens: false
+      },
+      "medium"
+    );
+  }
+  return (0, import_shared.nonCapableProfile)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildBedrockReasoningProfile
+});

package/dist/llm/reasoning/profiles/bedrock.d.ts

@@ -0,0 +1,3 @@
+import { type ReasoningProfile } from './shared.js';
+export declare function buildBedrockReasoningProfile(model: string): ReasoningProfile;
+//# sourceMappingURL=bedrock.d.ts.map

package/dist/llm/reasoning/profiles/bedrock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../../../src/llm/reasoning/profiles/bedrock.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,gBAAgB,EAExB,MAAM,aAAa,CAAC;AAUrB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAqB5E"}

package/dist/llm/reasoning/profiles/bedrock.js

@@ -0,0 +1,36 @@
+import "../../../chunk-PTJYTZNU.js";
+import {
+  buildBudgetProfile,
+  nonCapableProfile,
+  option,
+  withDefault
+} from "./shared.js";
+function isBedrockAnthropicModel(model) {
+  return model.toLowerCase().includes("anthropic");
+}
+function isBedrockNovaModel(model) {
+  return model.toLowerCase().includes("nova");
+}
+function buildBedrockReasoningProfile(model) {
+  if (isBedrockAnthropicModel(model)) {
+    return buildBudgetProfile({
+      includeDisabled: true,
+      supportsBudgetTokens: true
+    });
+  }
+  if (isBedrockNovaModel(model)) {
+    return withDefault(
+      {
+        capable: true,
+        paradigm: "effort",
+        variants: [option("disabled"), option("low"), option("medium"), option("high")],
+        supportsBudgetTokens: false
+      },
+      "medium"
+    );
+  }
+  return nonCapableProfile();
+}
+export {
+  buildBedrockReasoningProfile
+};

package/dist/llm/reasoning/profiles/google.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var google_exports = {};
+__export(google_exports, {
+  buildGoogleReasoningProfile: () => buildGoogleReasoningProfile,
+  isGemini3Model: () => isGemini3Model
+});
+module.exports = __toCommonJS(google_exports);
+var import_shared = require("./shared.js");
+function isGemini3Model(model) {
+  return model.toLowerCase().includes("gemini-3");
+}
+function buildGoogleReasoningProfile(config) {
+  if (isGemini3Model(config.model)) {
+    return (0, import_shared.buildThinkingLevelProfile)({
+      includeDisabled: config.includeDisabled,
+      supportsBudgetTokens: config.supportsBudgetTokensForThinkingLevelParadigm
+    });
+  }
+  return (0, import_shared.buildBudgetProfile)({
+    includeDisabled: config.includeDisabled,
+    supportsBudgetTokens: config.supportsBudgetTokensForBudgetParadigm
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildGoogleReasoningProfile,
+  isGemini3Model
+});

package/dist/llm/reasoning/profiles/google.d.ts

@@ -0,0 +1,9 @@
+import { type ReasoningProfile } from './shared.js';
+export declare function isGemini3Model(model: string): boolean;
+export declare function buildGoogleReasoningProfile(config: {
+    model: string;
+    includeDisabled: boolean;
+    supportsBudgetTokensForBudgetParadigm: boolean;
+    supportsBudgetTokensForThinkingLevelParadigm: boolean;
+}): ReasoningProfile;
+//# sourceMappingURL=google.d.ts.map

package/dist/llm/reasoning/profiles/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../../src/llm/reasoning/profiles/google.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnG,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,OAAO,CAAC;IACzB,qCAAqC,EAAE,OAAO,CAAC;IAC/C,4CAA4C,EAAE,OAAO,CAAC;CACzD,GAAG,gBAAgB,CAYnB"}