@omnicross/core 0.1.8 → 0.1.9

package/dist/{chunk-26K6T2YS.cjs → chunk-XELFM7KL.cjs}

@@ -4,13 +4,13 @@ var _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
 
 
 
-var _chunkOXHNSZ53cjs = require('./chunk-OXHNSZ53.cjs');
+var _chunkZQQUD66Mcjs = require('./chunk-ZQQUD66M.cjs');
 
 
-var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
+var _chunk5LNYGCIWcjs = require('./chunk-5LNYGCIW.cjs');
 
 
-var _chunkOVQBNVSVcjs = require('./chunk-OVQBNVSV.cjs');
+var _chunkCMVXX7ONcjs = require('./chunk-CMVXX7ON.cjs');
 
 
 var _chunkIIRPUVPHcjs = require('./chunk-IIRPUVPH.cjs');
@@ -111,6 +111,9 @@ var _chunkXPIOJQS2cjs = require('./chunk-XPIOJQS2.cjs');
 var _chunkGDIXXKF2cjs = require('./chunk-GDIXXKF2.cjs');
 
 
+var _chunkAOFWNWLTcjs = require('./chunk-AOFWNWLT.cjs');
+
+
 var _chunkRJUONLUQcjs = require('./chunk-RJUONLUQ.cjs');
 
 
@@ -413,9 +416,6 @@ function addOpenRouterProviderToRequest(requestBody, provider, modelId) {
   };
 }
 
-// src/completion/DirectApiHandler.ts
-var _thinkingconfig = require('@omnicross/contracts/thinking-config');
-
 // src/provider-proxy/ProviderProxy.ts
 var _http = require('http'); var _http2 = _interopRequireDefault(_http);
 
@@ -651,17 +651,17 @@ function getSharedExecutor() {
 }
 var sharedResponses = null;
 function getResponsesEndpointTransformer() {
-  if (!sharedResponses) sharedResponses = new (0, _chunkOVQBNVSVcjs.OpenAIResponseTransformer)();
+  if (!sharedResponses) sharedResponses = new (0, _chunkCMVXX7ONcjs.OpenAIResponseTransformer)();
   return sharedResponses;
 }
 var sharedAnthropic = null;
 function getAnthropicEndpointTransformer() {
-  if (!sharedAnthropic) sharedAnthropic = new (0, _chunkOXHNSZ53cjs.AnthropicTransformer)();
+  if (!sharedAnthropic) sharedAnthropic = new (0, _chunkZQQUD66Mcjs.AnthropicTransformer)();
   return sharedAnthropic;
 }
 var sharedGemini = null;
 function getGeminiEndpointTransformer() {
-  if (!sharedGemini) sharedGemini = new (0, _chunkV4TXMEJScjs.GeminiTransformer)();
+  if (!sharedGemini) sharedGemini = new (0, _chunk5LNYGCIWcjs.GeminiTransformer)();
   return sharedGemini;
 }
 function readBody(req) {
@@ -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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: resolvedModel, stream: isStream });
   const sameFormat = route.targetProviderFormat === "anthropic" || _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: resolvedModel, stream: isStream });
   return {
@@ -3562,6 +3566,7 @@ var KeyedMutex = (_class5 = class {constructor() { _class5.prototype.__init11.ca
 
 // src/outbound-api/outboundApiRouter.ts
 var _stream = require('stream');
+var _subscriptionmodelcatalog = require('@omnicross/contracts/subscription-model-catalog');
 
 // src/outbound-api/apiServerConfig.ts
 var _audittypes = require('@omnicross/contracts/audit-types');
@@ -4987,33 +4992,51 @@ function isModelsListRequest(url) {
   const path = _nullishCoalesce(_optionalChain([url, 'access', _253 => _253.split, 'call', _254 => _254("?"), 'access', _255 => _255[0], 'optionalAccess', _256 => _256.replace, 'call', _257 => _257(/\/+$/, "")]), () => ( ""));
   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(..._nullishCoalesce(endpoint.models, () => ( [])));
-    else if (endpoint.endpoint === "messages" || endpoint.endpoint === "responses") {
-      refs.push(...Object.values(_nullishCoalesce(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(..._nullishCoalesce(_optionalChain([provider, 'optionalAccess', _258 => _258.models]), () => ( [])));
+        } else if (Object.prototype.hasOwnProperty.call(
+          _subscriptionmodelcatalog.SUBSCRIPTION_MODEL_CATALOG,
+          binding.target.providerId
+        )) {
+          modelIds.push(
+            ..._subscriptionmodelcatalog.SUBSCRIPTION_MODEL_CATALOG[binding.target.providerId]
+          );
+        }
+        continue;
+      }
+      if (_optionalChain([binding, 'access', _259 => _259.modelMappings, 'optionalAccess', _260 => _260.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(..._nullishCoalesce(endpointConfig.models, () => ( [])));
+      else if (endpointConfig.endpoint === "messages" || endpointConfig.endpoint === "responses") {
+        refs.push(...Object.values(_nullishCoalesce(endpointConfig.modelMap, () => ( {}))));
+      } else {
+        if (endpointConfig.defaultModel) refs.push(endpointConfig.defaultModel);
+        if (endpointConfig.backgroundModel) refs.push(endpointConfig.backgroundModel);
+      }
+      modelIds.push(
+        ...refs.map((ref) => _optionalChain([_chunk4VZX5F4Tcjs.parseModelRef.call(void 0, ref), 'optionalAccess', _261 => _261.modelId])).filter((modelId) => modelId !== void 0)
+      );
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  const data = refs.map((ref) => _chunk4VZX5F4Tcjs.parseModelRef.call(void 0, 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 }));
 }
@@ -5047,7 +5070,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
   const verified = verification.key;
   if (audit) audit.keyId = verified.id;
   if (billing) billing.keyId = verified.id;
-  if (verified.loopbackOnly && !isLoopbackPeer(_optionalChain([req, 'access', _258 => _258.socket, 'optionalAccess', _259 => _259.remoteAddress]))) {
+  if (verified.loopbackOnly && !isLoopbackPeer(_optionalChain([req, 'access', _262 => _262.socket, 'optionalAccess', _263 => _263.remoteAddress]))) {
     writeJsonError(res, 403, "This integration key is restricted to loopback clients");
     return;
   }
@@ -5060,7 +5083,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       req,
       res,
       deps,
-      _optionalChain([config, 'access', _260 => _260.voucher, 'optionalAccess', _261 => _261.enabled]) === true,
+      _optionalChain([config, 'access', _264 => _264.voucher, 'optionalAccess', _265 => _265.enabled]) === true,
       _nullishCoalesce(redeemLimiter, () => ( getFallbackRedeemLimiter())),
       verified.id,
       _nullishCoalesce(presented, () => ( "")),
@@ -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);
@@ -5229,7 +5252,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
     }
     let releaseSerial = null;
     const providerKey = resolved.route.providerId;
-    if (_optionalChain([config, 'access', _262 => _262.userMessageQueue, 'optionalAccess', _263 => _263.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
+    if (_optionalChain([config, 'access', _266 => _266.userMessageQueue, 'optionalAccess', _267 => _267.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
       const umq = config.userMessageQueue;
       try {
         const serialSlot = await serialQueue.acquire(providerKey, {
@@ -5369,7 +5392,7 @@ var OutboundApiServer = (_class13 = class {
     const actualPort = await this.listen(bindAddr, port);
     this.boundAddr = bindAddr;
     this.boundPort = actualPort;
-    if (actualPort !== port) _optionalChain([this, 'access', _264 => _264.onPortChange, 'optionalCall', _265 => _265(actualPort)]);
+    if (actualPort !== port) _optionalChain([this, 'access', _268 => _268.onPortChange, 'optionalCall', _269 => _269(actualPort)]);
     this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
@@ -5438,7 +5461,7 @@ var OutboundApiServer = (_class13 = class {
     const provider = this.deps.healthReportProvider;
     if (!provider) return false;
     if (req.method !== "GET" && req.method !== "HEAD") return false;
-    const path = _optionalChain([(_nullishCoalesce(req.url, () => ( "/"))), 'access', _266 => _266.split, 'call', _267 => _267("?"), 'access', _268 => _268[0], 'optionalAccess', _269 => _269.replace, 'call', _270 => _270(/\/+$/, "")]) || "/";
+    const path = _optionalChain([(_nullishCoalesce(req.url, () => ( "/"))), 'access', _270 => _270.split, 'call', _271 => _271("?"), 'access', _272 => _272[0], 'optionalAccess', _273 => _273.replace, 'call', _274 => _274(/\/+$/, "")]) || "/";
     if (path !== "/health" && path !== "/healthz") return false;
     const report = provider();
     res.writeHead(_healthloggingtypes.healthHttpStatus.call(void 0, report.status), { "Content-Type": "application/json" });
@@ -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 _chunkAOFWNWLTcjs.resolveReasoningPlan.call(void 0, {
+    intent: intentFromOptions(options),
+    model: options.model,
+    provider,
+    target,
+    requestMaxTokens
+  });
+}
+function resolveOpenAIEffort(provider, options, target) {
+  const plan = resolveCompletionReasoningPlan(provider, options, target);
+  return _optionalChain([plan, 'optionalAccess', _275 => _275.kind]) === "level" && plan.enabled ? plan.effort : void 0;
+}
+function buildAnthropicReasoningWire(provider, options) {
+  const configuredMaxTokens = _nullishCoalesce(options.maxTokens, () => ( LEGACY_ANTHROPIC_MAX_TOKENS));
+  const legacyBound = Math.min(configuredMaxTokens, LEGACY_ANTHROPIC_MAX_TOKENS);
+  const plan = resolveCompletionReasoningPlan(
+    provider,
+    options,
+    "anthropic",
+    legacyBound
+  );
+  if (_optionalChain([plan, 'optionalAccess', _276 => _276.kind]) === "level" && plan.enabled) {
+    return {
+      effectiveMaxTokens: configuredMaxTokens,
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: plan.effort },
+      legacyBudgetEnabled: false
+    };
+  }
+  if (_optionalChain([plan, 'optionalAccess', _277 => _277.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 (_optionalChain([plan, 'optionalAccess', _278 => _278.kind]) === "level") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingLevel: plan.effort
+    };
+  }
+  if (_optionalChain([plan, 'optionalAccess', _279 => _279.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 = _thinkingconfig.getOpenAIReasoningEffort.call(void 0, options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, 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: _nullishCoalesce(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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
     const headers2 = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
@@ -5723,7 +5811,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       message: {
         id: `assistant-${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice2, 'access', _271 => _271.message, 'optionalAccess', _272 => _272.content]) || "",
+        content: _optionalChain([choice2, 'access', _280 => _280.message, 'optionalAccess', _281 => _281.content]) || "",
         timestamp: Date.now()
       },
       usage: openaiResponse2.usage ? {
@@ -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: _nullishCoalesce(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 = _chunkGDIXXKF2cjs.convertOpenAIToAnthropic.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, 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) {
@@ -5828,7 +5928,7 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
   const candidate = candidates[0];
   const content = candidate.content;
   let textContent = "";
-  if (_optionalChain([content, 'optionalAccess', _273 => _273.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _282 => _282.parts])) {
     for (const part of content.parts) {
       if (part.text) {
         textContent += part.text;
@@ -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 = _thinkingconfig.getOpenAIReasoningEffort.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
@@ -5923,7 +6021,6 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
 }
 
 // src/completion/StreamHandler.ts
-
 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 = _thinkingconfig.getOpenAIReasoningEffort.call(void 0, options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
@@ -5961,7 +6056,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _274 => _274.onError, 'optionalCall', _275 => _275(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _283 => _283.onError, 'optionalCall', _284 => _284(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai", {
@@ -5971,7 +6066,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     onVideo: callbacks.onVideo,
     onError: callbacks.onError
   });
-  _optionalChain([callbacks, 'access', _276 => _276.onDone, 'optionalCall', _277 => _277(
+  _optionalChain([callbacks, 'access', _285 => _285.onDone, 'optionalCall', _286 => _286(
     {
       id: messageId,
       role: "assistant",
@@ -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 = _nullishCoalesce(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" ? _thinkingconfig.buildAnthropicThinking.call(void 0, 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 = _chunkGDIXXKF2cjs.convertOpenAIToAnthropic.call(void 0, 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;
     }
   }
@@ -6043,7 +6141,7 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   logger.info("Streaming Anthropic completion request", {
     url: apiUrl,
     model: anthropicRequest.model,
-    messagesCount: _optionalChain([anthropicRequest, 'access', _278 => _278.messages, 'optionalAccess', _279 => _279.length]),
+    messagesCount: _optionalChain([anthropicRequest, 'access', _287 => _287.messages, 'optionalAccess', _288 => _288.length]),
     max_tokens: anthropicRequest.max_tokens,
     temperature: anthropicRequest.temperature,
     stream: anthropicRequest.stream,
@@ -6060,7 +6158,7 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   if (!response.ok) {
     const errorText = await response.text();
     logger.error("Anthropic API error", void 0, { status: response.status, errorText });
-    _optionalChain([callbacks, 'access', _280 => _280.onError, 'optionalCall', _281 => _281(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _289 => _289.onError, 'optionalCall', _290 => _290(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "anthropic", {
@@ -6071,10 +6169,10 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   });
   logger.info("Anthropic stream complete", {
     contentLength: result.content.length,
-    reasoningLength: _optionalChain([result, 'access', _282 => _282.reasoning, 'optionalAccess', _283 => _283.length]) || 0,
+    reasoningLength: _optionalChain([result, 'access', _291 => _291.reasoning, 'optionalAccess', _292 => _292.length]) || 0,
     blocksCount: result.blocks.length
   });
-  _optionalChain([callbacks, 'access', _284 => _284.onDone, 'optionalCall', _285 => _285(
+  _optionalChain([callbacks, 'access', _293 => _293.onDone, 'optionalCall', _294 => _294(
     {
       id: messageId,
       role: "assistant",
@@ -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) {
@@ -6130,7 +6230,7 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
   if (!response.ok) {
     const errorText = await response.text();
     logger.error("Gemini API error", void 0, { status: response.status, errorText });
-    _optionalChain([callbacks, 'access', _286 => _286.onError, 'optionalCall', _287 => _287(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _295 => _295.onError, 'optionalCall', _296 => _296(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "gemini", {
@@ -6139,7 +6239,7 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
     onError: callbacks.onError
   });
   logger.info("Gemini stream complete", { contentLength: result.content.length });
-  _optionalChain([callbacks, 'access', _288 => _288.onDone, 'optionalCall', _289 => _289(
+  _optionalChain([callbacks, 'access', _297 => _297.onDone, 'optionalCall', _298 => _298(
     {
       id: messageId,
       role: "assistant",
@@ -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 = _thinkingconfig.getOpenAIReasoningEffort.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
@@ -6191,7 +6289,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _290 => _290.onError, 'optionalCall', _291 => _291(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _299 => _299.onError, 'optionalCall', _300 => _300(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai-response", {
@@ -6200,7 +6298,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
     onError: callbacks.onError
   });
   logger.info("OpenAI Response API stream complete", { contentLength: result.content.length });
-  _optionalChain([callbacks, 'access', _292 => _292.onDone, 'optionalCall', _293 => _293(
+  _optionalChain([callbacks, 'access', _301 => _301.onDone, 'optionalCall', _302 => _302(
     {
       id: messageId,
       role: "assistant",
@@ -6220,7 +6318,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
 
 
 
-
+var _thinkingconfig = require('@omnicross/contracts/thinking-config');
 async function resolveEffectiveMaxTokens(llmConfig, _getProvider, logger, _providerId, _modelId, sessionMaxTokens) {
   if (sessionMaxTokens !== void 0 && sessionMaxTokens > 0) {
     logger.debug("Using session maxTokens", { sessionMaxTokens });
@@ -6228,7 +6326,7 @@ async function resolveEffectiveMaxTokens(llmConfig, _getProvider, logger, _provi
   }
   try {
     const globalParams = await llmConfig.getGlobalModelParameters();
-    if (_optionalChain([globalParams, 'optionalAccess', _294 => _294.maxTokens, 'optionalAccess', _295 => _295.enabled]) && globalParams.maxTokens.value > 0) {
+    if (_optionalChain([globalParams, 'optionalAccess', _303 => _303.maxTokens, 'optionalAccess', _304 => _304.enabled]) && globalParams.maxTokens.value > 0) {
       logger.debug("Using global maxTokens", { maxTokens: globalParams.maxTokens.value });
       return globalParams.maxTokens.value;
     }
@@ -6256,7 +6354,7 @@ async function resolveThinkingBudget(getProvider, logger, providerId, modelId, m
   }
   const thinkingBudget = _thinkingconfig.calculateThinkingBudget.call(void 0, modelId, thinkLevel, maxTokens);
   const provider = await getProvider(providerId);
-  const providerName = _optionalChain([provider, 'optionalAccess', _296 => _296.name, 'optionalAccess', _297 => _297.toLowerCase, 'call', _298 => _298()]) || "";
+  const providerName = _optionalChain([provider, 'optionalAccess', _305 => _305.name, 'optionalAccess', _306 => _306.toLowerCase, 'call', _307 => _307()]) || "";
   const apiFormat = provider ? _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, provider) : "openai";
   if (apiFormat === "anthropic" || providerName === "anthropic" || providerName.includes("claude")) {
     const thinkingConfig = _thinkingconfig.buildAnthropicThinking.call(void 0, modelId, thinkLevel, maxTokens);
@@ -6293,7 +6391,7 @@ function logToolFormat(tools, logger) {
       tools: openaiTools.map((t) => t.function.name),
       firstTool: {
         name: firstTool.function.name,
-        description: _optionalChain([firstTool, 'access', _299 => _299.function, 'access', _300 => _300.description, 'optionalAccess', _301 => _301.slice, 'call', _302 => _302(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _308 => _308.function, 'access', _309 => _309.description, 'optionalAccess', _310 => _310.slice, 'call', _311 => _311(0, 100)]),
         parameters: firstTool.function.parameters
       }
     });
@@ -6304,7 +6402,7 @@ function logToolFormat(tools, logger) {
       tools: anthropicTools.map((t) => t.name),
       firstTool: {
         name: firstTool.name,
-        description: _optionalChain([firstTool, 'access', _303 => _303.description, 'optionalAccess', _304 => _304.slice, 'call', _305 => _305(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _312 => _312.description, 'optionalAccess', _313 => _313.slice, 'call', _314 => _314(0, 100)]),
         input_schema: firstTool.input_schema
       }
     });
@@ -6315,9 +6413,9 @@ function logToolFormat(tools, logger) {
       count: allDeclarations.length,
       tools: allDeclarations.map((t) => t.name),
       firstTool: {
-        name: _optionalChain([allDeclarations, 'access', _306 => _306[0], 'optionalAccess', _307 => _307.name]),
-        description: _optionalChain([allDeclarations, 'access', _308 => _308[0], 'optionalAccess', _309 => _309.description, 'optionalAccess', _310 => _310.slice, 'call', _311 => _311(0, 100)]),
-        parameters: _optionalChain([allDeclarations, 'access', _312 => _312[0], 'optionalAccess', _313 => _313.parameters])
+        name: _optionalChain([allDeclarations, 'access', _315 => _315[0], 'optionalAccess', _316 => _316.name]),
+        description: _optionalChain([allDeclarations, 'access', _317 => _317[0], 'optionalAccess', _318 => _318.description, 'optionalAccess', _319 => _319.slice, 'call', _320 => _320(0, 100)]),
+        parameters: _optionalChain([allDeclarations, 'access', _321 => _321[0], 'optionalAccess', _322 => _322.parameters])
       }
     });
   }
@@ -6351,7 +6449,7 @@ function buildToolRequest(apiFormat, conversationMessages, actualModel, options,
       // Native Anthropic Messages requires this field. Resolve an absent
       // caller cap to the model's real ceiling rather than a small constant —
       // see `resolveAnthropicMaxTokens`.
-      max_tokens: _chunkOXHNSZ53cjs.resolveAnthropicMaxTokens.call(void 0, actualModel, options.maxTokens),
+      max_tokens: _chunkZQQUD66Mcjs.resolveAnthropicMaxTokens.call(void 0, actualModel, options.maxTokens),
       temperature: _nullishCoalesce(options.temperature, () => ( 0.7)),
       stream: true,
       tools: options.tools
@@ -6380,7 +6478,7 @@ function buildToolRequest(apiFormat, conversationMessages, actualModel, options,
 function extractDeltaContent(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _314 => _314.candidates, 'optionalAccess', _315 => _315[0], 'optionalAccess', _316 => _316.content, 'optionalAccess', _317 => _317.parts]) || [];
+    const parts = _optionalChain([json, 'access', _323 => _323.candidates, 'optionalAccess', _324 => _324[0], 'optionalAccess', _325 => _325.content, 'optionalAccess', _326 => _326.parts]) || [];
     let text = "";
     for (const part of parts) {
       if (part.thought === true) continue;
@@ -6388,15 +6486,15 @@ function extractDeltaContent(rawJson, apiFormat) {
     }
     return text;
   } else if (apiFormat === "anthropic") {
-    return _optionalChain([json, 'access', _318 => _318.delta, 'optionalAccess', _319 => _319.text]) || "";
+    return _optionalChain([json, 'access', _327 => _327.delta, 'optionalAccess', _328 => _328.text]) || "";
   } else {
-    return _optionalChain([json, 'access', _320 => _320.choices, 'optionalAccess', _321 => _321[0], 'optionalAccess', _322 => _322.delta, 'optionalAccess', _323 => _323.content]) || "";
+    return _optionalChain([json, 'access', _329 => _329.choices, 'optionalAccess', _330 => _330[0], 'optionalAccess', _331 => _331.delta, 'optionalAccess', _332 => _332.content]) || "";
   }
 }
 function extractDeltaReasoning(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _324 => _324.candidates, 'optionalAccess', _325 => _325[0], 'optionalAccess', _326 => _326.content, 'optionalAccess', _327 => _327.parts]) || [];
+    const parts = _optionalChain([json, 'access', _333 => _333.candidates, 'optionalAccess', _334 => _334[0], 'optionalAccess', _335 => _335.content, 'optionalAccess', _336 => _336.parts]) || [];
     let reasoning = "";
     for (const part of parts) {
       if (part.thought === true && part.text) reasoning += part.text;
@@ -6405,14 +6503,14 @@ function extractDeltaReasoning(rawJson, apiFormat) {
   } else if (apiFormat === "anthropic") {
     return "";
   } else {
-    const delta = _optionalChain([json, 'access', _328 => _328.choices, 'optionalAccess', _329 => _329[0], 'optionalAccess', _330 => _330.delta]);
-    return (_optionalChain([delta, 'optionalAccess', _331 => _331.thinking, 'optionalAccess', _332 => _332.content]) || "") + (_optionalChain([delta, 'optionalAccess', _333 => _333.reasoning_content]) || "");
+    const delta = _optionalChain([json, 'access', _337 => _337.choices, 'optionalAccess', _338 => _338[0], 'optionalAccess', _339 => _339.delta]);
+    return (_optionalChain([delta, 'optionalAccess', _340 => _340.thinking, 'optionalAccess', _341 => _341.content]) || "") + (_optionalChain([delta, 'optionalAccess', _342 => _342.reasoning_content]) || "");
   }
 }
 function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pendingOpenAIToolCalls) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _334 => _334.candidates, 'optionalAccess', _335 => _335[0], 'optionalAccess', _336 => _336.content, 'optionalAccess', _337 => _337.parts]) || [];
+    const parts = _optionalChain([json, 'access', _343 => _343.candidates, 'optionalAccess', _344 => _344[0], 'optionalAccess', _345 => _345.content, 'optionalAccess', _346 => _346.parts]) || [];
     for (const part of parts) {
       if (part.functionCall) {
         logger.info("Function call detected", { functionCall: part.functionCall });
@@ -6422,13 +6520,13 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           args: part.functionCall.args || {}
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _338 => _338.onToolCall, 'optionalCall', _339 => _339(toolCall)]);
+        _optionalChain([callbacks, 'access', _347 => _347.onToolCall, 'optionalCall', _348 => _348(toolCall)]);
         logger.info("Tool called", { toolName: toolCall.name });
       }
     }
   } else if (apiFormat !== "anthropic") {
-    const delta = _optionalChain([json, 'access', _340 => _340.choices, 'optionalAccess', _341 => _341[0], 'optionalAccess', _342 => _342.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _343 => _343.tool_calls]) && pendingOpenAIToolCalls) {
+    const delta = _optionalChain([json, 'access', _349 => _349.choices, 'optionalAccess', _350 => _350[0], 'optionalAccess', _351 => _351.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _352 => _352.tool_calls]) && pendingOpenAIToolCalls) {
       for (const tc of delta.tool_calls) {
         const index = _nullishCoalesce(tc.index, () => ( 0));
         let pending = pendingOpenAIToolCalls.get(index);
@@ -6437,8 +6535,8 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           pendingOpenAIToolCalls.set(index, pending);
         }
         if (tc.id) pending.id = tc.id;
-        if (_optionalChain([tc, 'access', _344 => _344.function, 'optionalAccess', _345 => _345.name])) pending.name += tc.function.name;
-        if (_optionalChain([tc, 'access', _346 => _346.function, 'optionalAccess', _347 => _347.arguments])) pending.arguments += tc.function.arguments;
+        if (_optionalChain([tc, 'access', _353 => _353.function, 'optionalAccess', _354 => _354.name])) pending.name += tc.function.name;
+        if (_optionalChain([tc, 'access', _355 => _355.function, 'optionalAccess', _356 => _356.arguments])) pending.arguments += tc.function.arguments;
       }
     }
   }
@@ -6453,7 +6551,7 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
           args: JSON.parse(pending.arguments || "{}")
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _348 => _348.onToolCall, 'optionalCall', _349 => _349(toolCall)]);
+        _optionalChain([callbacks, 'access', _357 => _357.onToolCall, 'optionalCall', _358 => _358(toolCall)]);
         logger.info("Tool called (OpenAI)", { toolName: toolCall.name, args: toolCall.args });
       } catch (e) {
         logger.error("Failed to parse OpenAI tool call arguments", e instanceof Error ? e : void 0, {
@@ -6467,38 +6565,38 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
 function parseStreamChunk(rawJson, apiFormat, callbacks, logger) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const candidate = _optionalChain([json, 'access', _350 => _350.candidates, 'optionalAccess', _351 => _351[0]]);
+    const candidate = _optionalChain([json, 'access', _359 => _359.candidates, 'optionalAccess', _360 => _360[0]]);
     if (!candidate) {
       logger.warn("No candidate found in Gemini response");
       return;
     }
-    const parts = _optionalChain([candidate, 'access', _352 => _352.content, 'optionalAccess', _353 => _353.parts]) || [];
+    const parts = _optionalChain([candidate, 'access', _361 => _361.content, 'optionalAccess', _362 => _362.parts]) || [];
     for (const part of parts) {
       if (part.thought === true && part.text) {
-        _optionalChain([callbacks, 'access', _354 => _354.onReasoning, 'optionalCall', _355 => _355(part.text)]);
+        _optionalChain([callbacks, 'access', _363 => _363.onReasoning, 'optionalCall', _364 => _364(part.text)]);
         continue;
       } else if (part.thoughtSignature && !part.thought) {
         logger.debug("Gemini returned thoughtSignature without thought content");
       }
       if (part.text) {
-        _optionalChain([callbacks, 'access', _356 => _356.onDelta, 'optionalCall', _357 => _357(part.text)]);
+        _optionalChain([callbacks, 'access', _365 => _365.onDelta, 'optionalCall', _366 => _366(part.text)]);
       }
     }
   } else if (apiFormat === "anthropic") {
     const delta = json.delta;
-    if (_optionalChain([delta, 'optionalAccess', _358 => _358.text])) {
-      _optionalChain([callbacks, 'access', _359 => _359.onDelta, 'optionalCall', _360 => _360(delta.text)]);
+    if (_optionalChain([delta, 'optionalAccess', _367 => _367.text])) {
+      _optionalChain([callbacks, 'access', _368 => _368.onDelta, 'optionalCall', _369 => _369(delta.text)]);
     }
   } else {
-    const delta = _optionalChain([json, 'access', _361 => _361.choices, 'optionalAccess', _362 => _362[0], 'optionalAccess', _363 => _363.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _364 => _364.content])) {
-      _optionalChain([callbacks, 'access', _365 => _365.onDelta, 'optionalCall', _366 => _366(delta.content)]);
+    const delta = _optionalChain([json, 'access', _370 => _370.choices, 'optionalAccess', _371 => _371[0], 'optionalAccess', _372 => _372.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _373 => _373.content])) {
+      _optionalChain([callbacks, 'access', _374 => _374.onDelta, 'optionalCall', _375 => _375(delta.content)]);
     }
-    if (_optionalChain([delta, 'optionalAccess', _367 => _367.thinking, 'optionalAccess', _368 => _368.content])) {
-      _optionalChain([callbacks, 'access', _369 => _369.onReasoning, 'optionalCall', _370 => _370(delta.thinking.content)]);
+    if (_optionalChain([delta, 'optionalAccess', _376 => _376.thinking, 'optionalAccess', _377 => _377.content])) {
+      _optionalChain([callbacks, 'access', _378 => _378.onReasoning, 'optionalCall', _379 => _379(delta.thinking.content)]);
     }
-    if (_optionalChain([delta, 'optionalAccess', _371 => _371.reasoning_content])) {
-      _optionalChain([callbacks, 'access', _372 => _372.onReasoning, 'optionalCall', _373 => _373(delta.reasoning_content)]);
+    if (_optionalChain([delta, 'optionalAccess', _380 => _380.reasoning_content])) {
+      _optionalChain([callbacks, 'access', _381 => _381.onReasoning, 'optionalCall', _382 => _382(delta.reasoning_content)]);
     }
   }
 }
@@ -6511,7 +6609,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content: reasoning
     };
     blocks.push(thinkingBlock);
-    _optionalChain([callbacks, 'access', _374 => _374.onBlock, 'optionalCall', _375 => _375(thinkingBlock)]);
+    _optionalChain([callbacks, 'access', _383 => _383.onBlock, 'optionalCall', _384 => _384(thinkingBlock)]);
   }
   if (content && content.trim()) {
     const textBlock = {
@@ -6520,7 +6618,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content
     };
     blocks.push(textBlock);
-    _optionalChain([callbacks, 'access', _376 => _376.onBlock, 'optionalCall', _377 => _377(textBlock)]);
+    _optionalChain([callbacks, 'access', _385 => _385.onBlock, 'optionalCall', _386 => _386(textBlock)]);
   }
 }
 async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
@@ -6535,7 +6633,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
       status: "running"
     };
     blocks.push(toolUseBlock);
-    _optionalChain([callbacks, 'access', _378 => _378.onBlock, 'optionalCall', _379 => _379(toolUseBlock)]);
+    _optionalChain([callbacks, 'access', _387 => _387.onBlock, 'optionalCall', _388 => _388(toolUseBlock)]);
     try {
       logger.info("Executing tool", { toolName: toolCall.name });
       const mcpTool = mcpTools.find((t) => t.id === toolCall.name);
@@ -6558,8 +6656,8 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         result = { isError: true, content: [{ type: "text", text: "MCP service not available" }] };
       }
       logger.info("Tool result received", { result });
-      _optionalChain([callbacks, 'access', _380 => _380.onToolResult, 'optionalCall', _381 => _381(toolCall.id, result)]);
-      const resultText = _optionalChain([result, 'access', _382 => _382.content, 'optionalAccess', _383 => _383[0], 'optionalAccess', _384 => _384.text]) || JSON.stringify(result);
+      _optionalChain([callbacks, 'access', _389 => _389.onToolResult, 'optionalCall', _390 => _390(toolCall.id, result)]);
+      const resultText = _optionalChain([result, 'access', _391 => _391.content, 'optionalAccess', _392 => _392[0], 'optionalAccess', _393 => _393.text]) || JSON.stringify(result);
       const toolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -6569,11 +6667,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: result.isError
       };
       blocks.push(toolResultBlock);
-      _optionalChain([callbacks, 'access', _385 => _385.onBlock, 'optionalCall', _386 => _386(toolResultBlock)]);
+      _optionalChain([callbacks, 'access', _394 => _394.onBlock, 'optionalCall', _395 => _395(toolResultBlock)]);
       const toolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
       if (toolUseBlockRef && toolUseBlockRef.type === "tool_use") {
         toolUseBlockRef.status = result.isError ? "error" : "completed";
-        _optionalChain([callbacks, 'access', _387 => _387.onBlock, 'optionalCall', _388 => _388({ ...toolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _396 => _396.onBlock, 'optionalCall', _397 => _397({ ...toolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result });
     } catch (error) {
@@ -6583,7 +6681,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true,
         content: [{ type: "text", text: `Error: ${errorMessage}` }]
       };
-      _optionalChain([callbacks, 'access', _389 => _389.onToolResult, 'optionalCall', _390 => _390(toolCall.id, errorResult)]);
+      _optionalChain([callbacks, 'access', _398 => _398.onToolResult, 'optionalCall', _399 => _399(toolCall.id, errorResult)]);
       const errorToolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -6593,11 +6691,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true
       };
       blocks.push(errorToolResultBlock);
-      _optionalChain([callbacks, 'access', _391 => _391.onBlock, 'optionalCall', _392 => _392(errorToolResultBlock)]);
+      _optionalChain([callbacks, 'access', _400 => _400.onBlock, 'optionalCall', _401 => _401(errorToolResultBlock)]);
       const errorToolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
       if (errorToolUseBlockRef && errorToolUseBlockRef.type === "tool_use") {
         errorToolUseBlockRef.status = "error";
-        _optionalChain([callbacks, 'access', _393 => _393.onBlock, 'optionalCall', _394 => _394({ ...errorToolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _402 => _402.onBlock, 'optionalCall', _403 => _403({ ...errorToolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result: errorResult });
     }
@@ -6607,7 +6705,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
 function mapToolArguments(args, mcpTool, logger) {
   const mappedArgs = { ...args };
   const toolSchema = mcpTool.inputSchema;
-  if (_optionalChain([toolSchema, 'optionalAccess', _395 => _395.properties])) {
+  if (_optionalChain([toolSchema, 'optionalAccess', _404 => _404.properties])) {
     const expectedParams = Object.keys(toolSchema.properties);
     const paramMappings = {
       "search_query": ["query", "q", "searchQuery", "search"],
@@ -6641,25 +6739,25 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _396 => _396.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _397 => _397.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _405 => _405.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _406 => _406.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _398 => _398.onError, 'optionalCall', _399 => _399(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _407 => _407.onError, 'optionalCall', _408 => _408(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _400 => _400.onError, 'optionalCall', _401 => _401(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _409 => _409.onError, 'optionalCall', _410 => _410(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _402 => _402.onError, 'optionalCall', _403 => _403("API key not configured")]);
+      _optionalChain([callbacks, 'access', _411 => _411.onError, 'optionalCall', _412 => _412("API key not configured")]);
       return;
     }
     const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    _optionalChain([callbacks, 'access', _404 => _404.onStart, 'optionalCall', _405 => _405(messageId)]);
+    _optionalChain([callbacks, 'access', _413 => _413.onStart, 'optionalCall', _414 => _414(messageId)]);
     const globalParams = await llmConfig.getGlobalModelParameters();
     const MAX_ITERATIONS = _nullishCoalesce(globalParams.toolMaxTurns, () => ( 100));
     let iteration = 0;
@@ -6706,12 +6804,12 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       });
       if (!response.ok) {
         const errorText = await response.text();
-        _optionalChain([callbacks, 'access', _406 => _406.onError, 'optionalCall', _407 => _407(`API error (${response.status}): ${errorText}`)]);
+        _optionalChain([callbacks, 'access', _415 => _415.onError, 'optionalCall', _416 => _416(`API error (${response.status}): ${errorText}`)]);
         return;
       }
-      const reader = _optionalChain([response, 'access', _408 => _408.body, 'optionalAccess', _409 => _409.getReader, 'call', _410 => _410()]);
+      const reader = _optionalChain([response, 'access', _417 => _417.body, 'optionalAccess', _418 => _418.getReader, 'call', _419 => _419()]);
       if (!reader) {
-        _optionalChain([callbacks, 'access', _411 => _411.onError, 'optionalCall', _412 => _412("No response body")]);
+        _optionalChain([callbacks, 'access', _420 => _420.onError, 'optionalCall', _421 => _421("No response body")]);
         return;
       }
       const decoder = new TextDecoder();
@@ -6744,7 +6842,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
                 logger.debug("Parsed JSON", { json });
                 if (json.error) {
                   logger.error("API Error", void 0, { error: json.error });
-                  _optionalChain([callbacks, 'access', _413 => _413.onError, 'optionalCall', _414 => _414(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
+                  _optionalChain([callbacks, 'access', _422 => _422.onError, 'optionalCall', _423 => _423(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
                   return;
                 }
                 parseStreamChunk(json, apiFormat, callbacks, logger);
@@ -6777,7 +6875,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
           toolCallsLength: toolCalls.length,
           executableToolCallsLength: executableToolCalls.length,
           hasMcpTools: !!options.mcpTools,
-          mcpToolsLength: _optionalChain([options, 'access', _415 => _415.mcpTools, 'optionalAccess', _416 => _416.length]),
+          mcpToolsLength: _optionalChain([options, 'access', _424 => _424.mcpTools, 'optionalAccess', _425 => _425.length]),
           hasMcpService: !!mcpService
         });
         if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
@@ -6798,7 +6896,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
             builtinExecutor
           );
           const toolResultsText = toolResults.map(({ toolCall, result }) => {
-            const resultText = typeof result === "string" ? result : _optionalChain([result, 'access', _417 => _417.content, 'optionalAccess', _418 => _418[0], 'optionalAccess', _419 => _419.text]) || JSON.stringify(result);
+            const resultText = typeof result === "string" ? result : _optionalChain([result, 'access', _426 => _426.content, 'optionalAccess', _427 => _427[0], 'optionalAccess', _428 => _428.text]) || JSON.stringify(result);
             return `Tool ${toolCall.name} result:
 ${resultText}`;
           }).join("\n\n");
@@ -6816,12 +6914,12 @@ ${resultText}`;
         }
       } catch (streamError) {
         logger.error("Stream processing error", streamError instanceof Error ? streamError : void 0);
-        _optionalChain([callbacks, 'access', _420 => _420.onError, 'optionalCall', _421 => _421(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
+        _optionalChain([callbacks, 'access', _429 => _429.onError, 'optionalCall', _430 => _430(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
         return;
       }
     }
     logger.info("Sending final callback", { blocksCount: blocks.length });
-    _optionalChain([callbacks, 'access', _422 => _422.onDone, 'optionalCall', _423 => _423({
+    _optionalChain([callbacks, 'access', _431 => _431.onDone, 'optionalCall', _432 => _432({
       id: messageId,
       role: "assistant",
       content: finalContent,
@@ -6832,7 +6930,7 @@ ${resultText}`;
   } catch (error) {
     logger.error("Error in streamWithTools", error instanceof Error ? error : void 0);
     const message = error instanceof Error ? error.message : "Unknown error";
-    _optionalChain([callbacks, 'access', _424 => _424.onError, 'optionalCall', _425 => _425(message)]);
+    _optionalChain([callbacks, 'access', _433 => _433.onError, 'optionalCall', _434 => _434(message)]);
   }
 }
 
@@ -6883,8 +6981,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _426 => _426.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _427 => _427.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _435 => _435.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _436 => _436.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
       return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -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 _chunkMUHWHQVMcjs.executeProviderCall.call(void 0, {
@@ -6960,18 +7059,18 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       { endpointTransformer: void 0 }
     );
     const data = await transformedResponse.json();
-    const choice = _optionalChain([data, 'access', _428 => _428.choices, 'optionalAccess', _429 => _429[0]]);
+    const choice = _optionalChain([data, 'access', _437 => _437.choices, 'optionalAccess', _438 => _438[0]]);
     if (!choice) {
       return { success: false, error: "No choices in response" };
     }
-    const rawToolCalls = _optionalChain([choice, 'access', _430 => _430.message, 'optionalAccess', _431 => _431.tool_calls]);
-    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _432 => _432.map, 'call', _433 => _433((tc) => ({
+    const rawToolCalls = _optionalChain([choice, 'access', _439 => _439.message, 'optionalAccess', _440 => _440.tool_calls]);
+    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _441 => _441.map, 'call', _442 => _442((tc) => ({
       id: tc.id,
       name: tc.function.name,
       args: typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments
     }))]);
     const tapped = readUsageFromOpenAIResponse(data.usage);
-    if (_optionalChain([recording, 'optionalAccess', _434 => _434.recorder]) && tapped) {
+    if (_optionalChain([recording, 'optionalAccess', _443 => _443.recorder]) && tapped) {
       recording.recorder.record({
         messageId: _nullishCoalesce(options.messageId, () => ( null)),
         parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -6989,9 +7088,9 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       message: {
         id: `msg_${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice, 'access', _435 => _435.message, 'optionalAccess', _436 => _436.content]) || "",
+        content: _optionalChain([choice, 'access', _444 => _444.message, 'optionalAccess', _445 => _445.content]) || "",
         timestamp: Date.now(),
-        thinking: data.reasoning_content || _optionalChain([choice, 'access', _437 => _437.message, 'optionalAccess', _438 => _438.thinking, 'optionalAccess', _439 => _439.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _440 => _440.message, 'optionalAccess', _441 => _441.thinking, 'optionalAccess', _442 => _442.content]) || "", signature: _optionalChain([choice, 'access', _443 => _443.message, 'optionalAccess', _444 => _444.thinking, 'optionalAccess', _445 => _445.signature]) } : void 0,
+        thinking: data.reasoning_content || _optionalChain([choice, 'access', _446 => _446.message, 'optionalAccess', _447 => _447.thinking, 'optionalAccess', _448 => _448.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _449 => _449.message, 'optionalAccess', _450 => _450.thinking, 'optionalAccess', _451 => _451.content]) || "", signature: _optionalChain([choice, 'access', _452 => _452.message, 'optionalAccess', _453 => _453.thinking, 'optionalAccess', _454 => _454.signature]) } : void 0,
         toolCalls
       },
       usage: data.usage ? {
@@ -7012,21 +7111,21 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _446 => _446.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _447 => _447.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _455 => _455.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _456 => _456.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _448 => _448.onError, 'optionalCall', _449 => _449(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _457 => _457.onError, 'optionalCall', _458 => _458(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _450 => _450.onError, 'optionalCall', _451 => _451(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _459 => _459.onError, 'optionalCall', _460 => _460(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _452 => _452.onError, 'optionalCall', _453 => _453("API key not configured")]);
+      _optionalChain([callbacks, 'access', _461 => _461.onError, 'optionalCall', _462 => _462("API key not configured")]);
       return;
     }
     const { chain, hasTransformers } = await resolveChainWithMain(
@@ -7038,13 +7137,14 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       return completeStreamFallback(options, callbacks);
     }
     const messageId = `msg_${Date.now()}`;
-    _optionalChain([callbacks, 'access', _454 => _454.onStart, 'optionalCall', _455 => _455(messageId)]);
+    _optionalChain([callbacks, 'access', _463 => _463.onStart, 'optionalCall', _464 => _464(messageId)]);
     const unifiedRequest = buildUnifiedCompletionRequest(actualModel, options, true);
     const transformerProvider = {
       name: provider.name,
       baseUrl: provider.api_base_url,
       apiKey,
-      models: provider.models || []
+      models: provider.models || [],
+      modelConfigs: provider.modelConfigs
     };
     const executor = getSharedExecutor2();
     const { response } = await _chunkMUHWHQVMcjs.executeProviderCall.call(void 0, {
@@ -7077,7 +7177,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     });
     if (!response.ok) {
       const errorText = await response.text();
-      _optionalChain([callbacks, 'access', _456 => _456.onError, 'optionalCall', _457 => _457(`API error (${response.status}): ${errorText}`)]);
+      _optionalChain([callbacks, 'access', _465 => _465.onError, 'optionalCall', _466 => _466(`API error (${response.status}): ${errorText}`)]);
       return;
     }
     const transformedResponse = await executor.executeResponseChain(
@@ -7087,9 +7187,9 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       chain,
       { endpointTransformer: void 0 }
     );
-    const reader = _optionalChain([transformedResponse, 'access', _458 => _458.body, 'optionalAccess', _459 => _459.getReader, 'call', _460 => _460()]);
+    const reader = _optionalChain([transformedResponse, 'access', _467 => _467.body, 'optionalAccess', _468 => _468.getReader, 'call', _469 => _469()]);
     if (!reader) {
-      _optionalChain([callbacks, 'access', _461 => _461.onError, 'optionalCall', _462 => _462("No response body")]);
+      _optionalChain([callbacks, 'access', _470 => _470.onError, 'optionalCall', _471 => _471("No response body")]);
       return;
     }
     const decoder = new TextDecoder();
@@ -7107,22 +7207,22 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
             if (data === "[DONE]") continue;
             try {
               const json = JSON.parse(data);
-              const delta = _optionalChain([json, 'access', _463 => _463.choices, 'optionalAccess', _464 => _464[0], 'optionalAccess', _465 => _465.delta]);
-              if (_optionalChain([delta, 'optionalAccess', _466 => _466.content])) {
+              const delta = _optionalChain([json, 'access', _472 => _472.choices, 'optionalAccess', _473 => _473[0], 'optionalAccess', _474 => _474.delta]);
+              if (_optionalChain([delta, 'optionalAccess', _475 => _475.content])) {
                 content += delta.content;
-                _optionalChain([callbacks, 'access', _467 => _467.onDelta, 'optionalCall', _468 => _468(delta.content)]);
+                _optionalChain([callbacks, 'access', _476 => _476.onDelta, 'optionalCall', _477 => _477(delta.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _469 => _469.thinking, 'optionalAccess', _470 => _470.content])) {
+              if (_optionalChain([delta, 'optionalAccess', _478 => _478.thinking, 'optionalAccess', _479 => _479.content])) {
                 reasoning += delta.thinking.content;
-                _optionalChain([callbacks, 'access', _471 => _471.onReasoning, 'optionalCall', _472 => _472(delta.thinking.content)]);
+                _optionalChain([callbacks, 'access', _480 => _480.onReasoning, 'optionalCall', _481 => _481(delta.thinking.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _473 => _473.reasoning_content])) {
+              if (_optionalChain([delta, 'optionalAccess', _482 => _482.reasoning_content])) {
                 reasoning += delta.reasoning_content;
-                _optionalChain([callbacks, 'access', _474 => _474.onReasoning, 'optionalCall', _475 => _475(delta.reasoning_content)]);
+                _optionalChain([callbacks, 'access', _483 => _483.onReasoning, 'optionalCall', _484 => _484(delta.reasoning_content)]);
               }
               if (json.usage) {
                 const tapped = readUsageFromOpenAIResponse(json.usage);
-                if (_optionalChain([recording, 'optionalAccess', _476 => _476.recorder]) && tapped) {
+                if (_optionalChain([recording, 'optionalAccess', _485 => _485.recorder]) && tapped) {
                   recording.recorder.record({
                     messageId: _nullishCoalesce(options.messageId, () => ( null)),
                     parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -7135,7 +7235,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
                     rawUsage: json.usage
                   });
                 }
-                _optionalChain([callbacks, 'access', _477 => _477.onDone, 'optionalCall', _478 => _478(
+                _optionalChain([callbacks, 'access', _486 => _486.onDone, 'optionalCall', _487 => _487(
                   {
                     id: messageId,
                     role: "assistant",
@@ -7156,7 +7256,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
           }
         }
       }
-      _optionalChain([callbacks, 'access', _479 => _479.onDone, 'optionalCall', _480 => _480({
+      _optionalChain([callbacks, 'access', _488 => _488.onDone, 'optionalCall', _489 => _489({
         id: messageId,
         role: "assistant",
         content,
@@ -7168,7 +7268,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    _optionalChain([callbacks, 'access', _481 => _481.onError, 'optionalCall', _482 => _482(message)]);
+    _optionalChain([callbacks, 'access', _490 => _490.onError, 'optionalCall', _491 => _491(message)]);
   }
 }
 
@@ -7235,8 +7335,8 @@ var CompletionService = (_class15 = class {
         options.providerId,
         options.model
       );
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _483 => _483.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _484 => _484.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _492 => _492.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _493 => _493.actualModelId]) || options.model;
       const provider = await this.getProvider(actualProviderId);
       if (!provider) {
         return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -7269,7 +7369,7 @@ var CompletionService = (_class15 = class {
         this.apiKeyPool.reportSuccess(options.sessionId);
       }
       if (result.success && result.usage && options.sessionId) {
-        _optionalChain([this, 'access', _485 => _485.usageEventSink, 'optionalAccess', _486 => _486.emit, 'call', _487 => _487({
+        _optionalChain([this, 'access', _494 => _494.usageEventSink, 'optionalAccess', _495 => _495.emit, 'call', _496 => _496({
           sessionId: options.sessionId,
           modelId: actualModel,
           usage: result.usage,
@@ -7298,8 +7398,8 @@ var CompletionService = (_class15 = class {
         options.model
       );
       this.logger.debug("Resolved routed model", { routedInfo });
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _488 => _488.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _489 => _489.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _497 => _497.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _498 => _498.actualModelId]) || options.model;
       this.logger.debug("Resolved provider and model", { actualProviderId, actualModel });
       const provider = await this.getProvider(actualProviderId);
       this.logger.debug("Retrieved provider", provider ? {
@@ -7311,22 +7411,22 @@ var CompletionService = (_class15 = class {
         enabled: provider.enabled
       } : { error: "Provider not found" });
       if (!provider) {
-        _optionalChain([callbacks, 'access', _490 => _490.onError, 'optionalCall', _491 => _491(`Provider not found: ${actualProviderId}`)]);
+        _optionalChain([callbacks, 'access', _499 => _499.onError, 'optionalCall', _500 => _500(`Provider not found: ${actualProviderId}`)]);
         return;
       }
       if (!provider.enabled) {
-        _optionalChain([callbacks, 'access', _492 => _492.onError, 'optionalCall', _493 => _493(`Provider is disabled: ${provider.name}`)]);
+        _optionalChain([callbacks, 'access', _501 => _501.onError, 'optionalCall', _502 => _502(`Provider is disabled: ${provider.name}`)]);
         return;
       }
       const apiKey = await this.resolveApiKeyForRequest(provider, actualProviderId, options.sessionId);
       if (!apiKey) {
-        _optionalChain([callbacks, 'access', _494 => _494.onError, 'optionalCall', _495 => _495("API key not configured")]);
+        _optionalChain([callbacks, 'access', _503 => _503.onError, 'optionalCall', _504 => _504("API key not configured")]);
         return;
       }
       const apiFormat = _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, provider);
       this.logger.info("Using API format for stream", { apiFormat });
       const messageId = `msg_${Date.now()}`;
-      _optionalChain([callbacks, 'access', _496 => _496.onStart, 'optionalCall', _497 => _497(messageId)]);
+      _optionalChain([callbacks, 'access', _505 => _505.onStart, 'optionalCall', _506 => _506(messageId)]);
       const resolvedOptions = { ...options, model: actualModel };
       if (options.sessionId) {
         const sid = options.sessionId;
@@ -7335,14 +7435,14 @@ var CompletionService = (_class15 = class {
           ...callbacks,
           onDone: (message, usage, metrics) => {
             if (usage) {
-              _optionalChain([this, 'access', _498 => _498.usageEventSink, 'optionalAccess', _499 => _499.emit, 'call', _500 => _500({
+              _optionalChain([this, 'access', _507 => _507.usageEventSink, 'optionalAccess', _508 => _508.emit, 'call', _509 => _509({
                 sessionId: sid,
                 modelId: actualModel,
                 usage,
                 engineOrigin: "completion"
               })]);
             }
-            _optionalChain([userOnDone, 'optionalCall', _501 => _501(message, usage, metrics)]);
+            _optionalChain([userOnDone, 'optionalCall', _510 => _510(message, usage, metrics)]);
           }
         };
       }
@@ -7358,11 +7458,11 @@ var CompletionService = (_class15 = class {
               retryState.error = { status, message: error };
               return;
             }
-            _optionalChain([callbacks, 'access', _502 => _502.onError, 'optionalCall', _503 => _503(error)]);
+            _optionalChain([callbacks, 'access', _511 => _511.onError, 'optionalCall', _512 => _512(error)]);
           },
           onDone: (message, usage, metrics) => {
             this.apiKeyPool.reportSuccess(options.sessionId);
-            _optionalChain([callbacks, 'access', _504 => _504.onDone, 'optionalCall', _505 => _505(message, usage, metrics)]);
+            _optionalChain([callbacks, 'access', _513 => _513.onDone, 'optionalCall', _514 => _514(message, usage, metrics)]);
           }
         };
         await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
@@ -7383,7 +7483,7 @@ var CompletionService = (_class15 = class {
               // don't fire onStart again
             });
           } else {
-            _optionalChain([callbacks, 'access', _506 => _506.onError, 'optionalCall', _507 => _507(retryState.error.message)]);
+            _optionalChain([callbacks, 'access', _515 => _515.onError, 'optionalCall', _516 => _516(retryState.error.message)]);
           }
         }
       } else {
@@ -7396,7 +7496,7 @@ var CompletionService = (_class15 = class {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       this.logger.error("Stream completion error", error instanceof Error ? error : void 0, { message });
-      _optionalChain([callbacks, 'access', _508 => _508.onError, 'optionalCall', _509 => _509(message)]);
+      _optionalChain([callbacks, 'access', _517 => _517.onError, 'optionalCall', _518 => _518(message)]);
     }
   }
   /**
@@ -7436,7 +7536,7 @@ var CompletionService = (_class15 = class {
         return {
           success: true,
           message: "Connection successful",
-          response: _optionalChain([result, 'access', _510 => _510.message, 'optionalAccess', _511 => _511.content]) || "",
+          response: _optionalChain([result, 'access', _519 => _519.message, 'optionalAccess', _520 => _520.content]) || "",
           model: modelId,
           durationMs
         };
@@ -7501,7 +7601,7 @@ ${description}`;
    * 3. Legacy single key from provider config
    */
   async resolveApiKeyForRequest(provider, providerId, sessionId) {
-    if (_optionalChain([provider, 'access', _512 => _512.codingPlan, 'optionalAccess', _513 => _513.enabled]) && provider.codingPlan.apiKey) {
+    if (_optionalChain([provider, 'access', _521 => _521.codingPlan, 'optionalAccess', _522 => _522.enabled]) && provider.codingPlan.apiKey) {
       return this.resolveApiKey(provider.codingPlan.apiKey);
     }
     if (this.apiKeyPool) {