@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/{chunk-RFEKJKTO.js → chunk-RN6WZEUF.js}

@@ -1,7 +1,13 @@
 import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+  DEFAULT_RESOLVER_OPTIONS,
+  PatternCapabilitySource,
+  extractModelId,
+  extractProvider,
+  likelySupportsReasoning
+} from "./chunk-I6PKJ7XQ.js";
+import {
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
 
 // src/models/resolver.ts
 function parseKey(input) {
@@ -179,258 +185,6 @@ function createResolver(directory) {
   };
 }
 
-// src/models/types.ts
-var SourcePriority = /* @__PURE__ */ ((SourcePriority3) => {
-  SourcePriority3[SourcePriority3["UserConfig"] = 0] = "UserConfig";
-  SourcePriority3[SourcePriority3["LocalCache"] = 1] = "LocalCache";
-  SourcePriority3[SourcePriority3["BundledData"] = 2] = "BundledData";
-  SourcePriority3[SourcePriority3["PatternMatch"] = 3] = "PatternMatch";
-  SourcePriority3[SourcePriority3["RemoteAPI"] = 4] = "RemoteAPI";
-  return SourcePriority3;
-})(SourcePriority || {});
-var DEFAULT_RESOLVER_OPTIONS = {
-  enableRemoteFetch: false,
-  remoteApiUrl: "https://models.dev",
-  cachePath: ".agent-core/cache",
-  cacheTtlMs: 60 * 60 * 1e3,
-  // 1 hour
-  networkTimeoutMs: 10 * 1e3,
-  // 10 seconds
-  modelOverrides: {}
-};
-
-// src/models/profiles.ts
-var REASONING_PATTERNS = [
-  // OpenAI o-series
-  {
-    pattern: /^o[134]-?(mini|pro|preview)?$/i,
-    provider: "openai",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
-    confidence: 0.95
-  },
-  // OpenAI GPT-5.x
-  {
-    pattern: /gpt-?5(\.\d)?/i,
-    provider: "openai",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
-    confidence: 0.9
-  },
-  // DeepSeek R1 variants
-  {
-    pattern: /deepseek[_-]?r1|r1[_-]distill/i,
-    capabilities: { reasoning: true, toolCalling: false },
-    confidence: 0.95
-  },
-  // Anthropic Claude with thinking
-  {
-    pattern: /claude.*thinking|thinking.*claude/i,
-    provider: "anthropic",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { thinkingFormat: "anthropic" },
-    confidence: 0.9
-  },
-  // Claude 4.x series (reasoning capable)
-  {
-    pattern: /claude[_-]?(opus|sonnet)[_-]?4/i,
-    provider: "anthropic",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { thinkingFormat: "anthropic" },
-    confidence: 0.85
-  },
-  // Gemini thinking models
-  {
-    pattern: /gemini.*thinking|gemini[_-]?2\.5[_-]?pro/i,
-    provider: "google",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { thinkingFormat: "google" },
-    confidence: 0.85
-  },
-  // Gemini 3.x (future-proofing)
-  {
-    pattern: /gemini[_-]?3/i,
-    provider: "google",
-    capabilities: { reasoning: true, toolCalling: true },
-    compatibility: { thinkingFormat: "google" },
-    confidence: 0.8
-  },
-  // Grok reasoning models
-  {
-    pattern: /grok[_-]?\d[_-]?(mini|reasoning)/i,
-    provider: "xai",
-    capabilities: { reasoning: true, toolCalling: true },
-    confidence: 0.85
-  },
-  // Qwen thinking models
-  {
-    pattern: /qwen.*thinking|qwen3/i,
-    capabilities: { reasoning: true, toolCalling: true },
-    confidence: 0.8
-  },
-  // Generic reasoning/thinking in name
-  {
-    pattern: /reasoning|thinking/i,
-    capabilities: { reasoning: true },
-    confidence: 0.7
-  }
-];
-var PROVIDER_PATTERNS = [
-  { pattern: /^(gpt|o[134]|chatgpt|davinci)/i, provider: "openai" },
-  { pattern: /^claude/i, provider: "anthropic" },
-  { pattern: /^gemini|^palm/i, provider: "google" },
-  { pattern: /^grok/i, provider: "xai" },
-  { pattern: /^deepseek/i, provider: "deepseek" },
-  { pattern: /^mistral|^mixtral|codestral/i, provider: "mistral" },
-  { pattern: /^llama/i, provider: "meta" },
-  { pattern: /^qwen/i, provider: "alibaba" },
-  { pattern: /^command/i, provider: "cohere" }
-];
-var CONTEXT_WINDOW_PROFILES = [
-  // Anthropic Claude 4.x — 200k
-  { pattern: /claude[_-]?(opus|sonnet)[_-]?4/i, tokens: 2e5 },
-  // Anthropic Claude 3.5 — 200k
-  { pattern: /claude[_-]?3[._-]?5/i, tokens: 2e5 },
-  // Anthropic Claude 3 Opus/Sonnet/Haiku — 200k
-  { pattern: /claude[_-]?3/i, tokens: 2e5 },
-  // Anthropic Claude 2 — 100k
-  { pattern: /claude[_-]?2/i, tokens: 1e5 },
-  // OpenAI o-series (o1, o3, o4) — 200k
-  { pattern: /^o[134]-?(mini|pro|preview)?$/i, tokens: 2e5 },
-  // OpenAI GPT-5.x — 1M
-  { pattern: /gpt-?5/i, tokens: 1e6 },
-  // OpenAI GPT-4o — 128k
-  { pattern: /gpt-?4o/i, tokens: 128e3 },
-  // OpenAI GPT-4 turbo — 128k
-  { pattern: /gpt-?4[_-]?turbo/i, tokens: 128e3 },
-  // OpenAI GPT-4 — 8k (original)
-  { pattern: /gpt-?4(?!o|[_-]?turbo)/i, tokens: 8192 },
-  // OpenAI GPT-3.5 turbo — 16k
-  { pattern: /gpt-?3[._-]?5/i, tokens: 16384 },
-  // Google Gemini 2.5 Pro — 1M
-  { pattern: /gemini[_-]?2[._-]?5[_-]?pro/i, tokens: 1e6 },
-  // Google Gemini 2.x Flash — 1M
-  { pattern: /gemini[_-]?2.*flash/i, tokens: 1e6 },
-  // Google Gemini 2.x Pro — 1M
-  { pattern: /gemini[_-]?2[._-]?\d?[_-]?pro/i, tokens: 1e6 },
-  // Google Gemini 1.5 Pro/Flash — 1M
-  { pattern: /gemini[_-]?1[._-]?5/i, tokens: 1e6 },
-  // xAI Grok 3+ — 128k
-  { pattern: /grok[_-]?\d/i, tokens: 128e3 },
-  // Mistral Large — 128k
-  { pattern: /mistral[_-]?large/i, tokens: 128e3 },
-  // Mistral Medium — 32k
-  { pattern: /mistral[_-]?medium/i, tokens: 32768 },
-  // Codestral — 256k
-  { pattern: /codestral/i, tokens: 256e3 },
-  // Mistral generic — 32k
-  { pattern: /mistral|mixtral/i, tokens: 32768 },
-  // DeepSeek R1/V3 — 128k
-  { pattern: /deepseek/i, tokens: 128e3 },
-  // Qwen 3 — 128k
-  { pattern: /qwen/i, tokens: 128e3 },
-  // Meta Llama 3 — 128k
-  { pattern: /llama[_-]?3/i, tokens: 128e3 },
-  // Cohere Command R+ — 128k
-  { pattern: /command[_-]?r/i, tokens: 128e3 }
-];
-function inferContextWindow(modelId) {
-  const normalized = modelId.toLowerCase();
-  for (const { pattern, tokens } of CONTEXT_WINDOW_PROFILES) {
-    if (pattern.test(normalized)) {
-      return tokens;
-    }
-  }
-  return void 0;
-}
-function inferProvider(modelId) {
-  const normalized = modelId.toLowerCase();
-  for (const { pattern, provider } of PROVIDER_PATTERNS) {
-    if (pattern.test(normalized)) {
-      return provider;
-    }
-  }
-  if (modelId.includes("/")) {
-    return modelId.split("/")[0];
-  }
-  return void 0;
-}
-function matchPatterns(modelId, providerHint) {
-  const normalized = modelId.toLowerCase();
-  for (const rule of REASONING_PATTERNS) {
-    if (rule.provider && providerHint && rule.provider !== providerHint) {
-      continue;
-    }
-    const matches = typeof rule.pattern === "string" ? normalized.includes(rule.pattern.toLowerCase()) : rule.pattern.test(normalized);
-    if (matches) {
-      return { rule, confidence: rule.confidence };
-    }
-  }
-  return void 0;
-}
-function createDefaultCapabilities() {
-  return {
-    reasoning: false,
-    toolCalling: true,
-    temperature: true,
-    attachments: false,
-    streaming: true,
-    inputModalities: ["text"],
-    outputModalities: ["text"]
-  };
-}
-var PatternCapabilitySource = class {
-  priority = 3 /* PatternMatch */;
-  name = "Pattern Matching";
-  async lookup(modelId, providerHint) {
-    const provider = providerHint || inferProvider(modelId);
-    const match = matchPatterns(modelId, provider);
-    const baseCapabilities = createDefaultCapabilities();
-    if (match) {
-      const entry = {
-        id: modelId,
-        name: modelId,
-        provider: match.rule.provider || provider || "unknown",
-        capabilities: {
-          ...baseCapabilities,
-          ...match.rule.capabilities,
-          contextWindow: inferContextWindow(modelId)
-        },
-        compatibility: match.rule.compatibility
-      };
-      return {
-        entry,
-        source: this.priority,
-        confident: match.confidence > 0.8
-      };
-    }
-    return {
-      entry: {
-        id: modelId,
-        name: modelId,
-        provider: provider || "unknown",
-        capabilities: {
-          ...baseCapabilities,
-          contextWindow: inferContextWindow(modelId)
-        }
-      },
-      source: this.priority,
-      confident: false
-    };
-  }
-  async isAvailable() {
-    return true;
-  }
-};
-function likelySupportsReasoning(modelId) {
-  const match = matchPatterns(modelId);
-  return match !== void 0 && match.rule.capabilities.reasoning === true;
-}
-function getProviderCompatibility(modelId, provider) {
-  const match = matchPatterns(modelId, provider);
-  return match?.rule.compatibility;
-}
-
 // src/models/overrides.ts
 function normalizeKey(value) {
   const trimmed = value?.trim();
@@ -517,6 +271,10 @@ var FileSystemAdapter = class {
 };
 var LocalStorageAdapter = class {
   key = "agent-core:model-capabilities";
+  log;
+  constructor(logger) {
+    this.log = logger;
+  }
   async read() {
     try {
       const content = localStorage.getItem(this.key);
@@ -530,7 +288,9 @@ var LocalStorageAdapter = class {
     try {
       localStorage.setItem(this.key, JSON.stringify(data));
     } catch (error) {
-      console.warn("[agent-core] Failed to write to localStorage:", error);
+      this.log.warn("Failed to write to localStorage", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   async clear() {
@@ -552,12 +312,12 @@ var MemoryAdapter = class {
     this.data = void 0;
   }
 };
-function createCapabilityCacheAdapter(cachePath) {
+function createCapabilityCacheAdapter(cachePath, logger) {
   if (isNodeEnvironment()) {
     return new FileSystemAdapter(cachePath);
   }
   if (hasLocalStorage()) {
-    return new LocalStorageAdapter();
+    return new LocalStorageAdapter(logger ?? silentLogger);
   }
   return new MemoryAdapter();
 }
@@ -577,10 +337,12 @@ var CapabilityCache = class {
   memoryCache = /* @__PURE__ */ new Map();
   ttlMs;
   loaded = false;
-  constructor(options = {}) {
+  log;
+  constructor(options = {}, logger) {
     const opts = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
     this.ttlMs = opts.cacheTtlMs;
     this.adapter = createCapabilityCacheAdapter(opts.cachePath);
+    this.log = logger?.child("cache") ?? silentLogger;
   }
   async load() {
     if (this.loaded) return;
@@ -592,7 +354,9 @@ var CapabilityCache = class {
         }
       }
     } catch (error) {
-      console.warn("[agent-core] Failed to load capability cache:", error);
+      this.log.warn("Failed to load capability cache", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
     this.loaded = true;
   }
@@ -897,22 +661,17 @@ var RemoteCapabilitySource = class {
 };
 
 // src/models/capability-resolver.ts
-function extractModelId(model) {
-  return getModelId(model);
-}
-function extractProvider(model) {
-  const provider = getProviderId(model);
-  return provider ?? inferProvider(extractModelId(model));
-}
 var ModelCapabilityResolver = class {
   options;
   cache;
   sources;
   initialized = false;
   initPromise;
-  constructor(options = {}) {
+  log;
+  constructor(options = {}, logger) {
     this.options = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
     this.cache = new CapabilityCache(this.options);
+    this.log = logger?.child("models") ?? silentLogger;
     this.sources = [
       new CacheCapabilitySource(this.cache),
       new PatternCapabilitySource()
@@ -935,7 +694,9 @@ var ModelCapabilityResolver = class {
         );
         if (remoteSource) {
           remoteSource.refresh().catch((err) => {
-            console.warn("[agent-core] Background refresh failed:", err);
+            this.log.warn("Background refresh failed", {
+              error: err instanceof Error ? err.message : String(err)
+            });
           });
         }
       }
@@ -966,7 +727,9 @@ var ModelCapabilityResolver = class {
           }
         }
       } catch (error) {
-        console.warn(`[agent-core] Source ${source.name} failed:`, error);
+        this.log.warn(`Source ${source.name} failed`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (!bestResult?.entry) {
@@ -1094,15 +857,298 @@ function configureResolver(options) {
   defaultResolver = new ModelCapabilityResolver(options);
 }
 
+// src/models/reasoning/types.ts
+var STANDARD_LEVELS = ["off", "low", "medium", "high"];
+var EXTENDED_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+var FIXED_LEVELS = ["medium"];
+function shouldIncludeReasoningSummary() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.CODE_AGENT_DISABLE_REASONING_SUMMARY !== "true";
+  }
+  return true;
+}
+
+// src/models/reasoning/providers.ts
+function buildOpenAIOptions(level, compat) {
+  if (level === "off") return void 0;
+  const options = {};
+  if (compat?.supportsReasoningEffort !== false) {
+    options.reasoningEffort = level;
+  }
+  if (shouldIncludeReasoningSummary()) {
+    options.reasoningSummary = "auto";
+  }
+  return options;
+}
+var ANTHROPIC_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 31999
+};
+function buildAnthropicOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: ANTHROPIC_BUDGETS[level]
+    }
+  };
+}
+var GOOGLE_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 24576
+};
+function buildGoogleOptions(level, modelId) {
+  if (level === "off") return void 0;
+  if (modelId?.includes("gemini-3") || modelId?.includes("gemini-4")) {
+    return {
+      thinkingConfig: {
+        includeThoughts: true,
+        thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
+      }
+    };
+  }
+  return {
+    thinkingConfig: {
+      includeThoughts: true,
+      thinkingBudget: GOOGLE_BUDGETS[level]
+    }
+  };
+}
+function buildXAIOptions(level) {
+  if (level === "off") return void 0;
+  return { reasoningEffort: level };
+}
+function buildGroqOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    includeThoughts: true,
+    thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
+  };
+}
+var BEDROCK_ANTHROPIC_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 31999
+};
+function buildBedrockOptions(level, modelId) {
+  if (level === "off") return void 0;
+  if (modelId?.includes("anthropic") || modelId?.includes("claude")) {
+    return {
+      reasoningConfig: {
+        type: "enabled",
+        budgetTokens: BEDROCK_ANTHROPIC_BUDGETS[level]
+      }
+    };
+  }
+  return {
+    reasoningConfig: {
+      type: "enabled",
+      maxReasoningEffort: level
+    }
+  };
+}
+function buildOpenRouterOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    reasoning: { effort: level }
+  };
+}
+var PROVIDER_KEY_MAP = {
+  "openai.chat": "openai",
+  "openai.responses": "openai",
+  "anthropic.messages": "anthropic",
+  "google.generative-ai": "google",
+  "bedrock": "bedrock",
+  "azure": "azure",
+  "xai": "xai",
+  "deepinfra": "deepinfra",
+  "togetherai": "togetherai",
+  "groq": "groq",
+  "mistral": "mistral"
+};
+function getProviderOptionsKey(provider) {
+  return PROVIDER_KEY_MAP[provider] || provider.split(".")[0] || "unknown";
+}
+
+// src/models/reasoning/config.ts
+async function getReasoningConfig(model) {
+  const resolver = getDefaultResolver();
+  const result = await resolver.resolve(model);
+  const { capabilities, compatibility } = result.entry;
+  const provider = extractProvider(model);
+  const modelId = extractModelId(model).toLowerCase();
+  if (!capabilities.reasoning) {
+    return {
+      supportsReasoning: false,
+      availableLevels: ["off"],
+      getProviderOptions: () => void 0
+    };
+  }
+  if (provider?.includes("openai") || modelId.includes("gpt") || modelId.match(/^o[134]/)) {
+    if (modelId === "o1-mini") {
+      return {
+        supportsReasoning: true,
+        availableLevels: FIXED_LEVELS,
+        getProviderOptions: () => void 0
+      };
+    }
+    const isAdvanced = modelId.includes("gpt-5") || modelId.includes("o3") || modelId.includes("o4");
+    return {
+      supportsReasoning: true,
+      availableLevels: isAdvanced ? EXTENDED_LEVELS : STANDARD_LEVELS,
+      getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
+    };
+  }
+  if (provider?.includes("anthropic") || modelId.includes("claude")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: ["off", "low", "medium", "high"],
+      getProviderOptions: buildAnthropicOptions
+    };
+  }
+  if (provider?.includes("google") || modelId.includes("gemini")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: (level) => buildGoogleOptions(level, modelId)
+    };
+  }
+  if (provider?.includes("xai") || modelId.includes("grok")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: buildXAIOptions
+    };
+  }
+  if (provider?.includes("bedrock")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: (level) => buildBedrockOptions(level, modelId)
+    };
+  }
+  if (provider?.includes("groq")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: ["off", "low", "high"],
+      getProviderOptions: buildGroqOptions
+    };
+  }
+  if (provider?.includes("openrouter")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: buildOpenRouterOptions
+    };
+  }
+  if (modelId.includes("r1") || modelId.includes("deepseek")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: FIXED_LEVELS,
+      getProviderOptions: () => void 0
+    };
+  }
+  return {
+    supportsReasoning: true,
+    availableLevels: STANDARD_LEVELS,
+    getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
+  };
+}
+function getReasoningConfigSync(model) {
+  const modelId = extractModelId(model).toLowerCase();
+  const provider = extractProvider(model) || "";
+  const supportsReasoning2 = modelId.match(/^o[134]/) !== null || modelId.includes("gpt-5") || modelId.includes("r1") || modelId.includes("thinking") || modelId.includes("reasoning") || modelId.includes("grok") && modelId.includes("mini");
+  if (!supportsReasoning2) {
+    return {
+      supportsReasoning: false,
+      availableLevels: ["off"],
+      getProviderOptions: () => void 0
+    };
+  }
+  const isOpenAI = provider.includes("openai") || !!modelId.match(/^o[134]/) || modelId.includes("gpt");
+  const isAnthropic = provider.includes("anthropic") || modelId.includes("claude");
+  const isGoogle = provider.includes("google") || modelId.includes("gemini");
+  const isXAI = provider.includes("xai") || modelId.includes("grok");
+  const isBedrock = provider.includes("bedrock");
+  const isGroq = provider.includes("groq");
+  const isOpenRouter = provider.includes("openrouter");
+  return {
+    supportsReasoning: true,
+    availableLevels: STANDARD_LEVELS,
+    getProviderOptions: (level) => {
+      if (level === "off") return void 0;
+      if (isOpenAI) {
+        const opts = { reasoningEffort: level };
+        if (shouldIncludeReasoningSummary()) opts.reasoningSummary = "auto";
+        return opts;
+      }
+      if (isAnthropic) return buildAnthropicOptions(level);
+      if (isGoogle) return buildGoogleOptions(level, modelId);
+      if (isXAI) return buildXAIOptions(level);
+      if (isBedrock) return buildBedrockOptions(level, modelId);
+      if (isGroq) return buildGroqOptions(level);
+      if (isOpenRouter) return buildOpenRouterOptions(level);
+      const defaultOpts = { reasoningEffort: level };
+      if (shouldIncludeReasoningSummary()) defaultOpts.reasoningSummary = "auto";
+      return defaultOpts;
+    }
+  };
+}
+async function buildReasoningOptions(model, level) {
+  if (level === "off") return void 0;
+  const config = await getReasoningConfig(model);
+  if (!config.supportsReasoning) return void 0;
+  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
+  const options = config.getProviderOptions(effectiveLevel);
+  if (!options) return void 0;
+  const provider = extractProvider(model) || "";
+  const providerKey = getProviderOptionsKey(provider);
+  return { [providerKey]: options };
+}
+function buildReasoningOptionsSync(model, level) {
+  if (level === "off") return void 0;
+  const config = getReasoningConfigSync(model);
+  if (!config.supportsReasoning) return void 0;
+  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
+  const options = config.getProviderOptions(effectiveLevel);
+  if (!options) return void 0;
+  const provider = extractProvider(model) || "";
+  const providerKey = getProviderOptionsKey(provider);
+  return { [providerKey]: options };
+}
+async function supportsReasoning(model) {
+  const resolver = getDefaultResolver();
+  return resolver.supportsReasoning(model);
+}
+function supportsReasoningSync(model) {
+  return likelySupportsReasoning(extractModelId(model));
+}
+
 export {
+  STANDARD_LEVELS,
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  shouldIncludeReasoningSummary,
+  buildOpenAIOptions,
+  buildAnthropicOptions,
+  buildGoogleOptions,
+  buildXAIOptions,
+  buildGroqOptions,
+  buildBedrockOptions,
+  buildOpenRouterOptions,
+  getProviderOptionsKey,
   createResolver,
-  SourcePriority,
-  DEFAULT_RESOLVER_OPTIONS,
-  inferContextWindow,
-  inferProvider,
-  PatternCapabilitySource,
-  likelySupportsReasoning,
-  getProviderCompatibility,
   findCapabilityOverride,
   applyCapabilityOverride,
   CapabilityCache,
@@ -1110,9 +1156,13 @@ export {
   getNetworkStatus,
   RemoteCapabilityFetcher,
   RemoteCapabilitySource,
-  extractModelId,
-  extractProvider,
   ModelCapabilityResolver,
   getDefaultResolver,
-  configureResolver
+  configureResolver,
+  getReasoningConfig,
+  getReasoningConfigSync,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  supportsReasoning,
+  supportsReasoningSync
 };