@omnicross/core 0.1.8 → 0.1.9

package/dist/{chunk-QYC54PMG.js → chunk-CQIJCPMF.js}

@@ -4,13 +4,13 @@ import {
 import {
   AnthropicTransformer,
   resolveAnthropicMaxTokens
-} from "./chunk-PEGTIPB3.js";
+} from "./chunk-HKB656B4.js";
 import {
   GeminiTransformer
-} from "./chunk-LVUCAWMK.js";
+} from "./chunk-55FMGZ3L.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-32O35CIF.js";
+} from "./chunk-45FHEOKW.js";
 import {
   TransformerChainExecutor
 } from "./chunk-WNKWAEUR.js";
@@ -109,6 +109,9 @@ import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
 } from "./chunk-5NJLQ6T6.js";
+import {
+  resolveReasoningPlan
+} from "./chunk-N2EIM2XJ.js";
 import {
   fetchUpstream
 } from "./chunk-RJ5ZGNI3.js";
@@ -413,9 +416,6 @@ function addOpenRouterProviderToRequest(requestBody, provider, modelId) {
   };
 }
 
-// src/completion/DirectApiHandler.ts
-import { getOpenAIReasoningEffort } from "@omnicross/contracts/thinking-config";
-
 // src/provider-proxy/ProviderProxy.ts
 import http from "http";
 
@@ -1432,7 +1432,8 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   const sameFormat = route.targetProviderFormat === "anthropic" || resolveApiFormat(provider) === "anthropic";
@@ -1740,7 +1741,8 @@ async function buildByoPlan2(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -1957,7 +1959,8 @@ async function buildByoPlan3(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -2351,7 +2354,8 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -3562,6 +3566,7 @@ var KeyedMutex = class {
 
 // src/outbound-api/outboundApiRouter.ts
 import { Readable } from "stream";
+import { SUBSCRIPTION_MODEL_CATALOG } from "@omnicross/contracts/subscription-model-catalog";
 
 // src/outbound-api/apiServerConfig.ts
 import { DEFAULT_AUDIT_CONFIG } from "@omnicross/contracts/audit-types";
@@ -4987,33 +4992,51 @@ function isModelsListRequest(url) {
   const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
   return path.endsWith("/models");
 }
-function writeModelsList(res, config, apiKeyId, allowedEndpoints) {
-  const refs = [];
-  const endpointConfigs = [];
+async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoints) {
+  const modelIds = [];
   for (const endpoint of ["chat", "responses", "messages", "gemini"]) {
     if (allowedEndpoints && !allowedEndpoints.includes(endpoint)) continue;
-    endpointConfigs.push(
-      ...candidateGatewayBindings(config.bindings, apiKeyId, endpoint).map(
-        (binding) => gatewayBindingToEndpointConfig(binding)
-      )
-    );
-  }
-  for (const endpoint of endpointConfigs) {
-    if (allowedEndpoints && !allowedEndpoints.includes(endpoint.endpoint)) continue;
-    if (endpoint.endpoint === "chat") refs.push(...endpoint.models ?? []);
-    else if (endpoint.endpoint === "messages" || endpoint.endpoint === "responses") {
-      refs.push(...Object.values(endpoint.modelMap ?? {}));
-    } else {
-      if (endpoint.defaultModel) refs.push(endpoint.defaultModel);
-      if (endpoint.backgroundModel) refs.push(endpoint.backgroundModel);
+    for (const binding of candidateGatewayBindings(config.bindings, apiKeyId, endpoint)) {
+      if (binding.modelMode === "passthrough") {
+        if (binding.target.kind === "provider") {
+          const provider = await llmConfig.getProvider(binding.target.providerId);
+          modelIds.push(...provider?.models ?? []);
+        } else if (Object.prototype.hasOwnProperty.call(
+          SUBSCRIPTION_MODEL_CATALOG,
+          binding.target.providerId
+        )) {
+          modelIds.push(
+            ...SUBSCRIPTION_MODEL_CATALOG[binding.target.providerId]
+          );
+        }
+        continue;
+      }
+      if (binding.modelMappings?.length) {
+        modelIds.push(
+          ...binding.modelMappings.map((mapping) => mapping.source.trim()).filter((source) => source !== "" && !source.includes("*"))
+        );
+        continue;
+      }
+      const endpointConfig = gatewayBindingToEndpointConfig(binding);
+      const refs = [];
+      if (endpointConfig.endpoint === "chat") refs.push(...endpointConfig.models ?? []);
+      else if (endpointConfig.endpoint === "messages" || endpointConfig.endpoint === "responses") {
+        refs.push(...Object.values(endpointConfig.modelMap ?? {}));
+      } else {
+        if (endpointConfig.defaultModel) refs.push(endpointConfig.defaultModel);
+        if (endpointConfig.backgroundModel) refs.push(endpointConfig.backgroundModel);
+      }
+      modelIds.push(
+        ...refs.map((ref) => parseModelRef(ref)?.modelId).filter((modelId) => modelId !== void 0)
+      );
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  const data = refs.map((ref) => parseModelRef(ref)).filter((p) => p !== null).filter((p) => {
-    if (seen.has(p.modelId)) return false;
-    seen.add(p.modelId);
+  const data = modelIds.filter((modelId) => {
+    if (seen.has(modelId)) return false;
+    seen.add(modelId);
     return true;
-  }).map((p) => ({ id: p.modelId, object: "model", owned_by: "omnicross" }));
+  }).map((modelId) => ({ id: modelId, object: "model", owned_by: "omnicross" }));
   res.writeHead(200, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ object: "list", data }));
 }
@@ -5081,7 +5104,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       writeJsonError(res, 403, "API key is not allowed to access this endpoint");
       return;
     }
-    writeModelsList(res, config, verified.id, verified.allowedEndpoints);
+    await writeModelsList(res, deps.llmConfig, config, verified.id, verified.allowedEndpoints);
     return;
   }
   const endpoint = selectEndpoint(req.method, req.url);
@@ -5637,6 +5660,70 @@ function __resetOutboundApiServerForTests() {
   instance2 = null;
 }
 
+// src/completion/ReasoningRequestBuilder.ts
+var LEGACY_ANTHROPIC_MAX_TOKENS = 16384;
+function intentFromOptions(options) {
+  return options.thinkLevel ? { effort: options.thinkLevel, enabled: options.thinkLevel !== "none" } : void 0;
+}
+function resolveCompletionReasoningPlan(provider, options, target, requestMaxTokens = options.maxTokens) {
+  return resolveReasoningPlan({
+    intent: intentFromOptions(options),
+    model: options.model,
+    provider,
+    target,
+    requestMaxTokens
+  });
+}
+function resolveOpenAIEffort(provider, options, target) {
+  const plan = resolveCompletionReasoningPlan(provider, options, target);
+  return plan?.kind === "level" && plan.enabled ? plan.effort : void 0;
+}
+function buildAnthropicReasoningWire(provider, options) {
+  const configuredMaxTokens = options.maxTokens ?? LEGACY_ANTHROPIC_MAX_TOKENS;
+  const legacyBound = Math.min(configuredMaxTokens, LEGACY_ANTHROPIC_MAX_TOKENS);
+  const plan = resolveCompletionReasoningPlan(
+    provider,
+    options,
+    "anthropic",
+    legacyBound
+  );
+  if (plan?.kind === "level" && plan.enabled) {
+    return {
+      effectiveMaxTokens: configuredMaxTokens,
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: plan.effort },
+      legacyBudgetEnabled: false
+    };
+  }
+  if (plan?.kind === "budget" && plan.enabled) {
+    return {
+      effectiveMaxTokens: legacyBound,
+      thinking: { type: "enabled", budget_tokens: plan.budgetTokens },
+      legacyBudgetEnabled: true
+    };
+  }
+  return {
+    effectiveMaxTokens: configuredMaxTokens,
+    legacyBudgetEnabled: false
+  };
+}
+function buildGeminiThinkingConfig(provider, options) {
+  const plan = resolveCompletionReasoningPlan(provider, options, "gemini");
+  if (plan?.kind === "level") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingLevel: plan.effort
+    };
+  }
+  if (plan?.kind === "budget") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingBudget: plan.budgetTokens
+    };
+  }
+  return void 0;
+}
+
 // src/completion/DirectApiHandler.ts
 async function callOpenAICompletion(provider, apiKey, options, logger) {
   const request = {
@@ -5648,11 +5735,9 @@ async function callOpenAICompletion(provider, apiKey, options, logger) {
     stream: false
     // For now, non-streaming only
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort(options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5689,16 +5774,19 @@ async function callOpenAICompletion(provider, apiKey, options, logger) {
 }
 async function callAnthropicCompletion(provider, apiKey, options, logger) {
   const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
+  const reasoningWire = buildAnthropicReasoningWire(provider, options);
   if (hasImages) {
     const systemMessages = options.messages.filter((m) => m.role === "system");
     const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
     const anthropicRequest2 = {
       model: options.model,
-      max_tokens: options.maxTokens ?? 16384,
-      temperature: options.temperature,
+      max_tokens: reasoningWire.effectiveMaxTokens,
+      ...reasoningWire.legacyBudgetEnabled ? {} : { temperature: options.temperature },
       ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
       messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
-      stream: false
+      stream: false,
+      ...reasoningWire.thinking ? { thinking: reasoningWire.thinking } : {},
+      ...reasoningWire.outputConfig ? { output_config: reasoningWire.outputConfig } : {}
     };
     const apiUrl2 = buildProviderApiUrl(provider, { model: options.model, stream: false });
     const headers2 = getProviderHeaders(provider, apiKey);
@@ -5740,14 +5828,24 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       content: m.content
     })),
     // Anthropic requires max_tokens; use 16384 default if not explicitly set
-    max_tokens: options.maxTokens ?? 16384,
-    temperature: options.temperature,
+    max_tokens: reasoningWire.effectiveMaxTokens,
+    temperature: reasoningWire.legacyBudgetEnabled ? void 0 : options.temperature,
     stream: false
   };
   const config = {
     defaultModel: options.model
   };
   const anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
+  const anthropicRequestBody = anthropicRequest;
+  if (reasoningWire.thinking) {
+    anthropicRequestBody.thinking = reasoningWire.thinking;
+  }
+  if (reasoningWire.outputConfig) {
+    anthropicRequestBody.output_config = reasoningWire.outputConfig;
+  }
+  if (reasoningWire.legacyBudgetEnabled) {
+    delete anthropicRequestBody.temperature;
+  }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
   logger.info("Calling Anthropic completion API", { url: apiUrl, model: options.model });
@@ -5792,11 +5890,13 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
       contents.push(convertMessageToGemini(msg));
     }
   }
+  const thinkingConfig = buildGeminiThinkingConfig(provider, options);
   const request = {
     contents,
     generationConfig: {
       ...options.maxTokens !== void 0 ? { maxOutputTokens: options.maxTokens } : {},
-      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...thinkingConfig ? { thinkingConfig } : {}
     }
   };
   if (systemInstruction) {
@@ -5867,11 +5967,9 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
     ...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort(options.thinkLevel);
-    if (effort) {
-      request.reasoning = { effort, summary: "auto" };
-    }
+  const responseEffort = resolveOpenAIEffort(provider, options, "openai-responses");
+  if (responseEffort) {
+    request.reasoning = { effort: responseEffort, summary: "auto" };
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5923,7 +6021,6 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
 }
 
 // src/completion/StreamHandler.ts
-import { buildAnthropicThinking, getOpenAIReasoningEffort as getOpenAIReasoningEffort2 } from "@omnicross/contracts/thinking-config";
 async function streamOpenAICompletion(provider, apiKey, options, messageId, callbacks, logger) {
   const request = {
     model: options.model,
@@ -5933,11 +6030,9 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     temperature: options.temperature,
     stream: true
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort2(options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5987,16 +6082,11 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
 }
 async function streamAnthropicCompletion(provider, apiKey, options, messageId, callbacks, logger) {
   const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
-  const MAX_TOKENS_FOR_THINKING = 16384;
-  let effectiveMaxTokens = options.maxTokens ?? 16384;
-  const thinkingMaxTokens = options.thinkLevel && options.thinkLevel !== "none" ? Math.min(effectiveMaxTokens, MAX_TOKENS_FOR_THINKING) : effectiveMaxTokens;
-  const thinkingConfig = options.thinkLevel && options.thinkLevel !== "none" ? buildAnthropicThinking(options.model, options.thinkLevel, thinkingMaxTokens) : void 0;
-  if (thinkingConfig) {
-    effectiveMaxTokens = thinkingMaxTokens;
-  }
+  const reasoningWire = buildAnthropicReasoningWire(provider, options);
+  const effectiveMaxTokens = reasoningWire.effectiveMaxTokens;
   logger.debug("Anthropic thinking configuration", {
     thinkLevel: options.thinkLevel,
-    thinkingConfig,
+    thinkingConfig: reasoningWire.thinking,
     effectiveMaxTokens
   });
   let anthropicRequest;
@@ -6007,12 +6097,15 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
       model: options.model,
       max_tokens: effectiveMaxTokens,
       // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
-      ...thinkingConfig ? {} : { temperature: options.temperature },
+      ...reasoningWire.legacyBudgetEnabled ? {} : { temperature: options.temperature },
       ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
       messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
       stream: true,
-      ...thinkingConfig ? { thinking: thinkingConfig } : {}
+      ...reasoningWire.thinking ? { thinking: reasoningWire.thinking } : {}
     };
+    if (reasoningWire.outputConfig) {
+      anthropicRequest.output_config = reasoningWire.outputConfig;
+    }
   } else {
     const config = {
       defaultModel: options.model
@@ -6026,12 +6119,17 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
       // Anthropic requires max_tokens; use adjusted value
       max_tokens: effectiveMaxTokens,
       // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
-      temperature: thinkingConfig ? void 0 : options.temperature,
+      temperature: reasoningWire.legacyBudgetEnabled ? void 0 : options.temperature,
       stream: true
     };
     anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
-    if (thinkingConfig) {
-      anthropicRequest.thinking = thinkingConfig;
+    if (reasoningWire.thinking) {
+      anthropicRequest.thinking = reasoningWire.thinking;
+    }
+    if (reasoningWire.outputConfig) {
+      anthropicRequest.output_config = reasoningWire.outputConfig;
+    }
+    if (reasoningWire.legacyBudgetEnabled) {
       delete anthropicRequest.temperature;
     }
   }
@@ -6097,11 +6195,13 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
       contents.push(convertMessageToGemini(msg));
     }
   }
+  const thinkingConfig = buildGeminiThinkingConfig(provider, options);
   const request = {
     contents,
     generationConfig: {
       ...options.maxTokens !== void 0 ? { maxOutputTokens: options.maxTokens } : {},
-      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...thinkingConfig ? { thinkingConfig } : {}
     }
   };
   if (systemInstruction) {
@@ -6167,11 +6267,9 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
     ...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort2(options.thinkLevel);
-    if (effort) {
-      request.reasoning = { effort, summary: "auto" };
-    }
+  const responseEffort = resolveOpenAIEffort(provider, options, "openai-responses");
+  if (responseEffort) {
+    request.reasoning = { effort: responseEffort, summary: "auto" };
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
   const headers = getProviderHeaders(provider, apiKey);
@@ -6215,7 +6313,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
 
 // src/completion/ThinkingResolver.ts
 import {
-  buildAnthropicThinking as buildAnthropicThinking2,
+  buildAnthropicThinking,
   calculateThinkingBudget,
   DEFAULT_MAX_TOKENS,
   getClaudeMaxTokens,
@@ -6259,7 +6357,7 @@ async function resolveThinkingBudget(getProvider, logger, providerId, modelId, m
   const providerName = provider?.name?.toLowerCase() || "";
   const apiFormat = provider ? resolveApiFormat(provider) : "openai";
   if (apiFormat === "anthropic" || providerName === "anthropic" || providerName.includes("claude")) {
-    const thinkingConfig = buildAnthropicThinking2(modelId, thinkLevel, maxTokens);
+    const thinkingConfig = buildAnthropicThinking(modelId, thinkLevel, maxTokens);
     const adjustedMaxTokens = getClaudeMaxTokens(maxTokens, thinkingBudget) || maxTokens;
     logger.debug("Claude model thinking budget", {
       thinkingBudget,
@@ -6914,7 +7012,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       name: provider.name,
       baseUrl: provider.api_base_url,
       apiKey,
-      models: provider.models || []
+      models: provider.models || [],
+      modelConfigs: provider.modelConfigs
     };
     const executor = getSharedExecutor2();
     const { response } = await executeProviderCall({
@@ -7044,7 +7143,8 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       name: provider.name,
       baseUrl: provider.api_base_url,
       apiKey,
-      models: provider.models || []
+      models: provider.models || [],
+      modelConfigs: provider.modelConfigs
     };
     const executor = getSharedExecutor2();
     const { response } = await executeProviderCall({

package/dist/{chunk-PEGTIPB3.js → chunk-HKB656B4.js}

@@ -1,6 +1,16 @@
 import {
   anthropicUsageToChatUsage
 } from "./chunk-FU7EAR73.js";
+import {
+  flattenToolResultContent,
+  formatBase64,
+  getThinkLevel
+} from "./chunk-WYVGULTQ.js";
+import {
+  extractReasoningIntent,
+  normalizeThinkLevel,
+  resolveReasoningPlan
+} from "./chunk-N2EIM2XJ.js";
 
 // src/transformer/transformers/AnthropicToolHandling.ts
 function isServerSideTool(tool) {
@@ -18,38 +28,6 @@ function convertAnthropicToolsToOpenAI(tools) {
   }));
 }
 
-// src/transformer/transformers/AnthropicTypes.ts
-function getThinkLevel(budgetTokens) {
-  if (!budgetTokens || budgetTokens <= 0) return "none";
-  if (budgetTokens < 4096) return "low";
-  if (budgetTokens < 16384) return "medium";
-  return "high";
-}
-function formatBase64(data, mediaType) {
-  if (data.startsWith("data:")) return data;
-  return `data:${mediaType || "image/png"};base64,${data}`;
-}
-function flattenToolResultContent(content) {
-  if (typeof content === "string") return content;
-  if (content == null) return "";
-  if (!Array.isArray(content)) return JSON.stringify(content);
-  const parts = [];
-  for (const block of content) {
-    if (typeof block === "string") {
-      parts.push(block);
-      continue;
-    }
-    if (!block || typeof block !== "object") continue;
-    const typed = block;
-    if (typed.type === "image" || typed.type === "image_url") {
-      parts.push("[image omitted]");
-    } else if (typeof typed.text === "string") {
-      parts.push(typed.text);
-    }
-  }
-  return parts.filter((text) => text !== "").join("\n");
-}
-
 // src/anthropicMaxTokens.ts
 import { lookupCanonicalCapabilities } from "@omnicross/contracts/canonical-models";
 var ANTHROPIC_FALLBACK_MAX_TOKENS = 128e3;
@@ -65,7 +43,7 @@ function resolveAnthropicMaxTokens(model, requested) {
 }
 
 // src/transformer/transformers/AnthropicRequestBuilder.ts
-function buildAnthropicRequestBody(request) {
+function buildAnthropicRequestBody(request, provider) {
   let systemContent;
   const anthropicMessages = [];
   for (let i = 0; i < request.messages.length; i++) {
@@ -202,10 +180,18 @@ function buildAnthropicRequestBody(request) {
       body.tool_choice = { type: "tool", name: request.tool_choice.function.name };
     }
   }
-  if (request.reasoning?.enabled) {
-    const budgetMap = { low: 2048, medium: 8192, high: 32768 };
-    const budget = request.reasoning.max_tokens || budgetMap[request.reasoning.effort || "medium"] || 8192;
-    body.thinking = { type: "enabled", budget_tokens: budget };
+  const reasoningPlan = resolveReasoningPlan({
+    intent: extractReasoningIntent(request),
+    model: request.model,
+    provider,
+    target: "anthropic",
+    requestMaxTokens: request.max_tokens
+  });
+  if (reasoningPlan?.kind === "level" && reasoningPlan.enabled) {
+    body.thinking = { type: "adaptive" };
+    body.output_config = { effort: reasoningPlan.effort };
+  } else if (reasoningPlan?.kind === "budget" && reasoningPlan.enabled) {
+    body.thinking = { type: "enabled", budget_tokens: reasoningPlan.budgetTokens };
     body.temperature = 1;
   }
   return body;
@@ -461,10 +447,18 @@ function transformAnthropicRequestToUnified(request) {
     result._serverSideTools = serverSideTools;
   }
   if (anthropicRequest.thinking) {
-    result.reasoning = {
-      effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
-      enabled: anthropicRequest.thinking.type === "enabled"
-    };
+    if (anthropicRequest.thinking.type === "disabled") {
+      result.reasoning = { effort: "none", enabled: false };
+    } else if (anthropicRequest.thinking.type === "adaptive") {
+      const effort = normalizeThinkLevel(anthropicRequest.output_config?.effort);
+      if (effort) result.reasoning = { effort, enabled: effort !== "none" };
+    } else {
+      result.reasoning = {
+        effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
+        enabled: true,
+        ...typeof anthropicRequest.thinking.budget_tokens === "number" ? { max_tokens: anthropicRequest.thinking.budget_tokens } : {}
+      };
+    }
   }
   if (anthropicRequest.tool_choice) {
     if (anthropicRequest.tool_choice.type === "tool" && anthropicRequest.tool_choice.name) {
@@ -994,8 +988,8 @@ var AnthropicTransformer = class {
    * This is the reverse of transformRequestOut — converts OpenAI/unified format
    * to Anthropic's expected request body structure.
    */
-  async transformRequestIn(request, _provider, _context) {
-    return buildAnthropicRequestBody(request);
+  async transformRequestIn(request, provider, _context) {
+    return buildAnthropicRequestBody(request, provider);
   }
   /**
    * Transform Anthropic response to OpenAI/unified format