@omnicross/core 0.1.8 → 0.1.10

package/dist/{chunk-QYC54PMG.js → chunk-FEBAQI5A.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";
@@ -33,9 +33,11 @@ import {
   captureCallerIdentity
 } from "./chunk-XX6NQJMA.js";
 import {
+  MATCH_TEXT_PER_MESSAGE_CAP,
   collectMatchText,
   deriveGatewaySessionKey,
-  deriveSubscriptionSessionKey
+  deriveSubscriptionSessionKey,
+  flattenMatchText
 } from "./chunk-GFIZ6LQI.js";
 import {
   emitWebhookEvent
@@ -104,11 +106,14 @@ import {
 } from "./chunk-H5JUT3KV.js";
 import {
   beginAuditCapture
-} from "./chunk-7C7DET6S.js";
+} from "./chunk-GXEZ2R3E.js";
 import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
 } from "./chunk-5NJLQ6T6.js";
+import {
+  resolveReasoningPlan
+} from "./chunk-N2EIM2XJ.js";
 import {
   fetchUpstream
 } from "./chunk-RJ5ZGNI3.js";
@@ -413,9 +418,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 +1434,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 +1743,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 +1961,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 +2356,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 +3568,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";
@@ -3659,6 +3666,7 @@ function normalizeAudit(raw) {
     retentionDays: Math.trunc(
       clampNumber(a?.retentionDays, 1, 365, DEFAULT_AUDIT_CONFIG.retentionDays)
     ),
+    compactStreamingBodies: a?.compactStreamingBodies === true,
     trustForwardedFor: a?.trustForwardedFor === true
   };
 }
@@ -4126,8 +4134,62 @@ function mergeServerConfig(current, patch) {
   });
 }
 
+// src/outbound-api/auditSessionKey.ts
+import { createHash as createHash2 } from "crypto";
+var EXPLICIT_ID_SOURCES = /* @__PURE__ */ new Set([
+  "session-header",
+  "thread-header",
+  "body-session-id",
+  "body-thread-id",
+  "prompt-cache-key"
+]);
+var ANTHROPIC_SESSION_RE = /_session_([A-Za-z0-9][A-Za-z0-9_-]{7,})/;
+var DIGEST_HEX = 32;
+function stableDigest(value) {
+  return createHash2("sha256").update(value, "utf8").digest("hex").slice(0, DIGEST_HEX);
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function anthropicSessionId(body) {
+  const userId = asObject(body["metadata"])?.["user_id"];
+  if (typeof userId !== "string" || !userId) return void 0;
+  const matched = ANTHROPIC_SESSION_RE.exec(userId);
+  return matched?.[1];
+}
+function anthropicContentFingerprint(body) {
+  const messages = body["messages"];
+  if (!Array.isArray(messages) || messages.length === 0) return void 0;
+  const parts = [];
+  const system = flattenMatchText(body["system"]).trim();
+  if (system) parts.push(system.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  let firstUser = "";
+  for (const entry of messages) {
+    const message = asObject(entry);
+    if (!message || message["role"] !== "user") continue;
+    const text = flattenMatchText(message["content"]).trim();
+    if (!text) continue;
+    firstUser = text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+    break;
+  }
+  if (parts.length === 0 && !firstUser) return void 0;
+  return `${parts.join("\0")}\0${firstUser}`;
+}
+function deriveAuditSessionKey(body, headers = {}, options = {}) {
+  const anthropicSession = anthropicSessionId(body);
+  if (anthropicSession) return stableDigest(`anthropic-session\0${anthropicSession}`);
+  const gateway = deriveGatewaySessionKey(body, headers, {
+    ...options.fallbackKey !== void 0 ? { fallbackKey: options.fallbackKey } : {},
+    ...options.endpoint !== void 0 ? { endpoint: options.endpoint } : {}
+  });
+  if (EXPLICIT_ID_SOURCES.has(gateway.source)) return gateway.key;
+  const fingerprint = anthropicContentFingerprint(body);
+  if (fingerprint) return stableDigest(`anthropic-content\0${fingerprint}`);
+  return gateway.key;
+}
+
 // src/outbound-api/outboundApiKeyAuth.ts
-import { createHash as createHash2, randomBytes as randomBytes4 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes4 } from "crypto";
 
 // src/outbound-api/keyPolicy.ts
 var DAY_MS = 864e5;
@@ -4192,7 +4254,7 @@ function generateSecret() {
   return KEY_PREFIX + randomBase62(SECRET_BYTES);
 }
 function hashKey(secret) {
-  return createHash2("sha256").update(secret, "utf8").digest("hex");
+  return createHash3("sha256").update(secret, "utf8").digest("hex");
 }
 function keyPrefix(secret) {
   return secret.slice(0, PREFIX_LEN);
@@ -4520,7 +4582,7 @@ var OutboundRateLimiter = class {
 function asArray(v) {
   return Array.isArray(v) ? v : [];
 }
-function asObject(v) {
+function asObject2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
 function last(arr) {
@@ -4528,13 +4590,13 @@ function last(arr) {
 }
 function isUserMessageAnthropic(body) {
   const messages = asArray(body["messages"]);
-  const lastMsg = asObject(last(messages));
+  const lastMsg = asObject2(last(messages));
   if (!lastMsg || lastMsg["role"] !== "user") return false;
   const content = lastMsg["content"];
   if (typeof content === "string") return true;
   if (Array.isArray(content)) {
     const hasToolResult = content.some(
-      (block) => asObject(block)?.["type"] === "tool_result"
+      (block) => asObject2(block)?.["type"] === "tool_result"
     );
     return !hasToolResult;
   }
@@ -4544,7 +4606,7 @@ function isUserMessageResponses(body) {
   const input = body["input"];
   if (typeof input === "string") return input.length > 0;
   if (Array.isArray(input)) {
-    const lastItem = asObject(last(input));
+    const lastItem = asObject2(last(input));
     if (!lastItem) return false;
     if (lastItem["type"] === "function_call_output") return false;
     return lastItem["role"] === "user";
@@ -4553,22 +4615,22 @@ function isUserMessageResponses(body) {
 }
 function isUserMessageChat(body) {
   const messages = asArray(body["messages"]);
-  const lastMsg = asObject(last(messages));
+  const lastMsg = asObject2(last(messages));
   if (!lastMsg) return false;
   return lastMsg["role"] === "user";
 }
 function isUserMessageGemini(body) {
   const contents = asArray(body["contents"]);
-  const lastContent = asObject(last(contents));
+  const lastContent = asObject2(last(contents));
   if (!lastContent || lastContent["role"] !== "user") return false;
   const parts = asArray(lastContent["parts"]);
   const hasFunctionResponse = parts.some(
-    (part) => asObject(part)?.["functionResponse"] !== void 0
+    (part) => asObject2(part)?.["functionResponse"] !== void 0
   );
   return !hasFunctionResponse;
 }
 function isUserMessageRequest(endpoint, parsedBody) {
-  const body = asObject(parsedBody);
+  const body = asObject2(parsedBody);
   if (!body) return false;
   switch (endpoint) {
     case "messages":
@@ -4718,7 +4780,7 @@ var UserMessageSerialQueue = class {
 };
 
 // src/outbound-api/voucher.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var CODE_ENTROPY_CHARS = 32;
 var CODE_PREFIX = "CC_";
 var DISPLAY_PREFIX_LEN = 8;
@@ -4727,7 +4789,7 @@ function generateVoucherCode() {
   return CODE_PREFIX + randomBase62(CODE_ENTROPY_CHARS);
 }
 function hashVoucherCode(code) {
-  return createHash3("sha256").update(code, "utf8").digest("hex");
+  return createHash4("sha256").update(code, "utf8").digest("hex");
 }
 function voucherCodePrefix(code) {
   return code.slice(0, DISPLAY_PREFIX_LEN);
@@ -4987,33 +5049,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 +5161,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);
@@ -5162,7 +5242,13 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       writeJsonError(res, 400, "Invalid JSON in request body");
       return;
     }
-    if (audit) audit.setRequestBody(rawBody);
+    if (audit) {
+      audit.setRequestBody(rawBody);
+      audit.sessionKey = deriveAuditSessionKey(parsedBody, req.headers, {
+        fallbackKey: verified.id,
+        endpoint
+      });
+    }
     if (endpoint === "gemini" && typeof parsedBody["model"] !== "string") {
       const urlModel = extractGeminiModelFromUrl(req.url);
       if (urlModel) parsedBody["model"] = urlModel;
@@ -5637,6 +5723,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 +5798,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 +5837,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 +5891,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 +5953,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 +6030,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 +6084,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 +6093,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 +6145,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 +6160,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 +6182,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 +6258,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 +6330,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 +6376,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
 
 // src/completion/ThinkingResolver.ts
 import {
-  buildAnthropicThinking as buildAnthropicThinking2,
+  buildAnthropicThinking,
   calculateThinkingBudget,
   DEFAULT_MAX_TOKENS,
   getClaudeMaxTokens,
@@ -6259,7 +6420,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 +7075,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 +7206,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({