@omnicross/core 0.1.8 → 0.1.10

package/dist/{chunk-26K6T2YS.cjs → chunk-TIT74RIL.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');
@@ -36,6 +36,8 @@ var _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
 
 
 
+
+
 var _chunkJ3QQ6JS5cjs = require('./chunk-J3QQ6JS5.cjs');
 
 
@@ -104,13 +106,16 @@ var _chunkQBZJ7P2Tcjs = require('./chunk-QBZJ7P2T.cjs');
 var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
 
-var _chunkXPIOJQS2cjs = require('./chunk-XPIOJQS2.cjs');
+var _chunkUWDW6PN3cjs = require('./chunk-UWDW6PN3.cjs');
 
 
 
 var _chunkGDIXXKF2cjs = require('./chunk-GDIXXKF2.cjs');
 
 
+var _chunkAOFWNWLTcjs = require('./chunk-AOFWNWLT.cjs');
+
+
 var _chunkRJUONLUQcjs = require('./chunk-RJUONLUQ.cjs');
 
 
@@ -413,9 +418,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 +653,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 +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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: resolvedModel, stream: isStream });
   const sameFormat = route.targetProviderFormat === "anthropic" || _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, 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 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: resolvedModel, stream: isStream });
   return {
@@ -3562,6 +3568,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');
@@ -3659,7 +3666,8 @@ function normalizeAudit(raw) {
     retentionDays: Math.trunc(
       clampNumber(_optionalChain([a, 'optionalAccess', _195 => _195.retentionDays]), 1, 365, _audittypes.DEFAULT_AUDIT_CONFIG.retentionDays)
     ),
-    trustForwardedFor: _optionalChain([a, 'optionalAccess', _196 => _196.trustForwardedFor]) === true
+    compactStreamingBodies: _optionalChain([a, 'optionalAccess', _196 => _196.compactStreamingBodies]) === true,
+    trustForwardedFor: _optionalChain([a, 'optionalAccess', _197 => _197.trustForwardedFor]) === true
   };
 }
 function normalizeMaxBodyBytes(value) {
@@ -3670,26 +3678,26 @@ function normalizeMaxBodyBytes(value) {
   return Math.trunc(Math.min(1048576, value));
 }
 function normalizeBilling(raw) {
-  const b = _optionalChain([raw, 'optionalAccess', _197 => _197.billing]);
+  const b = _optionalChain([raw, 'optionalAccess', _198 => _198.billing]);
   const config = {
-    enabled: _optionalChain([b, 'optionalAccess', _198 => _198.enabled]) === true,
+    enabled: _optionalChain([b, 'optionalAccess', _199 => _199.enabled]) === true,
     maxRetryAgeMs: Math.trunc(
-      clampNumber(_optionalChain([b, 'optionalAccess', _199 => _199.maxRetryAgeMs]), 6e4, 2592e6, _billingtypes.DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
+      clampNumber(_optionalChain([b, 'optionalAccess', _200 => _200.maxRetryAgeMs]), 6e4, 2592e6, _billingtypes.DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
     )
   };
-  if (typeof _optionalChain([b, 'optionalAccess', _200 => _200.endpoint]) === "string" && b.endpoint.trim()) config.endpoint = b.endpoint.trim();
-  if (typeof _optionalChain([b, 'optionalAccess', _201 => _201.secret]) === "string" && b.secret.length > 0) config.secret = b.secret;
+  if (typeof _optionalChain([b, 'optionalAccess', _201 => _201.endpoint]) === "string" && b.endpoint.trim()) config.endpoint = b.endpoint.trim();
+  if (typeof _optionalChain([b, 'optionalAccess', _202 => _202.secret]) === "string" && b.secret.length > 0) config.secret = b.secret;
   return config;
 }
 var DEFAULT_FINGERPRINT = { enabled: false };
 function normalizeFingerprint(raw) {
-  const f = _optionalChain([raw, 'optionalAccess', _202 => _202.fingerprint]);
-  const out = { enabled: _optionalChain([f, 'optionalAccess', _203 => _203.enabled]) === true };
-  if (typeof _optionalChain([f, 'optionalAccess', _204 => _204.ua]) === "string" && f.ua.trim().length > 0) out.ua = f.ua.trim();
+  const f = _optionalChain([raw, 'optionalAccess', _203 => _203.fingerprint]);
+  const out = { enabled: _optionalChain([f, 'optionalAccess', _204 => _204.enabled]) === true };
+  if (typeof _optionalChain([f, 'optionalAccess', _205 => _205.ua]) === "string" && f.ua.trim().length > 0) out.ua = f.ua.trim();
   return out;
 }
 function normalizeVoucher(raw) {
-  return { enabled: _optionalChain([raw, 'optionalAccess', _205 => _205.voucher, 'optionalAccess', _206 => _206.enabled]) === true };
+  return { enabled: _optionalChain([raw, 'optionalAccess', _206 => _206.voucher, 'optionalAccess', _207 => _207.enabled]) === true };
 }
 var PROXY_TYPES = ["http", "https", "socks5"];
 function normalizeProxyConfig(raw) {
@@ -3773,14 +3781,14 @@ function clampNumber(value, min, max, fallback) {
   return Math.min(max, Math.max(min, n));
 }
 function normalizeQueueSegments(raw) {
-  const umq = _optionalChain([raw, 'optionalAccess', _207 => _207.userMessageQueue]);
-  const cq = _optionalChain([raw, 'optionalAccess', _208 => _208.concurrencyQueue]);
+  const umq = _optionalChain([raw, 'optionalAccess', _208 => _208.userMessageQueue]);
+  const cq = _optionalChain([raw, 'optionalAccess', _209 => _209.concurrencyQueue]);
   return {
     userMessageQueue: {
-      enabled: _optionalChain([umq, 'optionalAccess', _209 => _209.enabled]) === true,
-      delayMs: clampNumber(_optionalChain([umq, 'optionalAccess', _210 => _210.delayMs]), 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
+      enabled: _optionalChain([umq, 'optionalAccess', _210 => _210.enabled]) === true,
+      delayMs: clampNumber(_optionalChain([umq, 'optionalAccess', _211 => _211.delayMs]), 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
       waitTimeoutMs: clampNumber(
-        _optionalChain([umq, 'optionalAccess', _211 => _211.waitTimeoutMs]),
+        _optionalChain([umq, 'optionalAccess', _212 => _212.waitTimeoutMs]),
         1e3,
         3e5,
         DEFAULT_USER_MESSAGE_QUEUE.waitTimeoutMs
@@ -3788,14 +3796,14 @@ function normalizeQueueSegments(raw) {
     },
     concurrencyQueue: {
       maxQueueSizeFactor: clampNumber(
-        _optionalChain([cq, 'optionalAccess', _212 => _212.maxQueueSizeFactor]),
+        _optionalChain([cq, 'optionalAccess', _213 => _213.maxQueueSizeFactor]),
         1,
         10,
         DEFAULT_CONCURRENCY_QUEUE.maxQueueSizeFactor
       ),
-      minQueueSize: clampNumber(_optionalChain([cq, 'optionalAccess', _213 => _213.minQueueSize]), 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
+      minQueueSize: clampNumber(_optionalChain([cq, 'optionalAccess', _214 => _214.minQueueSize]), 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
       waitTimeoutMs: clampNumber(
-        _optionalChain([cq, 'optionalAccess', _214 => _214.waitTimeoutMs]),
+        _optionalChain([cq, 'optionalAccess', _215 => _215.waitTimeoutMs]),
         1e3,
         3e5,
         DEFAULT_CONCURRENCY_QUEUE.waitTimeoutMs
@@ -3908,7 +3916,7 @@ function normalizeGatewayModelMappings(raw) {
   return mappings;
 }
 function hasConfiguredLegacyModels(config) {
-  return Object.values(_nullishCoalesce(config.modelMap, () => ( {}))).some((value) => typeof value === "string" && value.trim()) || Boolean(_optionalChain([config, 'access', _215 => _215.models, 'optionalAccess', _216 => _216.some, 'call', _217 => _217((value) => typeof value === "string" && value.trim())])) || Boolean(_optionalChain([config, 'access', _218 => _218.defaultModel, 'optionalAccess', _219 => _219.trim, 'call', _220 => _220()])) || Boolean(_optionalChain([config, 'access', _221 => _221.backgroundModel, 'optionalAccess', _222 => _222.trim, 'call', _223 => _223()])) || Boolean(Object.values(_nullishCoalesce(config.prefixTargets, () => ( {}))).some((value) => _optionalChain([value, 'optionalAccess', _224 => _224.trim, 'call', _225 => _225()])));
+  return Object.values(_nullishCoalesce(config.modelMap, () => ( {}))).some((value) => typeof value === "string" && value.trim()) || Boolean(_optionalChain([config, 'access', _216 => _216.models, 'optionalAccess', _217 => _217.some, 'call', _218 => _218((value) => typeof value === "string" && value.trim())])) || Boolean(_optionalChain([config, 'access', _219 => _219.defaultModel, 'optionalAccess', _220 => _220.trim, 'call', _221 => _221()])) || Boolean(_optionalChain([config, 'access', _222 => _222.backgroundModel, 'optionalAccess', _223 => _223.trim, 'call', _224 => _224()])) || Boolean(Object.values(_nullishCoalesce(config.prefixTargets, () => ( {}))).some((value) => _optionalChain([value, 'optionalAccess', _225 => _225.trim, 'call', _226 => _226()])));
 }
 function splitModelRef(ref) {
   if (typeof ref !== "string") return null;
@@ -3976,7 +3984,7 @@ function legacyEndpointToBindings(config) {
     if (!parsed) continue;
     const route = routeFor(parsed.providerId);
     route[field] = ref;
-    if (_optionalChain([config, 'access', _226 => _226.backgroundModelIds, 'optionalAccess', _227 => _227.length])) {
+    if (_optionalChain([config, 'access', _227 => _227.backgroundModelIds, 'optionalAccess', _228 => _228.length])) {
       route.backgroundModelIds = [...config.backgroundModelIds];
     }
   }
@@ -4126,6 +4134,60 @@ function mergeServerConfig(current, patch) {
   });
 }
 
+// src/outbound-api/auditSessionKey.ts
+
+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 _crypto.createHash.call(void 0, "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 = _optionalChain([asObject, 'call', _229 => _229(body["metadata"]), 'optionalAccess', _230 => _230["user_id"]]);
+  if (typeof userId !== "string" || !userId) return void 0;
+  const matched = ANTHROPIC_SESSION_RE.exec(userId);
+  return _optionalChain([matched, 'optionalAccess', _231 => _231[1]]);
+}
+function anthropicContentFingerprint(body) {
+  const messages = body["messages"];
+  if (!Array.isArray(messages) || messages.length === 0) return void 0;
+  const parts = [];
+  const system = _chunkJ3QQ6JS5cjs.flattenMatchText.call(void 0, body["system"]).trim();
+  if (system) parts.push(system.slice(0, _chunkJ3QQ6JS5cjs.MATCH_TEXT_PER_MESSAGE_CAP));
+  let firstUser = "";
+  for (const entry of messages) {
+    const message = asObject(entry);
+    if (!message || message["role"] !== "user") continue;
+    const text = _chunkJ3QQ6JS5cjs.flattenMatchText.call(void 0, message["content"]).trim();
+    if (!text) continue;
+    firstUser = text.slice(0, _chunkJ3QQ6JS5cjs.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 = _chunkJ3QQ6JS5cjs.deriveGatewaySessionKey.call(void 0, 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
 
 
@@ -4488,8 +4550,8 @@ var OutboundRateLimiter = (_class10 = class {
    * recorded (no bucket growth).
    */
   check(apiKeyId, now = Date.now(), override) {
-    const maxRequests = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _228 => _228.maxRequests]), () => ( this.maxRequests));
-    const windowMs = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _229 => _229.windowMs]), () => ( this.windowMs));
+    const maxRequests = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _232 => _232.maxRequests]), () => ( this.maxRequests));
+    const windowMs = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _233 => _233.windowMs]), () => ( this.windowMs));
     if (maxRequests === 0) return { allowed: true, retryAfterSeconds: 0 };
     const cutoff = now - windowMs;
     const timestamps = (_nullishCoalesce(this.hits.get(apiKeyId), () => ( []))).filter((ts) => ts > cutoff);
@@ -4520,7 +4582,7 @@ var OutboundRateLimiter = (_class10 = 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) => _optionalChain([asObject, 'call', _230 => _230(block), 'optionalAccess', _231 => _231["type"]]) === "tool_result"
+      (block) => _optionalChain([asObject2, 'call', _234 => _234(block), 'optionalAccess', _235 => _235["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) => _optionalChain([asObject, 'call', _232 => _232(part), 'optionalAccess', _233 => _233["functionResponse"]]) !== void 0
+    (part) => _optionalChain([asObject2, 'call', _236 => _236(part), 'optionalAccess', _237 => _237["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":
@@ -4737,14 +4799,14 @@ function newVoucherId() {
 }
 function computeVoucherGrant(voucher, currentKey, now) {
   if (voucher.type === "credit") {
-    const current = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _234 => _234.totalCostLimitUsd]), () => ( 0));
+    const current = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _238 => _238.totalCostLimitUsd]), () => ( 0));
     let granted2 = current + (_nullishCoalesce(voucher.creditUsd, () => ( 0)));
     if (voucher.maxTotalCostLimitUsd != null) {
       granted2 = Math.min(granted2, voucher.maxTotalCostLimitUsd);
     }
     return { totalCostLimitUsd: granted2 };
   }
-  const currentExpiry = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _235 => _235.expiresAt]), () => ( now));
+  const currentExpiry = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _239 => _239.expiresAt]), () => ( now));
   let granted = currentExpiry + (_nullishCoalesce(voucher.renewalDays, () => ( 0))) * DAY_MS2;
   if (voucher.maxExpiryDays != null) {
     granted = Math.min(granted, now + voucher.maxExpiryDays * DAY_MS2);
@@ -4775,7 +4837,7 @@ function toVoucherInfo(v) {
 // src/outbound-api/voucherRedeem.ts
 function isRedeemRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _236 => _236.split, 'call', _237 => _237("?"), 'access', _238 => _238[0], 'optionalAccess', _239 => _239.replace, 'call', _240 => _240(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _240 => _240.split, 'call', _241 => _241("?"), 'access', _242 => _242[0], 'optionalAccess', _243 => _243.replace, 'call', _244 => _244(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/redeem");
 }
 function writeErr(res, status, message, headers = {}) {
@@ -4805,8 +4867,8 @@ function grantToResult(type, granted) {
 function currentResult(type, keyRow) {
   const result = { type };
   if (type === "credit") {
-    if (_optionalChain([keyRow, 'optionalAccess', _241 => _241.totalCostLimitUsd]) != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
-  } else if (_optionalChain([keyRow, 'optionalAccess', _242 => _242.expiresAt]) != null) {
+    if (_optionalChain([keyRow, 'optionalAccess', _245 => _245.totalCostLimitUsd]) != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
+  } else if (_optionalChain([keyRow, 'optionalAccess', _246 => _246.expiresAt]) != null) {
     result.expiresAt = keyRow.expiresAt;
   }
   return result;
@@ -4893,7 +4955,7 @@ async function handleVoucherRedeem(req, res, deps, voucherEnabled, redeemLimiter
     const won = await voucherDb.voucherRedeemCas(voucher.id, verifiedKeyId, absolute, now);
     if (!won) {
       const after = await voucherDb.voucherGetByHash(codeHash);
-      if (_optionalChain([after, 'optionalAccess', _243 => _243.status]) === "redeemed" && after.redeemedByKeyId === verifiedKeyId) {
+      if (_optionalChain([after, 'optionalAccess', _247 => _247.status]) === "redeemed" && after.redeemedByKeyId === verifiedKeyId) {
         return after.grantApplied === true ? { ok: true, result: currentResult(after.type, await deps.db.outboundApiKeysGetByHash(keyHash)) } : await applyFirstPass(after, recordedAbsolute(after));
       }
       return { ok: false, status: 409, message: "Code was already redeemed" };
@@ -4954,10 +5016,10 @@ function extractPresentedKey(req) {
   }
   const xApiKey = req.headers["x-api-key"];
   const xApi = Array.isArray(xApiKey) ? xApiKey[0] : xApiKey;
-  if (_optionalChain([xApi, 'optionalAccess', _244 => _244.trim, 'call', _245 => _245()])) return xApi.trim();
+  if (_optionalChain([xApi, 'optionalAccess', _248 => _248.trim, 'call', _249 => _249()])) return xApi.trim();
   const goog = req.headers["x-goog-api-key"];
   const g = Array.isArray(goog) ? goog[0] : goog;
-  return _optionalChain([g, 'optionalAccess', _246 => _246.trim, 'call', _247 => _247()]) || void 0;
+  return _optionalChain([g, 'optionalAccess', _250 => _250.trim, 'call', _251 => _251()]) || void 0;
 }
 function isLoopbackPeer(address) {
   if (!address) return false;
@@ -4966,7 +5028,7 @@ function isLoopbackPeer(address) {
 }
 function selectEndpoint(method, url) {
   if (method !== "POST" || !url) return null;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _248 => _248.split, 'call', _249 => _249("?"), 'access', _250 => _250[0], 'optionalAccess', _251 => _251.replace, 'call', _252 => _252(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _252 => _252.split, 'call', _253 => _253("?"), 'access', _254 => _254[0], 'optionalAccess', _255 => _255.replace, 'call', _256 => _256(/\/+$/, "")]), () => ( ""));
   if (path.endsWith("/chat/completions")) return "chat";
   if (path.endsWith("/responses")) return "responses";
   if (path.includes("/v1/messages")) return "messages";
@@ -4984,36 +5046,54 @@ function extractGeminiModelFromUrl(url) {
 }
 function isModelsListRequest(url) {
   if (!url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _253 => _253.split, 'call', _254 => _254("?"), 'access', _255 => _255[0], 'optionalAccess', _256 => _256.replace, 'call', _257 => _257(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _257 => _257.split, 'call', _258 => _258("?"), 'access', _259 => _259[0], 'optionalAccess', _260 => _260.replace, 'call', _261 => _261(/\/+$/, "")]), () => ( ""));
   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', _262 => _262.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', _263 => _263.modelMappings, 'optionalAccess', _264 => _264.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', _265 => _265.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 }));
 }
@@ -5032,7 +5112,7 @@ function shimAuthHeader(req, routeToken) {
 }
 async function handleOutboundRequest(req, res, deps, config, rateLimiter, serialQueue, concurrencyGate, redeemLimiter, redeemMutex) {
   const now = Date.now();
-  const audit = _chunkXPIOJQS2cjs.beginAuditCapture.call(void 0, req, res, now);
+  const audit = _chunkUWDW6PN3cjs.beginAuditCapture.call(void 0, req, res, now);
   const billing = _chunkAPYG5QD7cjs.beginBillingCapture.call(void 0, req, res, now);
   const presented = extractPresentedKey(req);
   const verification = await verifyKey(deps.db, presented, now);
@@ -5047,7 +5127,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', _266 => _266.socket, 'optionalAccess', _267 => _267.remoteAddress]))) {
     writeJsonError(res, 403, "This integration key is restricted to loopback clients");
     return;
   }
@@ -5060,7 +5140,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', _268 => _268.voucher, 'optionalAccess', _269 => _269.enabled]) === true,
       _nullishCoalesce(redeemLimiter, () => ( getFallbackRedeemLimiter())),
       verified.id,
       _nullishCoalesce(presented, () => ( "")),
@@ -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;
@@ -5229,7 +5315,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', _270 => _270.userMessageQueue, 'optionalAccess', _271 => _271.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
       const umq = config.userMessageQueue;
       try {
         const serialSlot = await serialQueue.acquire(providerKey, {
@@ -5369,7 +5455,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', _272 => _272.onPortChange, 'optionalCall', _273 => _273(actualPort)]);
     this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
@@ -5438,7 +5524,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', _274 => _274.split, 'call', _275 => _275("?"), 'access', _276 => _276[0], 'optionalAccess', _277 => _277.replace, 'call', _278 => _278(/\/+$/, "")]) || "/";
     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 +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 _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', _279 => _279.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', _280 => _280.kind]) === "level" && plan.enabled) {
+    return {
+      effectiveMaxTokens: configuredMaxTokens,
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: plan.effort },
+      legacyBudgetEnabled: false
+    };
+  }
+  if (_optionalChain([plan, 'optionalAccess', _281 => _281.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', _282 => _282.kind]) === "level") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingLevel: plan.effort
+    };
+  }
+  if (_optionalChain([plan, 'optionalAccess', _283 => _283.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 = _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 +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: _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 +5874,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', _284 => _284.message, 'optionalAccess', _285 => _285.content]) || "",
         timestamp: Date.now()
       },
       usage: openaiResponse2.usage ? {
@@ -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: _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 +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) {
@@ -5828,7 +5991,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', _286 => _286.parts])) {
     for (const part of content.parts) {
       if (part.text) {
         textContent += part.text;
@@ -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 = _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 +6084,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 +6093,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 +6119,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', _287 => _287.onError, 'optionalCall', _288 => _288(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai", {
@@ -5971,7 +6129,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', _289 => _289.onDone, 'optionalCall', _290 => _290(
     {
       id: messageId,
       role: "assistant",
@@ -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 = _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 +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 = _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 +6204,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', _291 => _291.messages, 'optionalAccess', _292 => _292.length]),
     max_tokens: anthropicRequest.max_tokens,
     temperature: anthropicRequest.temperature,
     stream: anthropicRequest.stream,
@@ -6060,7 +6221,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', _293 => _293.onError, 'optionalCall', _294 => _294(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "anthropic", {
@@ -6071,10 +6232,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', _295 => _295.reasoning, 'optionalAccess', _296 => _296.length]) || 0,
     blocksCount: result.blocks.length
   });
-  _optionalChain([callbacks, 'access', _284 => _284.onDone, 'optionalCall', _285 => _285(
+  _optionalChain([callbacks, 'access', _297 => _297.onDone, 'optionalCall', _298 => _298(
     {
       id: messageId,
       role: "assistant",
@@ -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) {
@@ -6130,7 +6293,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', _299 => _299.onError, 'optionalCall', _300 => _300(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "gemini", {
@@ -6139,7 +6302,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', _301 => _301.onDone, 'optionalCall', _302 => _302(
     {
       id: messageId,
       role: "assistant",
@@ -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 = _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 +6352,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', _303 => _303.onError, 'optionalCall', _304 => _304(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai-response", {
@@ -6200,7 +6361,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', _305 => _305.onDone, 'optionalCall', _306 => _306(
     {
       id: messageId,
       role: "assistant",
@@ -6220,7 +6381,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 +6389,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', _307 => _307.maxTokens, 'optionalAccess', _308 => _308.enabled]) && globalParams.maxTokens.value > 0) {
       logger.debug("Using global maxTokens", { maxTokens: globalParams.maxTokens.value });
       return globalParams.maxTokens.value;
     }
@@ -6256,7 +6417,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', _309 => _309.name, 'optionalAccess', _310 => _310.toLowerCase, 'call', _311 => _311()]) || "";
   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 +6454,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', _312 => _312.function, 'access', _313 => _313.description, 'optionalAccess', _314 => _314.slice, 'call', _315 => _315(0, 100)]),
         parameters: firstTool.function.parameters
       }
     });
@@ -6304,7 +6465,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', _316 => _316.description, 'optionalAccess', _317 => _317.slice, 'call', _318 => _318(0, 100)]),
         input_schema: firstTool.input_schema
       }
     });
@@ -6315,9 +6476,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', _319 => _319[0], 'optionalAccess', _320 => _320.name]),
+        description: _optionalChain([allDeclarations, 'access', _321 => _321[0], 'optionalAccess', _322 => _322.description, 'optionalAccess', _323 => _323.slice, 'call', _324 => _324(0, 100)]),
+        parameters: _optionalChain([allDeclarations, 'access', _325 => _325[0], 'optionalAccess', _326 => _326.parameters])
       }
     });
   }
@@ -6351,7 +6512,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 +6541,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', _327 => _327.candidates, 'optionalAccess', _328 => _328[0], 'optionalAccess', _329 => _329.content, 'optionalAccess', _330 => _330.parts]) || [];
     let text = "";
     for (const part of parts) {
       if (part.thought === true) continue;
@@ -6388,15 +6549,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', _331 => _331.delta, 'optionalAccess', _332 => _332.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', _333 => _333.choices, 'optionalAccess', _334 => _334[0], 'optionalAccess', _335 => _335.delta, 'optionalAccess', _336 => _336.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', _337 => _337.candidates, 'optionalAccess', _338 => _338[0], 'optionalAccess', _339 => _339.content, 'optionalAccess', _340 => _340.parts]) || [];
     let reasoning = "";
     for (const part of parts) {
       if (part.thought === true && part.text) reasoning += part.text;
@@ -6405,14 +6566,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', _341 => _341.choices, 'optionalAccess', _342 => _342[0], 'optionalAccess', _343 => _343.delta]);
+    return (_optionalChain([delta, 'optionalAccess', _344 => _344.thinking, 'optionalAccess', _345 => _345.content]) || "") + (_optionalChain([delta, 'optionalAccess', _346 => _346.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', _347 => _347.candidates, 'optionalAccess', _348 => _348[0], 'optionalAccess', _349 => _349.content, 'optionalAccess', _350 => _350.parts]) || [];
     for (const part of parts) {
       if (part.functionCall) {
         logger.info("Function call detected", { functionCall: part.functionCall });
@@ -6422,13 +6583,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', _351 => _351.onToolCall, 'optionalCall', _352 => _352(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', _353 => _353.choices, 'optionalAccess', _354 => _354[0], 'optionalAccess', _355 => _355.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _356 => _356.tool_calls]) && pendingOpenAIToolCalls) {
       for (const tc of delta.tool_calls) {
         const index = _nullishCoalesce(tc.index, () => ( 0));
         let pending = pendingOpenAIToolCalls.get(index);
@@ -6437,8 +6598,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', _357 => _357.function, 'optionalAccess', _358 => _358.name])) pending.name += tc.function.name;
+        if (_optionalChain([tc, 'access', _359 => _359.function, 'optionalAccess', _360 => _360.arguments])) pending.arguments += tc.function.arguments;
       }
     }
   }
@@ -6453,7 +6614,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', _361 => _361.onToolCall, 'optionalCall', _362 => _362(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 +6628,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', _363 => _363.candidates, 'optionalAccess', _364 => _364[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', _365 => _365.content, 'optionalAccess', _366 => _366.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', _367 => _367.onReasoning, 'optionalCall', _368 => _368(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', _369 => _369.onDelta, 'optionalCall', _370 => _370(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', _371 => _371.text])) {
+      _optionalChain([callbacks, 'access', _372 => _372.onDelta, 'optionalCall', _373 => _373(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', _374 => _374.choices, 'optionalAccess', _375 => _375[0], 'optionalAccess', _376 => _376.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _377 => _377.content])) {
+      _optionalChain([callbacks, 'access', _378 => _378.onDelta, 'optionalCall', _379 => _379(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', _380 => _380.thinking, 'optionalAccess', _381 => _381.content])) {
+      _optionalChain([callbacks, 'access', _382 => _382.onReasoning, 'optionalCall', _383 => _383(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', _384 => _384.reasoning_content])) {
+      _optionalChain([callbacks, 'access', _385 => _385.onReasoning, 'optionalCall', _386 => _386(delta.reasoning_content)]);
     }
   }
 }
@@ -6511,7 +6672,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', _387 => _387.onBlock, 'optionalCall', _388 => _388(thinkingBlock)]);
   }
   if (content && content.trim()) {
     const textBlock = {
@@ -6520,7 +6681,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', _389 => _389.onBlock, 'optionalCall', _390 => _390(textBlock)]);
   }
 }
 async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
@@ -6535,7 +6696,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', _391 => _391.onBlock, 'optionalCall', _392 => _392(toolUseBlock)]);
     try {
       logger.info("Executing tool", { toolName: toolCall.name });
       const mcpTool = mcpTools.find((t) => t.id === toolCall.name);
@@ -6558,8 +6719,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', _393 => _393.onToolResult, 'optionalCall', _394 => _394(toolCall.id, result)]);
+      const resultText = _optionalChain([result, 'access', _395 => _395.content, 'optionalAccess', _396 => _396[0], 'optionalAccess', _397 => _397.text]) || JSON.stringify(result);
       const toolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -6569,11 +6730,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', _398 => _398.onBlock, 'optionalCall', _399 => _399(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', _400 => _400.onBlock, 'optionalCall', _401 => _401({ ...toolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result });
     } catch (error) {
@@ -6583,7 +6744,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', _402 => _402.onToolResult, 'optionalCall', _403 => _403(toolCall.id, errorResult)]);
       const errorToolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -6593,11 +6754,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', _404 => _404.onBlock, 'optionalCall', _405 => _405(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', _406 => _406.onBlock, 'optionalCall', _407 => _407({ ...errorToolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result: errorResult });
     }
@@ -6607,7 +6768,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', _408 => _408.properties])) {
     const expectedParams = Object.keys(toolSchema.properties);
     const paramMappings = {
       "search_query": ["query", "q", "searchQuery", "search"],
@@ -6641,25 +6802,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', _409 => _409.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _410 => _410.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', _411 => _411.onError, 'optionalCall', _412 => _412(`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', _413 => _413.onError, 'optionalCall', _414 => _414(`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', _415 => _415.onError, 'optionalCall', _416 => _416("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', _417 => _417.onStart, 'optionalCall', _418 => _418(messageId)]);
     const globalParams = await llmConfig.getGlobalModelParameters();
     const MAX_ITERATIONS = _nullishCoalesce(globalParams.toolMaxTurns, () => ( 100));
     let iteration = 0;
@@ -6706,12 +6867,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', _419 => _419.onError, 'optionalCall', _420 => _420(`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', _421 => _421.body, 'optionalAccess', _422 => _422.getReader, 'call', _423 => _423()]);
       if (!reader) {
-        _optionalChain([callbacks, 'access', _411 => _411.onError, 'optionalCall', _412 => _412("No response body")]);
+        _optionalChain([callbacks, 'access', _424 => _424.onError, 'optionalCall', _425 => _425("No response body")]);
         return;
       }
       const decoder = new TextDecoder();
@@ -6744,7 +6905,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', _426 => _426.onError, 'optionalCall', _427 => _427(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
                   return;
                 }
                 parseStreamChunk(json, apiFormat, callbacks, logger);
@@ -6777,7 +6938,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', _428 => _428.mcpTools, 'optionalAccess', _429 => _429.length]),
           hasMcpService: !!mcpService
         });
         if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
@@ -6798,7 +6959,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', _430 => _430.content, 'optionalAccess', _431 => _431[0], 'optionalAccess', _432 => _432.text]) || JSON.stringify(result);
             return `Tool ${toolCall.name} result:
 ${resultText}`;
           }).join("\n\n");
@@ -6816,12 +6977,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', _433 => _433.onError, 'optionalCall', _434 => _434(`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', _435 => _435.onDone, 'optionalCall', _436 => _436({
       id: messageId,
       role: "assistant",
       content: finalContent,
@@ -6832,7 +6993,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', _437 => _437.onError, 'optionalCall', _438 => _438(message)]);
   }
 }
 
@@ -6883,8 +7044,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', _439 => _439.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _440 => _440.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
       return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -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 _chunkMUHWHQVMcjs.executeProviderCall.call(void 0, {
@@ -6960,18 +7122,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', _441 => _441.choices, 'optionalAccess', _442 => _442[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', _443 => _443.message, 'optionalAccess', _444 => _444.tool_calls]);
+    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _445 => _445.map, 'call', _446 => _446((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', _447 => _447.recorder]) && tapped) {
       recording.recorder.record({
         messageId: _nullishCoalesce(options.messageId, () => ( null)),
         parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -6989,9 +7151,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', _448 => _448.message, 'optionalAccess', _449 => _449.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', _450 => _450.message, 'optionalAccess', _451 => _451.thinking, 'optionalAccess', _452 => _452.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _453 => _453.message, 'optionalAccess', _454 => _454.thinking, 'optionalAccess', _455 => _455.content]) || "", signature: _optionalChain([choice, 'access', _456 => _456.message, 'optionalAccess', _457 => _457.thinking, 'optionalAccess', _458 => _458.signature]) } : void 0,
         toolCalls
       },
       usage: data.usage ? {
@@ -7012,21 +7174,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', _459 => _459.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _460 => _460.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', _461 => _461.onError, 'optionalCall', _462 => _462(`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', _463 => _463.onError, 'optionalCall', _464 => _464(`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', _465 => _465.onError, 'optionalCall', _466 => _466("API key not configured")]);
       return;
     }
     const { chain, hasTransformers } = await resolveChainWithMain(
@@ -7038,13 +7200,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', _467 => _467.onStart, 'optionalCall', _468 => _468(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 +7240,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', _469 => _469.onError, 'optionalCall', _470 => _470(`API error (${response.status}): ${errorText}`)]);
       return;
     }
     const transformedResponse = await executor.executeResponseChain(
@@ -7087,9 +7250,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', _471 => _471.body, 'optionalAccess', _472 => _472.getReader, 'call', _473 => _473()]);
     if (!reader) {
-      _optionalChain([callbacks, 'access', _461 => _461.onError, 'optionalCall', _462 => _462("No response body")]);
+      _optionalChain([callbacks, 'access', _474 => _474.onError, 'optionalCall', _475 => _475("No response body")]);
       return;
     }
     const decoder = new TextDecoder();
@@ -7107,22 +7270,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', _476 => _476.choices, 'optionalAccess', _477 => _477[0], 'optionalAccess', _478 => _478.delta]);
+              if (_optionalChain([delta, 'optionalAccess', _479 => _479.content])) {
                 content += delta.content;
-                _optionalChain([callbacks, 'access', _467 => _467.onDelta, 'optionalCall', _468 => _468(delta.content)]);
+                _optionalChain([callbacks, 'access', _480 => _480.onDelta, 'optionalCall', _481 => _481(delta.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _469 => _469.thinking, 'optionalAccess', _470 => _470.content])) {
+              if (_optionalChain([delta, 'optionalAccess', _482 => _482.thinking, 'optionalAccess', _483 => _483.content])) {
                 reasoning += delta.thinking.content;
-                _optionalChain([callbacks, 'access', _471 => _471.onReasoning, 'optionalCall', _472 => _472(delta.thinking.content)]);
+                _optionalChain([callbacks, 'access', _484 => _484.onReasoning, 'optionalCall', _485 => _485(delta.thinking.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _473 => _473.reasoning_content])) {
+              if (_optionalChain([delta, 'optionalAccess', _486 => _486.reasoning_content])) {
                 reasoning += delta.reasoning_content;
-                _optionalChain([callbacks, 'access', _474 => _474.onReasoning, 'optionalCall', _475 => _475(delta.reasoning_content)]);
+                _optionalChain([callbacks, 'access', _487 => _487.onReasoning, 'optionalCall', _488 => _488(delta.reasoning_content)]);
               }
               if (json.usage) {
                 const tapped = readUsageFromOpenAIResponse(json.usage);
-                if (_optionalChain([recording, 'optionalAccess', _476 => _476.recorder]) && tapped) {
+                if (_optionalChain([recording, 'optionalAccess', _489 => _489.recorder]) && tapped) {
                   recording.recorder.record({
                     messageId: _nullishCoalesce(options.messageId, () => ( null)),
                     parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -7135,7 +7298,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
                     rawUsage: json.usage
                   });
                 }
-                _optionalChain([callbacks, 'access', _477 => _477.onDone, 'optionalCall', _478 => _478(
+                _optionalChain([callbacks, 'access', _490 => _490.onDone, 'optionalCall', _491 => _491(
                   {
                     id: messageId,
                     role: "assistant",
@@ -7156,7 +7319,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
           }
         }
       }
-      _optionalChain([callbacks, 'access', _479 => _479.onDone, 'optionalCall', _480 => _480({
+      _optionalChain([callbacks, 'access', _492 => _492.onDone, 'optionalCall', _493 => _493({
         id: messageId,
         role: "assistant",
         content,
@@ -7168,7 +7331,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', _494 => _494.onError, 'optionalCall', _495 => _495(message)]);
   }
 }
 
@@ -7235,8 +7398,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', _496 => _496.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _497 => _497.actualModelId]) || options.model;
       const provider = await this.getProvider(actualProviderId);
       if (!provider) {
         return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -7269,7 +7432,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', _498 => _498.usageEventSink, 'optionalAccess', _499 => _499.emit, 'call', _500 => _500({
           sessionId: options.sessionId,
           modelId: actualModel,
           usage: result.usage,
@@ -7298,8 +7461,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', _501 => _501.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _502 => _502.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 +7474,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', _503 => _503.onError, 'optionalCall', _504 => _504(`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', _505 => _505.onError, 'optionalCall', _506 => _506(`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', _507 => _507.onError, 'optionalCall', _508 => _508("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', _509 => _509.onStart, 'optionalCall', _510 => _510(messageId)]);
       const resolvedOptions = { ...options, model: actualModel };
       if (options.sessionId) {
         const sid = options.sessionId;
@@ -7335,14 +7498,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', _511 => _511.usageEventSink, 'optionalAccess', _512 => _512.emit, 'call', _513 => _513({
                 sessionId: sid,
                 modelId: actualModel,
                 usage,
                 engineOrigin: "completion"
               })]);
             }
-            _optionalChain([userOnDone, 'optionalCall', _501 => _501(message, usage, metrics)]);
+            _optionalChain([userOnDone, 'optionalCall', _514 => _514(message, usage, metrics)]);
           }
         };
       }
@@ -7358,11 +7521,11 @@ var CompletionService = (_class15 = class {
               retryState.error = { status, message: error };
               return;
             }
-            _optionalChain([callbacks, 'access', _502 => _502.onError, 'optionalCall', _503 => _503(error)]);
+            _optionalChain([callbacks, 'access', _515 => _515.onError, 'optionalCall', _516 => _516(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', _517 => _517.onDone, 'optionalCall', _518 => _518(message, usage, metrics)]);
           }
         };
         await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
@@ -7383,7 +7546,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', _519 => _519.onError, 'optionalCall', _520 => _520(retryState.error.message)]);
           }
         }
       } else {
@@ -7396,7 +7559,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', _521 => _521.onError, 'optionalCall', _522 => _522(message)]);
     }
   }
   /**
@@ -7436,7 +7599,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', _523 => _523.message, 'optionalAccess', _524 => _524.content]) || "",
           model: modelId,
           durationMs
         };
@@ -7501,7 +7664,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', _525 => _525.codingPlan, 'optionalAccess', _526 => _526.enabled]) && provider.codingPlan.apiKey) {
       return this.resolveApiKey(provider.codingPlan.apiKey);
     }
     if (this.apiKeyPool) {