@dexto/core 1.6.0 → 1.6.2

package/dist/llm/providers/openrouter-model-registry.js

@@ -21,6 +21,23 @@ class OpenRouterModelRegistry {
   refreshPromise = null;
   lastRefreshAttemptAt = null;
   lastUsedApiKey;
+  parseExpirationDateEndUtc(expirationDate) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(expirationDate.trim());
+    if (!match) return null;
+    const year = Number(match[1]);
+    const monthIndex = Number(match[2]) - 1;
+    const day = Number(match[3]);
+    if (!Number.isFinite(year) || !Number.isFinite(monthIndex) || !Number.isFinite(day)) {
+      return null;
+    }
+    return Date.UTC(year, monthIndex, day, 23, 59, 59, 999);
+  }
+  isExpired(model) {
+    if (!model.expirationDate) return false;
+    const expiresAt = this.parseExpirationDateEndUtc(model.expirationDate);
+    if (!expiresAt) return false;
+    return Date.now() > expiresAt;
+  }
   /**
    * Look up a model ID against the OpenRouter catalog.
    * @returns 'valid' if model exists, 'invalid' if not found, 'unknown' if cache is stale/empty
@@ -38,7 +55,11 @@ class OpenRouterModelRegistry {
       this.scheduleRefresh();
       return "unknown";
     }
-    return this.models.has(normalized) ? "valid" : "invalid";
+    const info = this.models.get(normalized);
+    if (info && this.isExpired(info)) {
+      return "invalid";
+    }
+    return info ? "valid" : "invalid";
   }
   /**
    * Get context length for a model ID.
@@ -53,6 +74,7 @@ class OpenRouterModelRegistry {
       return null;
     }
     const info = this.models.get(normalized);
+    if (info && this.isExpired(info)) return null;
     return info?.contextLength ?? null;
   }
   /**
@@ -67,7 +89,9 @@ class OpenRouterModelRegistry {
     if (!this.models || this.models.size === 0 || !this.isCacheFresh()) {
       return null;
     }
-    return this.models.get(normalized) ?? null;
+    const info = this.models.get(normalized) ?? null;
+    if (info && this.isExpired(info)) return null;
+    return info;
   }
   /**
    * Schedule a non-blocking background refresh of the model cache.
@@ -77,6 +101,9 @@ class OpenRouterModelRegistry {
     if (apiKey) {
       this.lastUsedApiKey = apiKey;
     }
+    if ((process.env.NODE_ENV === "test" || process.env.VITEST) && options?.allowInTests !== true) {
+      return;
+    }
     if (this.refreshPromise) {
       return;
     }
@@ -85,7 +112,7 @@ class OpenRouterModelRegistry {
       return;
     }
     this.lastRefreshAttemptAt = now;
-    this.refreshPromise = this.refreshInternal(apiKey).catch((error) => {
+    this.refreshPromise = this.refreshInternal(apiKey, options?.timeoutMs).catch((error) => {
       logger.warn(
         `Failed to refresh OpenRouter model registry: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -101,6 +128,9 @@ class OpenRouterModelRegistry {
     if (apiKey) {
       this.lastUsedApiKey = apiKey;
     }
+    if ((process.env.NODE_ENV === "test" || process.env.VITEST) && options?.allowInTests !== true) {
+      return;
+    }
     if (!options?.force && this.refreshPromise) {
       await this.refreshPromise;
       return;
@@ -117,7 +147,7 @@ class OpenRouterModelRegistry {
     } else {
       this.lastRefreshAttemptAt = Date.now();
     }
-    const promise = this.refreshInternal(apiKey).finally(() => {
+    const promise = this.refreshInternal(apiKey, options?.timeoutMs).finally(() => {
       this.refreshPromise = null;
     });
     this.refreshPromise = promise;
@@ -130,7 +160,12 @@ class OpenRouterModelRegistry {
     if (!this.models || this.models.size === 0) {
       return null;
     }
-    return Array.from(this.models.keys());
+    const ids = [];
+    for (const info of this.models.values()) {
+      if (this.isExpired(info)) continue;
+      ids.push(info.id);
+    }
+    return ids;
   }
   /**
    * Get all cached model info (or null if cache is empty).
@@ -139,19 +174,20 @@ class OpenRouterModelRegistry {
     if (!this.models || this.models.size === 0) {
       return null;
     }
-    return Array.from(this.models.values());
+    return Array.from(this.models.values()).filter((info) => !this.isExpired(info));
   }
   /**
    * Get cache metadata for debugging/monitoring.
    */
   getCacheMetadata() {
+    const modelCount = this.models ? Array.from(this.models.values()).filter((info) => !this.isExpired(info)).length : 0;
     return {
       lastFetchedAt: this.lastFetchedAt ? new Date(this.lastFetchedAt) : null,
-      modelCount: this.models ? this.models.size : 0,
+      modelCount,
       isFresh: this.isCacheFresh()
     };
   }
-  async refreshInternal(apiKey) {
+  async refreshInternal(apiKey, timeoutMs) {
     try {
       const headers = {
         Accept: "application/json"
@@ -160,7 +196,10 @@ class OpenRouterModelRegistry {
         headers.Authorization = `Bearer ${apiKey}`;
       }
       logger.debug("Refreshing OpenRouter model registry from remote source");
-      const response = await fetch(OPENROUTER_MODELS_ENDPOINT, { headers });
+      const response = await fetch(OPENROUTER_MODELS_ENDPOINT, {
+        headers,
+        signal: AbortSignal.timeout(timeoutMs ?? 3e4)
+      });
       if (!response.ok) {
         const body = await response.text();
         throw new Error(`HTTP ${response.status}: ${body}`);
@@ -189,7 +228,7 @@ class OpenRouterModelRegistry {
       }
       this.models = /* @__PURE__ */ new Map();
       for (const model of parsed.models) {
-        if (typeof model === "object" && model.id && typeof model.contextLength === "number") {
+        if (typeof model === "object" && typeof model.id === "string" && model.id.trim().length > 0 && typeof model.contextLength === "number") {
           this.models.set(model.id.toLowerCase(), model);
         }
       }
@@ -254,7 +293,18 @@ class OpenRouterModelRegistry {
           } else if (record.top_provider && typeof record.top_provider === "object" && typeof record.top_provider.context_length === "number") {
             contextLength = record.top_provider.context_length;
           }
-          models.push({ id, contextLength });
+          const displayName = typeof record.name === "string" && record.name.trim().length > 0 ? record.name : void 0;
+          const expirationDate = typeof record.expiration_date === "string" && record.expiration_date.trim().length > 0 ? record.expiration_date : void 0;
+          const supportedParameters = Array.isArray(record.supported_parameters) ? record.supported_parameters.filter(
+            (p) => typeof p === "string" && p.trim().length > 0
+          ) : void 0;
+          models.push({
+            id,
+            contextLength,
+            ...displayName ? { displayName } : {},
+            ...expirationDate ? { expirationDate } : {},
+            ...supportedParameters ? { supportedParameters } : {}
+          });
         }
       }
     }
@@ -283,6 +333,9 @@ async function refreshOpenRouterModelCache(options) {
 function getCachedOpenRouterModels() {
   return openRouterModelRegistry.getCachedModels();
 }
+function getCachedOpenRouterModelsWithInfo() {
+  return openRouterModelRegistry.getCachedModelsWithInfo();
+}
 function getOpenRouterModelContextLength(modelId) {
   return openRouterModelRegistry.getContextLength(modelId);
 }
@@ -299,6 +352,7 @@ const __TEST_ONLY__ = {
 export {
   __TEST_ONLY__,
   getCachedOpenRouterModels,
+  getCachedOpenRouterModelsWithInfo,
   getOpenRouterModelCacheInfo,
   getOpenRouterModelContextLength,
   getOpenRouterModelInfo,

package/dist/llm/reasoning/anthropic-betas.cjs

@@ -0,0 +1,31 @@
+"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_betas_exports = {};
+__export(anthropic_betas_exports, {
+  ANTHROPIC_BETA_HEADER: () => ANTHROPIC_BETA_HEADER,
+  ANTHROPIC_INTERLEAVED_THINKING_BETA: () => ANTHROPIC_INTERLEAVED_THINKING_BETA
+});
+module.exports = __toCommonJS(anthropic_betas_exports);
+const ANTHROPIC_BETA_HEADER = "anthropic-beta";
+const ANTHROPIC_INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANTHROPIC_BETA_HEADER,
+  ANTHROPIC_INTERLEAVED_THINKING_BETA
+});

package/dist/llm/reasoning/anthropic-betas.d.ts

@@ -0,0 +1,3 @@
+export declare const ANTHROPIC_BETA_HEADER = "anthropic-beta";
+export declare const ANTHROPIC_INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+//# sourceMappingURL=anthropic-betas.d.ts.map

package/dist/llm/reasoning/anthropic-betas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-betas.d.ts","sourceRoot":"","sources":["../../../src/llm/reasoning/anthropic-betas.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAMtD,eAAO,MAAM,mCAAmC,oCAAoC,CAAC"}

package/dist/llm/reasoning/anthropic-betas.js

@@ -0,0 +1,7 @@
+import "../../chunk-PTJYTZNU.js";
+const ANTHROPIC_BETA_HEADER = "anthropic-beta";
+const ANTHROPIC_INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+export {
+  ANTHROPIC_BETA_HEADER,
+  ANTHROPIC_INTERLEAVED_THINKING_BETA
+};

package/dist/llm/reasoning/anthropic-thinking.cjs

@@ -0,0 +1,79 @@
+"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_thinking_exports = {};
+__export(anthropic_thinking_exports, {
+  isAnthropicAdaptiveThinkingModel: () => isAnthropicAdaptiveThinkingModel,
+  isAnthropicOpusAdaptiveThinkingModel: () => isAnthropicOpusAdaptiveThinkingModel,
+  isClaudeVersionAtLeast: () => isClaudeVersionAtLeast,
+  parseClaudeVersion: () => parseClaudeVersion,
+  supportsAnthropicInterleavedThinking: () => supportsAnthropicInterleavedThinking
+});
+module.exports = __toCommonJS(anthropic_thinking_exports);
+function parseClaudeVersion(model) {
+  const modelLower = model.toLowerCase();
+  const variantFirst = /claude-(opus|sonnet|haiku)-(\d+)(?:[.-](\d{1,2})(?!\d))?/i.exec(
+    modelLower
+  );
+  if (variantFirst) {
+    const [, variant, majorRaw, minorRaw] = variantFirst;
+    if (!variant || !majorRaw) return null;
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = minorRaw ? Number.parseInt(minorRaw, 10) : 0;
+    if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+    return { major, minor, variant };
+  }
+  const versionFirst = /claude-(\d+)(?:[.-](\d{1,2})(?!\d))?-(opus|sonnet|haiku)/i.exec(
+    modelLower
+  );
+  if (versionFirst) {
+    const [, majorRaw, minorRaw, variant] = versionFirst;
+    if (!majorRaw || !variant) return null;
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = minorRaw ? Number.parseInt(minorRaw, 10) : 0;
+    if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+    return { major, minor, variant };
+  }
+  return null;
+}
+function isClaudeVersionAtLeast(version, min) {
+  return version.major > min.major || version.major === min.major && version.minor >= min.minor;
+}
+function isAnthropicAdaptiveThinkingModel(model) {
+  const version = parseClaudeVersion(model);
+  if (!version) return false;
+  return isClaudeVersionAtLeast(version, { major: 4, minor: 6 });
+}
+function isAnthropicOpusAdaptiveThinkingModel(model) {
+  const version = parseClaudeVersion(model);
+  if (!version || version.variant !== "opus") return false;
+  return isClaudeVersionAtLeast(version, { major: 4, minor: 6 });
+}
+function supportsAnthropicInterleavedThinking(model) {
+  const version = parseClaudeVersion(model);
+  if (!version) return false;
+  return version.major >= 4;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAnthropicAdaptiveThinkingModel,
+  isAnthropicOpusAdaptiveThinkingModel,
+  isClaudeVersionAtLeast,
+  parseClaudeVersion,
+  supportsAnthropicInterleavedThinking
+});

package/dist/llm/reasoning/anthropic-thinking.d.ts

@@ -0,0 +1,15 @@
+export type ClaudeVariant = 'opus' | 'sonnet' | 'haiku';
+export type ParsedClaudeVersion = {
+    major: number;
+    minor: number;
+    variant?: ClaudeVariant;
+};
+export declare function parseClaudeVersion(model: string): ParsedClaudeVersion | null;
+export declare function isClaudeVersionAtLeast(version: Pick<ParsedClaudeVersion, 'major' | 'minor'>, min: {
+    major: number;
+    minor: number;
+}): boolean;
+export declare function isAnthropicAdaptiveThinkingModel(model: string): boolean;
+export declare function isAnthropicOpusAdaptiveThinkingModel(model: string): boolean;
+export declare function supportsAnthropicInterleavedThinking(model: string): boolean;
+//# sourceMappingURL=anthropic-thinking.d.ts.map

package/dist/llm/reasoning/anthropic-thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-thinking.d.ts","sourceRoot":"","sources":["../../../src/llm/reasoning/anthropic-thinking.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAExD,MAAM,MAAM,mBAAmB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAmC5E;AAED,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,OAAO,CAAC,EACrD,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACtC,OAAO,CAET;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMvE;AAED,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAM3E"}

package/dist/llm/reasoning/anthropic-thinking.js

@@ -0,0 +1,52 @@
+import "../../chunk-PTJYTZNU.js";
+function parseClaudeVersion(model) {
+  const modelLower = model.toLowerCase();
+  const variantFirst = /claude-(opus|sonnet|haiku)-(\d+)(?:[.-](\d{1,2})(?!\d))?/i.exec(
+    modelLower
+  );
+  if (variantFirst) {
+    const [, variant, majorRaw, minorRaw] = variantFirst;
+    if (!variant || !majorRaw) return null;
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = minorRaw ? Number.parseInt(minorRaw, 10) : 0;
+    if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+    return { major, minor, variant };
+  }
+  const versionFirst = /claude-(\d+)(?:[.-](\d{1,2})(?!\d))?-(opus|sonnet|haiku)/i.exec(
+    modelLower
+  );
+  if (versionFirst) {
+    const [, majorRaw, minorRaw, variant] = versionFirst;
+    if (!majorRaw || !variant) return null;
+    const major = Number.parseInt(majorRaw, 10);
+    const minor = minorRaw ? Number.parseInt(minorRaw, 10) : 0;
+    if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+    return { major, minor, variant };
+  }
+  return null;
+}
+function isClaudeVersionAtLeast(version, min) {
+  return version.major > min.major || version.major === min.major && version.minor >= min.minor;
+}
+function isAnthropicAdaptiveThinkingModel(model) {
+  const version = parseClaudeVersion(model);
+  if (!version) return false;
+  return isClaudeVersionAtLeast(version, { major: 4, minor: 6 });
+}
+function isAnthropicOpusAdaptiveThinkingModel(model) {
+  const version = parseClaudeVersion(model);
+  if (!version || version.variant !== "opus") return false;
+  return isClaudeVersionAtLeast(version, { major: 4, minor: 6 });
+}
+function supportsAnthropicInterleavedThinking(model) {
+  const version = parseClaudeVersion(model);
+  if (!version) return false;
+  return version.major >= 4;
+}
+export {
+  isAnthropicAdaptiveThinkingModel,
+  isAnthropicOpusAdaptiveThinkingModel,
+  isClaudeVersionAtLeast,
+  parseClaudeVersion,
+  supportsAnthropicInterleavedThinking
+};

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