@omnicross/core 0.1.9 → 0.1.10

package/dist/{chunk-XELFM7KL.cjs → chunk-TIT74RIL.cjs}

@@ -36,6 +36,8 @@ var _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
 
 
 
+
+
 var _chunkJ3QQ6JS5cjs = require('./chunk-J3QQ6JS5.cjs');
 
 
@@ -104,7 +106,7 @@ var _chunkQBZJ7P2Tcjs = require('./chunk-QBZJ7P2T.cjs');
 var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
 
-var _chunkXPIOJQS2cjs = require('./chunk-XPIOJQS2.cjs');
+var _chunkUWDW6PN3cjs = require('./chunk-UWDW6PN3.cjs');
 
 
 
@@ -3664,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) {
@@ -3675,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) {
@@ -3778,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
@@ -3793,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
@@ -3913,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;
@@ -3981,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];
     }
   }
@@ -4131,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
 
 
@@ -4493,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);
@@ -4525,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) {
@@ -4533,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;
   }
@@ -4549,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";
@@ -4558,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":
@@ -4742,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);
@@ -4780,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 = {}) {
@@ -4810,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;
@@ -4898,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" };
@@ -4959,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;
@@ -4971,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";
@@ -4989,7 +5046,7 @@ 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");
 }
 async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoints) {
@@ -5000,7 +5057,7 @@ async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoint
       if (binding.modelMode === "passthrough") {
         if (binding.target.kind === "provider") {
           const provider = await llmConfig.getProvider(binding.target.providerId);
-          modelIds.push(..._nullishCoalesce(_optionalChain([provider, 'optionalAccess', _258 => _258.models]), () => ( [])));
+          modelIds.push(..._nullishCoalesce(_optionalChain([provider, 'optionalAccess', _262 => _262.models]), () => ( [])));
         } else if (Object.prototype.hasOwnProperty.call(
           _subscriptionmodelcatalog.SUBSCRIPTION_MODEL_CATALOG,
           binding.target.providerId
@@ -5011,7 +5068,7 @@ async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoint
         }
         continue;
       }
-      if (_optionalChain([binding, 'access', _259 => _259.modelMappings, 'optionalAccess', _260 => _260.length])) {
+      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("*"))
         );
@@ -5027,7 +5084,7 @@ async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoint
         if (endpointConfig.backgroundModel) refs.push(endpointConfig.backgroundModel);
       }
       modelIds.push(
-        ...refs.map((ref) => _optionalChain([_chunk4VZX5F4Tcjs.parseModelRef.call(void 0, ref), 'optionalAccess', _261 => _261.modelId])).filter((modelId) => modelId !== void 0)
+        ...refs.map((ref) => _optionalChain([_chunk4VZX5F4Tcjs.parseModelRef.call(void 0, ref), 'optionalAccess', _265 => _265.modelId])).filter((modelId) => modelId !== void 0)
       );
     }
   }
@@ -5055,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);
@@ -5070,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', _262 => _262.socket, 'optionalAccess', _263 => _263.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;
   }
@@ -5083,7 +5140,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       req,
       res,
       deps,
-      _optionalChain([config, 'access', _264 => _264.voucher, 'optionalAccess', _265 => _265.enabled]) === true,
+      _optionalChain([config, 'access', _268 => _268.voucher, 'optionalAccess', _269 => _269.enabled]) === true,
       _nullishCoalesce(redeemLimiter, () => ( getFallbackRedeemLimiter())),
       verified.id,
       _nullishCoalesce(presented, () => ( "")),
@@ -5185,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;
@@ -5252,7 +5315,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
     }
     let releaseSerial = null;
     const providerKey = resolved.route.providerId;
-    if (_optionalChain([config, 'access', _266 => _266.userMessageQueue, 'optionalAccess', _267 => _267.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, {
@@ -5392,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', _268 => _268.onPortChange, 'optionalCall', _269 => _269(actualPort)]);
+    if (actualPort !== port) _optionalChain([this, 'access', _272 => _272.onPortChange, 'optionalCall', _273 => _273(actualPort)]);
     this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
@@ -5461,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', _270 => _270.split, 'call', _271 => _271("?"), 'access', _272 => _272[0], 'optionalAccess', _273 => _273.replace, 'call', _274 => _274(/\/+$/, "")]) || "/";
+    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" });
@@ -5676,7 +5739,7 @@ function resolveCompletionReasoningPlan(provider, options, target, requestMaxTok
 }
 function resolveOpenAIEffort(provider, options, target) {
   const plan = resolveCompletionReasoningPlan(provider, options, target);
-  return _optionalChain([plan, 'optionalAccess', _275 => _275.kind]) === "level" && plan.enabled ? plan.effort : void 0;
+  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));
@@ -5687,7 +5750,7 @@ function buildAnthropicReasoningWire(provider, options) {
     "anthropic",
     legacyBound
   );
-  if (_optionalChain([plan, 'optionalAccess', _276 => _276.kind]) === "level" && plan.enabled) {
+  if (_optionalChain([plan, 'optionalAccess', _280 => _280.kind]) === "level" && plan.enabled) {
     return {
       effectiveMaxTokens: configuredMaxTokens,
       thinking: { type: "adaptive" },
@@ -5695,7 +5758,7 @@ function buildAnthropicReasoningWire(provider, options) {
       legacyBudgetEnabled: false
     };
   }
-  if (_optionalChain([plan, 'optionalAccess', _277 => _277.kind]) === "budget" && plan.enabled) {
+  if (_optionalChain([plan, 'optionalAccess', _281 => _281.kind]) === "budget" && plan.enabled) {
     return {
       effectiveMaxTokens: legacyBound,
       thinking: { type: "enabled", budget_tokens: plan.budgetTokens },
@@ -5709,13 +5772,13 @@ function buildAnthropicReasoningWire(provider, options) {
 }
 function buildGeminiThinkingConfig(provider, options) {
   const plan = resolveCompletionReasoningPlan(provider, options, "gemini");
-  if (_optionalChain([plan, 'optionalAccess', _278 => _278.kind]) === "level") {
+  if (_optionalChain([plan, 'optionalAccess', _282 => _282.kind]) === "level") {
     return {
       includeThoughts: plan.enabled,
       thinkingLevel: plan.effort
     };
   }
-  if (_optionalChain([plan, 'optionalAccess', _279 => _279.kind]) === "budget") {
+  if (_optionalChain([plan, 'optionalAccess', _283 => _283.kind]) === "budget") {
     return {
       includeThoughts: plan.enabled,
       thinkingBudget: plan.budgetTokens
@@ -5811,7 +5874,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       message: {
         id: `assistant-${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice2, 'access', _280 => _280.message, 'optionalAccess', _281 => _281.content]) || "",
+        content: _optionalChain([choice2, 'access', _284 => _284.message, 'optionalAccess', _285 => _285.content]) || "",
         timestamp: Date.now()
       },
       usage: openaiResponse2.usage ? {
@@ -5928,7 +5991,7 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
   const candidate = candidates[0];
   const content = candidate.content;
   let textContent = "";
-  if (_optionalChain([content, 'optionalAccess', _282 => _282.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _286 => _286.parts])) {
     for (const part of content.parts) {
       if (part.text) {
         textContent += part.text;
@@ -6056,7 +6119,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _283 => _283.onError, 'optionalCall', _284 => _284(`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", {
@@ -6066,7 +6129,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     onVideo: callbacks.onVideo,
     onError: callbacks.onError
   });
-  _optionalChain([callbacks, 'access', _285 => _285.onDone, 'optionalCall', _286 => _286(
+  _optionalChain([callbacks, 'access', _289 => _289.onDone, 'optionalCall', _290 => _290(
     {
       id: messageId,
       role: "assistant",
@@ -6141,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', _287 => _287.messages, 'optionalAccess', _288 => _288.length]),
+    messagesCount: _optionalChain([anthropicRequest, 'access', _291 => _291.messages, 'optionalAccess', _292 => _292.length]),
     max_tokens: anthropicRequest.max_tokens,
     temperature: anthropicRequest.temperature,
     stream: anthropicRequest.stream,
@@ -6158,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', _289 => _289.onError, 'optionalCall', _290 => _290(`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", {
@@ -6169,10 +6232,10 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   });
   logger.info("Anthropic stream complete", {
     contentLength: result.content.length,
-    reasoningLength: _optionalChain([result, 'access', _291 => _291.reasoning, 'optionalAccess', _292 => _292.length]) || 0,
+    reasoningLength: _optionalChain([result, 'access', _295 => _295.reasoning, 'optionalAccess', _296 => _296.length]) || 0,
     blocksCount: result.blocks.length
   });
-  _optionalChain([callbacks, 'access', _293 => _293.onDone, 'optionalCall', _294 => _294(
+  _optionalChain([callbacks, 'access', _297 => _297.onDone, 'optionalCall', _298 => _298(
     {
       id: messageId,
       role: "assistant",
@@ -6230,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', _295 => _295.onError, 'optionalCall', _296 => _296(`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", {
@@ -6239,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', _297 => _297.onDone, 'optionalCall', _298 => _298(
+  _optionalChain([callbacks, 'access', _301 => _301.onDone, 'optionalCall', _302 => _302(
     {
       id: messageId,
       role: "assistant",
@@ -6289,7 +6352,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _299 => _299.onError, 'optionalCall', _300 => _300(`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", {
@@ -6298,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', _301 => _301.onDone, 'optionalCall', _302 => _302(
+  _optionalChain([callbacks, 'access', _305 => _305.onDone, 'optionalCall', _306 => _306(
     {
       id: messageId,
       role: "assistant",
@@ -6326,7 +6389,7 @@ async function resolveEffectiveMaxTokens(llmConfig, _getProvider, logger, _provi
   }
   try {
     const globalParams = await llmConfig.getGlobalModelParameters();
-    if (_optionalChain([globalParams, 'optionalAccess', _303 => _303.maxTokens, 'optionalAccess', _304 => _304.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;
     }
@@ -6354,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', _305 => _305.name, 'optionalAccess', _306 => _306.toLowerCase, 'call', _307 => _307()]) || "";
+  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);
@@ -6391,7 +6454,7 @@ function logToolFormat(tools, logger) {
       tools: openaiTools.map((t) => t.function.name),
       firstTool: {
         name: firstTool.function.name,
-        description: _optionalChain([firstTool, 'access', _308 => _308.function, 'access', _309 => _309.description, 'optionalAccess', _310 => _310.slice, 'call', _311 => _311(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
       }
     });
@@ -6402,7 +6465,7 @@ function logToolFormat(tools, logger) {
       tools: anthropicTools.map((t) => t.name),
       firstTool: {
         name: firstTool.name,
-        description: _optionalChain([firstTool, 'access', _312 => _312.description, 'optionalAccess', _313 => _313.slice, 'call', _314 => _314(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _316 => _316.description, 'optionalAccess', _317 => _317.slice, 'call', _318 => _318(0, 100)]),
         input_schema: firstTool.input_schema
       }
     });
@@ -6413,9 +6476,9 @@ function logToolFormat(tools, logger) {
       count: allDeclarations.length,
       tools: allDeclarations.map((t) => t.name),
       firstTool: {
-        name: _optionalChain([allDeclarations, 'access', _315 => _315[0], 'optionalAccess', _316 => _316.name]),
-        description: _optionalChain([allDeclarations, 'access', _317 => _317[0], 'optionalAccess', _318 => _318.description, 'optionalAccess', _319 => _319.slice, 'call', _320 => _320(0, 100)]),
-        parameters: _optionalChain([allDeclarations, 'access', _321 => _321[0], 'optionalAccess', _322 => _322.parameters])
+        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])
       }
     });
   }
@@ -6478,7 +6541,7 @@ function buildToolRequest(apiFormat, conversationMessages, actualModel, options,
 function extractDeltaContent(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _323 => _323.candidates, 'optionalAccess', _324 => _324[0], 'optionalAccess', _325 => _325.content, 'optionalAccess', _326 => _326.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;
@@ -6486,15 +6549,15 @@ function extractDeltaContent(rawJson, apiFormat) {
     }
     return text;
   } else if (apiFormat === "anthropic") {
-    return _optionalChain([json, 'access', _327 => _327.delta, 'optionalAccess', _328 => _328.text]) || "";
+    return _optionalChain([json, 'access', _331 => _331.delta, 'optionalAccess', _332 => _332.text]) || "";
   } else {
-    return _optionalChain([json, 'access', _329 => _329.choices, 'optionalAccess', _330 => _330[0], 'optionalAccess', _331 => _331.delta, 'optionalAccess', _332 => _332.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', _333 => _333.candidates, 'optionalAccess', _334 => _334[0], 'optionalAccess', _335 => _335.content, 'optionalAccess', _336 => _336.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;
@@ -6503,14 +6566,14 @@ function extractDeltaReasoning(rawJson, apiFormat) {
   } else if (apiFormat === "anthropic") {
     return "";
   } else {
-    const delta = _optionalChain([json, 'access', _337 => _337.choices, 'optionalAccess', _338 => _338[0], 'optionalAccess', _339 => _339.delta]);
-    return (_optionalChain([delta, 'optionalAccess', _340 => _340.thinking, 'optionalAccess', _341 => _341.content]) || "") + (_optionalChain([delta, 'optionalAccess', _342 => _342.reasoning_content]) || "");
+    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', _343 => _343.candidates, 'optionalAccess', _344 => _344[0], 'optionalAccess', _345 => _345.content, 'optionalAccess', _346 => _346.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 });
@@ -6520,13 +6583,13 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           args: part.functionCall.args || {}
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _347 => _347.onToolCall, 'optionalCall', _348 => _348(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', _349 => _349.choices, 'optionalAccess', _350 => _350[0], 'optionalAccess', _351 => _351.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _352 => _352.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);
@@ -6535,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', _353 => _353.function, 'optionalAccess', _354 => _354.name])) pending.name += tc.function.name;
-        if (_optionalChain([tc, 'access', _355 => _355.function, 'optionalAccess', _356 => _356.arguments])) pending.arguments += tc.function.arguments;
+        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;
       }
     }
   }
@@ -6551,7 +6614,7 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
           args: JSON.parse(pending.arguments || "{}")
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _357 => _357.onToolCall, 'optionalCall', _358 => _358(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, {
@@ -6565,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', _359 => _359.candidates, 'optionalAccess', _360 => _360[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', _361 => _361.content, 'optionalAccess', _362 => _362.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', _363 => _363.onReasoning, 'optionalCall', _364 => _364(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', _365 => _365.onDelta, 'optionalCall', _366 => _366(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', _367 => _367.text])) {
-      _optionalChain([callbacks, 'access', _368 => _368.onDelta, 'optionalCall', _369 => _369(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', _370 => _370.choices, 'optionalAccess', _371 => _371[0], 'optionalAccess', _372 => _372.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _373 => _373.content])) {
-      _optionalChain([callbacks, 'access', _374 => _374.onDelta, 'optionalCall', _375 => _375(delta.content)]);
+    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', _376 => _376.thinking, 'optionalAccess', _377 => _377.content])) {
-      _optionalChain([callbacks, 'access', _378 => _378.onReasoning, 'optionalCall', _379 => _379(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', _380 => _380.reasoning_content])) {
-      _optionalChain([callbacks, 'access', _381 => _381.onReasoning, 'optionalCall', _382 => _382(delta.reasoning_content)]);
+    if (_optionalChain([delta, 'optionalAccess', _384 => _384.reasoning_content])) {
+      _optionalChain([callbacks, 'access', _385 => _385.onReasoning, 'optionalCall', _386 => _386(delta.reasoning_content)]);
     }
   }
 }
@@ -6609,7 +6672,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content: reasoning
     };
     blocks.push(thinkingBlock);
-    _optionalChain([callbacks, 'access', _383 => _383.onBlock, 'optionalCall', _384 => _384(thinkingBlock)]);
+    _optionalChain([callbacks, 'access', _387 => _387.onBlock, 'optionalCall', _388 => _388(thinkingBlock)]);
   }
   if (content && content.trim()) {
     const textBlock = {
@@ -6618,7 +6681,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content
     };
     blocks.push(textBlock);
-    _optionalChain([callbacks, 'access', _385 => _385.onBlock, 'optionalCall', _386 => _386(textBlock)]);
+    _optionalChain([callbacks, 'access', _389 => _389.onBlock, 'optionalCall', _390 => _390(textBlock)]);
   }
 }
 async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
@@ -6633,7 +6696,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
       status: "running"
     };
     blocks.push(toolUseBlock);
-    _optionalChain([callbacks, 'access', _387 => _387.onBlock, 'optionalCall', _388 => _388(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);
@@ -6656,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', _389 => _389.onToolResult, 'optionalCall', _390 => _390(toolCall.id, result)]);
-      const resultText = _optionalChain([result, 'access', _391 => _391.content, 'optionalAccess', _392 => _392[0], 'optionalAccess', _393 => _393.text]) || JSON.stringify(result);
+      _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",
@@ -6667,11 +6730,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: result.isError
       };
       blocks.push(toolResultBlock);
-      _optionalChain([callbacks, 'access', _394 => _394.onBlock, 'optionalCall', _395 => _395(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', _396 => _396.onBlock, 'optionalCall', _397 => _397({ ...toolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _400 => _400.onBlock, 'optionalCall', _401 => _401({ ...toolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result });
     } catch (error) {
@@ -6681,7 +6744,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true,
         content: [{ type: "text", text: `Error: ${errorMessage}` }]
       };
-      _optionalChain([callbacks, 'access', _398 => _398.onToolResult, 'optionalCall', _399 => _399(toolCall.id, errorResult)]);
+      _optionalChain([callbacks, 'access', _402 => _402.onToolResult, 'optionalCall', _403 => _403(toolCall.id, errorResult)]);
       const errorToolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -6691,11 +6754,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true
       };
       blocks.push(errorToolResultBlock);
-      _optionalChain([callbacks, 'access', _400 => _400.onBlock, 'optionalCall', _401 => _401(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', _402 => _402.onBlock, 'optionalCall', _403 => _403({ ...errorToolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _406 => _406.onBlock, 'optionalCall', _407 => _407({ ...errorToolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result: errorResult });
     }
@@ -6705,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', _404 => _404.properties])) {
+  if (_optionalChain([toolSchema, 'optionalAccess', _408 => _408.properties])) {
     const expectedParams = Object.keys(toolSchema.properties);
     const paramMappings = {
       "search_query": ["query", "q", "searchQuery", "search"],
@@ -6739,25 +6802,25 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _405 => _405.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _406 => _406.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', _407 => _407.onError, 'optionalCall', _408 => _408(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _411 => _411.onError, 'optionalCall', _412 => _412(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _409 => _409.onError, 'optionalCall', _410 => _410(`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', _411 => _411.onError, 'optionalCall', _412 => _412("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', _413 => _413.onStart, 'optionalCall', _414 => _414(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;
@@ -6804,12 +6867,12 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       });
       if (!response.ok) {
         const errorText = await response.text();
-        _optionalChain([callbacks, 'access', _415 => _415.onError, 'optionalCall', _416 => _416(`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', _417 => _417.body, 'optionalAccess', _418 => _418.getReader, 'call', _419 => _419()]);
+      const reader = _optionalChain([response, 'access', _421 => _421.body, 'optionalAccess', _422 => _422.getReader, 'call', _423 => _423()]);
       if (!reader) {
-        _optionalChain([callbacks, 'access', _420 => _420.onError, 'optionalCall', _421 => _421("No response body")]);
+        _optionalChain([callbacks, 'access', _424 => _424.onError, 'optionalCall', _425 => _425("No response body")]);
         return;
       }
       const decoder = new TextDecoder();
@@ -6842,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', _422 => _422.onError, 'optionalCall', _423 => _423(`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);
@@ -6875,7 +6938,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
           toolCallsLength: toolCalls.length,
           executableToolCallsLength: executableToolCalls.length,
           hasMcpTools: !!options.mcpTools,
-          mcpToolsLength: _optionalChain([options, 'access', _424 => _424.mcpTools, 'optionalAccess', _425 => _425.length]),
+          mcpToolsLength: _optionalChain([options, 'access', _428 => _428.mcpTools, 'optionalAccess', _429 => _429.length]),
           hasMcpService: !!mcpService
         });
         if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
@@ -6896,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', _426 => _426.content, 'optionalAccess', _427 => _427[0], 'optionalAccess', _428 => _428.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");
@@ -6914,12 +6977,12 @@ ${resultText}`;
         }
       } catch (streamError) {
         logger.error("Stream processing error", streamError instanceof Error ? streamError : void 0);
-        _optionalChain([callbacks, 'access', _429 => _429.onError, 'optionalCall', _430 => _430(`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', _431 => _431.onDone, 'optionalCall', _432 => _432({
+    _optionalChain([callbacks, 'access', _435 => _435.onDone, 'optionalCall', _436 => _436({
       id: messageId,
       role: "assistant",
       content: finalContent,
@@ -6930,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', _433 => _433.onError, 'optionalCall', _434 => _434(message)]);
+    _optionalChain([callbacks, 'access', _437 => _437.onError, 'optionalCall', _438 => _438(message)]);
   }
 }
 
@@ -6981,8 +7044,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _435 => _435.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _436 => _436.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}` };
@@ -7059,18 +7122,18 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       { endpointTransformer: void 0 }
     );
     const data = await transformedResponse.json();
-    const choice = _optionalChain([data, 'access', _437 => _437.choices, 'optionalAccess', _438 => _438[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', _439 => _439.message, 'optionalAccess', _440 => _440.tool_calls]);
-    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _441 => _441.map, 'call', _442 => _442((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', _443 => _443.recorder]) && tapped) {
+    if (_optionalChain([recording, 'optionalAccess', _447 => _447.recorder]) && tapped) {
       recording.recorder.record({
         messageId: _nullishCoalesce(options.messageId, () => ( null)),
         parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -7088,9 +7151,9 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       message: {
         id: `msg_${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice, 'access', _444 => _444.message, 'optionalAccess', _445 => _445.content]) || "",
+        content: _optionalChain([choice, 'access', _448 => _448.message, 'optionalAccess', _449 => _449.content]) || "",
         timestamp: Date.now(),
-        thinking: data.reasoning_content || _optionalChain([choice, 'access', _446 => _446.message, 'optionalAccess', _447 => _447.thinking, 'optionalAccess', _448 => _448.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _449 => _449.message, 'optionalAccess', _450 => _450.thinking, 'optionalAccess', _451 => _451.content]) || "", signature: _optionalChain([choice, 'access', _452 => _452.message, 'optionalAccess', _453 => _453.thinking, 'optionalAccess', _454 => _454.signature]) } : void 0,
+        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 ? {
@@ -7111,21 +7174,21 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _455 => _455.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _456 => _456.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', _457 => _457.onError, 'optionalCall', _458 => _458(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _461 => _461.onError, 'optionalCall', _462 => _462(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _459 => _459.onError, 'optionalCall', _460 => _460(`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', _461 => _461.onError, 'optionalCall', _462 => _462("API key not configured")]);
+      _optionalChain([callbacks, 'access', _465 => _465.onError, 'optionalCall', _466 => _466("API key not configured")]);
       return;
     }
     const { chain, hasTransformers } = await resolveChainWithMain(
@@ -7137,7 +7200,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       return completeStreamFallback(options, callbacks);
     }
     const messageId = `msg_${Date.now()}`;
-    _optionalChain([callbacks, 'access', _463 => _463.onStart, 'optionalCall', _464 => _464(messageId)]);
+    _optionalChain([callbacks, 'access', _467 => _467.onStart, 'optionalCall', _468 => _468(messageId)]);
     const unifiedRequest = buildUnifiedCompletionRequest(actualModel, options, true);
     const transformerProvider = {
       name: provider.name,
@@ -7177,7 +7240,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     });
     if (!response.ok) {
       const errorText = await response.text();
-      _optionalChain([callbacks, 'access', _465 => _465.onError, 'optionalCall', _466 => _466(`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(
@@ -7187,9 +7250,9 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       chain,
       { endpointTransformer: void 0 }
     );
-    const reader = _optionalChain([transformedResponse, 'access', _467 => _467.body, 'optionalAccess', _468 => _468.getReader, 'call', _469 => _469()]);
+    const reader = _optionalChain([transformedResponse, 'access', _471 => _471.body, 'optionalAccess', _472 => _472.getReader, 'call', _473 => _473()]);
     if (!reader) {
-      _optionalChain([callbacks, 'access', _470 => _470.onError, 'optionalCall', _471 => _471("No response body")]);
+      _optionalChain([callbacks, 'access', _474 => _474.onError, 'optionalCall', _475 => _475("No response body")]);
       return;
     }
     const decoder = new TextDecoder();
@@ -7207,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', _472 => _472.choices, 'optionalAccess', _473 => _473[0], 'optionalAccess', _474 => _474.delta]);
-              if (_optionalChain([delta, 'optionalAccess', _475 => _475.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', _476 => _476.onDelta, 'optionalCall', _477 => _477(delta.content)]);
+                _optionalChain([callbacks, 'access', _480 => _480.onDelta, 'optionalCall', _481 => _481(delta.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _478 => _478.thinking, 'optionalAccess', _479 => _479.content])) {
+              if (_optionalChain([delta, 'optionalAccess', _482 => _482.thinking, 'optionalAccess', _483 => _483.content])) {
                 reasoning += delta.thinking.content;
-                _optionalChain([callbacks, 'access', _480 => _480.onReasoning, 'optionalCall', _481 => _481(delta.thinking.content)]);
+                _optionalChain([callbacks, 'access', _484 => _484.onReasoning, 'optionalCall', _485 => _485(delta.thinking.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _482 => _482.reasoning_content])) {
+              if (_optionalChain([delta, 'optionalAccess', _486 => _486.reasoning_content])) {
                 reasoning += delta.reasoning_content;
-                _optionalChain([callbacks, 'access', _483 => _483.onReasoning, 'optionalCall', _484 => _484(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', _485 => _485.recorder]) && tapped) {
+                if (_optionalChain([recording, 'optionalAccess', _489 => _489.recorder]) && tapped) {
                   recording.recorder.record({
                     messageId: _nullishCoalesce(options.messageId, () => ( null)),
                     parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -7235,7 +7298,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
                     rawUsage: json.usage
                   });
                 }
-                _optionalChain([callbacks, 'access', _486 => _486.onDone, 'optionalCall', _487 => _487(
+                _optionalChain([callbacks, 'access', _490 => _490.onDone, 'optionalCall', _491 => _491(
                   {
                     id: messageId,
                     role: "assistant",
@@ -7256,7 +7319,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
           }
         }
       }
-      _optionalChain([callbacks, 'access', _488 => _488.onDone, 'optionalCall', _489 => _489({
+      _optionalChain([callbacks, 'access', _492 => _492.onDone, 'optionalCall', _493 => _493({
         id: messageId,
         role: "assistant",
         content,
@@ -7268,7 +7331,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    _optionalChain([callbacks, 'access', _490 => _490.onError, 'optionalCall', _491 => _491(message)]);
+    _optionalChain([callbacks, 'access', _494 => _494.onError, 'optionalCall', _495 => _495(message)]);
   }
 }
 
@@ -7335,8 +7398,8 @@ var CompletionService = (_class15 = class {
         options.providerId,
         options.model
       );
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _492 => _492.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _493 => _493.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}` };
@@ -7369,7 +7432,7 @@ var CompletionService = (_class15 = class {
         this.apiKeyPool.reportSuccess(options.sessionId);
       }
       if (result.success && result.usage && options.sessionId) {
-        _optionalChain([this, 'access', _494 => _494.usageEventSink, 'optionalAccess', _495 => _495.emit, 'call', _496 => _496({
+        _optionalChain([this, 'access', _498 => _498.usageEventSink, 'optionalAccess', _499 => _499.emit, 'call', _500 => _500({
           sessionId: options.sessionId,
           modelId: actualModel,
           usage: result.usage,
@@ -7398,8 +7461,8 @@ var CompletionService = (_class15 = class {
         options.model
       );
       this.logger.debug("Resolved routed model", { routedInfo });
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _497 => _497.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _498 => _498.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 ? {
@@ -7411,22 +7474,22 @@ var CompletionService = (_class15 = class {
         enabled: provider.enabled
       } : { error: "Provider not found" });
       if (!provider) {
-        _optionalChain([callbacks, 'access', _499 => _499.onError, 'optionalCall', _500 => _500(`Provider not found: ${actualProviderId}`)]);
+        _optionalChain([callbacks, 'access', _503 => _503.onError, 'optionalCall', _504 => _504(`Provider not found: ${actualProviderId}`)]);
         return;
       }
       if (!provider.enabled) {
-        _optionalChain([callbacks, 'access', _501 => _501.onError, 'optionalCall', _502 => _502(`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', _503 => _503.onError, 'optionalCall', _504 => _504("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', _505 => _505.onStart, 'optionalCall', _506 => _506(messageId)]);
+      _optionalChain([callbacks, 'access', _509 => _509.onStart, 'optionalCall', _510 => _510(messageId)]);
       const resolvedOptions = { ...options, model: actualModel };
       if (options.sessionId) {
         const sid = options.sessionId;
@@ -7435,14 +7498,14 @@ var CompletionService = (_class15 = class {
           ...callbacks,
           onDone: (message, usage, metrics) => {
             if (usage) {
-              _optionalChain([this, 'access', _507 => _507.usageEventSink, 'optionalAccess', _508 => _508.emit, 'call', _509 => _509({
+              _optionalChain([this, 'access', _511 => _511.usageEventSink, 'optionalAccess', _512 => _512.emit, 'call', _513 => _513({
                 sessionId: sid,
                 modelId: actualModel,
                 usage,
                 engineOrigin: "completion"
               })]);
             }
-            _optionalChain([userOnDone, 'optionalCall', _510 => _510(message, usage, metrics)]);
+            _optionalChain([userOnDone, 'optionalCall', _514 => _514(message, usage, metrics)]);
           }
         };
       }
@@ -7458,11 +7521,11 @@ var CompletionService = (_class15 = class {
               retryState.error = { status, message: error };
               return;
             }
-            _optionalChain([callbacks, 'access', _511 => _511.onError, 'optionalCall', _512 => _512(error)]);
+            _optionalChain([callbacks, 'access', _515 => _515.onError, 'optionalCall', _516 => _516(error)]);
           },
           onDone: (message, usage, metrics) => {
             this.apiKeyPool.reportSuccess(options.sessionId);
-            _optionalChain([callbacks, 'access', _513 => _513.onDone, 'optionalCall', _514 => _514(message, usage, metrics)]);
+            _optionalChain([callbacks, 'access', _517 => _517.onDone, 'optionalCall', _518 => _518(message, usage, metrics)]);
           }
         };
         await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
@@ -7483,7 +7546,7 @@ var CompletionService = (_class15 = class {
               // don't fire onStart again
             });
           } else {
-            _optionalChain([callbacks, 'access', _515 => _515.onError, 'optionalCall', _516 => _516(retryState.error.message)]);
+            _optionalChain([callbacks, 'access', _519 => _519.onError, 'optionalCall', _520 => _520(retryState.error.message)]);
           }
         }
       } else {
@@ -7496,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', _517 => _517.onError, 'optionalCall', _518 => _518(message)]);
+      _optionalChain([callbacks, 'access', _521 => _521.onError, 'optionalCall', _522 => _522(message)]);
     }
   }
   /**
@@ -7536,7 +7599,7 @@ var CompletionService = (_class15 = class {
         return {
           success: true,
           message: "Connection successful",
-          response: _optionalChain([result, 'access', _519 => _519.message, 'optionalAccess', _520 => _520.content]) || "",
+          response: _optionalChain([result, 'access', _523 => _523.message, 'optionalAccess', _524 => _524.content]) || "",
           model: modelId,
           durationMs
         };
@@ -7601,7 +7664,7 @@ ${description}`;
    * 3. Legacy single key from provider config
    */
   async resolveApiKeyForRequest(provider, providerId, sessionId) {
-    if (_optionalChain([provider, 'access', _521 => _521.codingPlan, 'optionalAccess', _522 => _522.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) {