@omnicross/core 0.1.6 → 0.1.8

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

@@ -1,30 +1,30 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15;
 
+var _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
 
 
-var _chunkEJLH6NFTcjs = require('./chunk-EJLH6NFT.cjs');
 
+var _chunkOXHNSZ53cjs = require('./chunk-OXHNSZ53.cjs');
 
-var _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
 
+var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
 
-var _chunkIIRPUVPHcjs = require('./chunk-IIRPUVPH.cjs');
 
+var _chunkOVQBNVSVcjs = require('./chunk-OVQBNVSV.cjs');
 
-var _chunkGBHYAGX3cjs = require('./chunk-GBHYAGX3.cjs');
 
+var _chunkIIRPUVPHcjs = require('./chunk-IIRPUVPH.cjs');
 
-var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
 
+var _chunkGBHYAGX3cjs = require('./chunk-GBHYAGX3.cjs');
 
-var _chunk6VUQPOV3cjs = require('./chunk-6VUQPOV3.cjs');
 
 
 
-var _chunk4VLRHHFEcjs = require('./chunk-4VLRHHFE.cjs');
 
 
-var _chunkR3HK6R4Bcjs = require('./chunk-R3HK6R4B.cjs');
+
+var _chunk3SCOLIPTcjs = require('./chunk-3SCOLIPT.cjs');
 
 
 var _chunkRPII3E6Zcjs = require('./chunk-RPII3E6Z.cjs');
@@ -34,20 +34,34 @@ var _chunkRPII3E6Zcjs = require('./chunk-RPII3E6Z.cjs');
 var _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
 
 
+
+
+var _chunkJ3QQ6JS5cjs = require('./chunk-J3QQ6JS5.cjs');
+
+
+var _chunkUIBD2YY5cjs = require('./chunk-UIBD2YY5.cjs');
+
+
+var _chunkR3HK6R4Bcjs = require('./chunk-R3HK6R4B.cjs');
+
+
+var _chunkQXD4MV2Xcjs = require('./chunk-QXD4MV2X.cjs');
+
+
 var _chunkNYUNU75Acjs = require('./chunk-NYUNU75A.cjs');
 
 
+var _chunkOTZC4TNHcjs = require('./chunk-OTZC4TNH.cjs');
 
-var _chunkYK57NMIFcjs = require('./chunk-YK57NMIF.cjs');
 
 
-var _chunkYNJNTCSQcjs = require('./chunk-YNJNTCSQ.cjs');
+var _chunkYWL7YZWScjs = require('./chunk-YWL7YZWS.cjs');
 
 
-var _chunkSVNDB62Dcjs = require('./chunk-SVNDB62D.cjs');
+var _chunkYNJNTCSQcjs = require('./chunk-YNJNTCSQ.cjs');
 
 
-var _chunkUIBD2YY5cjs = require('./chunk-UIBD2YY5.cjs');
+var _chunkSVNDB62Dcjs = require('./chunk-SVNDB62D.cjs');
 
 
 var _chunk6QQG7YG3cjs = require('./chunk-6QQG7YG3.cjs');
@@ -64,9 +78,6 @@ var _chunkMUHWHQVMcjs = require('./chunk-MUHWHQVM.cjs');
 var _chunkQ27JY5RGcjs = require('./chunk-Q27JY5RG.cjs');
 
 
-var _chunkQXD4MV2Xcjs = require('./chunk-QXD4MV2X.cjs');
-
-
 var _chunkAPYG5QD7cjs = require('./chunk-APYG5QD7.cjs');
 
 
@@ -85,19 +96,28 @@ var _chunk4YINUUKQcjs = require('./chunk-4YINUUKQ.cjs');
 var _chunk4VZX5F4Tcjs = require('./chunk-4VZX5F4T.cjs');
 
 
+var _chunkQBZJ7P2Tcjs = require('./chunk-QBZJ7P2T.cjs');
+
+
 
 
 var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
 
-var _chunkUNWKG6EIcjs = require('./chunk-UNWKG6EI.cjs');
+var _chunkXPIOJQS2cjs = require('./chunk-XPIOJQS2.cjs');
+
+
 
+var _chunkGDIXXKF2cjs = require('./chunk-GDIXXKF2.cjs');
 
 
-var _chunkWYTEQ4Q5cjs = require('./chunk-WYTEQ4Q5.cjs');
+var _chunkRJUONLUQcjs = require('./chunk-RJUONLUQ.cjs');
 
 
-var _chunkKCVJWJSTcjs = require('./chunk-KCVJWJST.cjs');
+var _chunkHVBBDBS3cjs = require('./chunk-HVBBDBS3.cjs');
+
+
+var _chunkNKVZ6Z3Ycjs = require('./chunk-NKVZ6Z3Y.cjs');
 
 
 var _chunkJMJBSACDcjs = require('./chunk-JMJBSACD.cjs');
@@ -415,12 +435,16 @@ var ProviderProxyRouteMap = (_class = class {
    * (`ANTHROPIC_AUTH_TOKEN` / `OPENAI_API_KEY`). Optionally override the idle
    * timeout (tests use a short one).
    */
-  addRoute(context, idleMs) {
+  addRoute(context, idleMsOrOptions) {
+    const options = typeof idleMsOrOptions === "number" ? { idleMs: idleMsOrOptions } : _nullishCoalesce(idleMsOrOptions, () => ( {}));
     const token = _crypto.randomBytes.call(void 0, TOKEN_BYTES).toString("hex");
     const entry = {
       context,
       idleTimer: null,
-      idleMs: _nullishCoalesce(idleMs, () => ( this.defaultIdleMs))
+      idleMs: _nullishCoalesce(options.idleMs, () => ( this.defaultIdleMs)),
+      onActivity: options.onActivity,
+      onEvicted: options.onEvicted,
+      evicted: false
     };
     this.routes.set(token, entry);
     this.armIdleTimer(token, entry);
@@ -435,6 +459,10 @@ var ProviderProxyRouteMap = (_class = class {
     if (!token) return void 0;
     const entry = this.routes.get(token);
     if (!entry) return void 0;
+    try {
+      _optionalChain([entry, 'access', _5 => _5.onActivity, 'optionalCall', _6 => _6(Date.now())]);
+    } catch (e4) {
+    }
     this.armIdleTimer(token, entry);
     return entry.context;
   }
@@ -442,8 +470,16 @@ var ProviderProxyRouteMap = (_class = class {
   removeRoute(token) {
     const entry = this.routes.get(token);
     if (!entry) return false;
-    this.clearIdleTimer(entry);
     this.routes.delete(token);
+    this.evict(entry, "removed");
+    return true;
+  }
+  /** Re-arm one existing route without rotating its token. */
+  renewRoute(token, idleMs) {
+    const entry = this.routes.get(token);
+    if (!entry) return false;
+    if (idleMs !== void 0) entry.idleMs = idleMs;
+    this.armIdleTimer(token, entry);
     return true;
   }
   /** Current live-route count (tests / diagnostics). */
@@ -456,10 +492,11 @@ var ProviderProxyRouteMap = (_class = class {
   }
   /** Tear down every route (proxy stop / app teardown). */
   clear() {
-    for (const entry of this.routes.values()) {
-      this.clearIdleTimer(entry);
-    }
+    const entries2 = [...this.routes.values()];
     this.routes.clear();
+    for (const entry of entries2) {
+      this.evict(entry, "cleared");
+    }
   }
   // ---------------------------------------------------------------------------
   // Idle reaping (modeled on AcpSessionManager.armIdleTimer / clearIdleTimer)
@@ -467,9 +504,10 @@ var ProviderProxyRouteMap = (_class = class {
   armIdleTimer(token, entry) {
     this.clearIdleTimer(entry);
     entry.idleTimer = setTimeout(() => {
-      this.routes.delete(token);
+      if (!this.routes.delete(token)) return;
+      this.evict(entry, "idle");
     }, entry.idleMs);
-    _optionalChain([entry, 'access', _5 => _5.idleTimer, 'access', _6 => _6.unref, 'optionalCall', _7 => _7()]);
+    _optionalChain([entry, 'access', _7 => _7.idleTimer, 'access', _8 => _8.unref, 'optionalCall', _9 => _9()]);
   }
   clearIdleTimer(entry) {
     if (entry.idleTimer) {
@@ -477,8 +515,77 @@ var ProviderProxyRouteMap = (_class = class {
       entry.idleTimer = null;
     }
   }
+  evict(entry, reason) {
+    if (entry.evicted) return;
+    entry.evicted = true;
+    this.clearIdleTimer(entry);
+    try {
+      _optionalChain([entry, 'access', _10 => _10.onEvicted, 'optionalCall', _11 => _11(reason)]);
+    } catch (e5) {
+    }
+  }
 }, _class);
 
+// src/provider-proxy/identity/claudeCodeHeaders.ts
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+var OAUTH_BETA = "oauth-2025-04-20";
+var CLAUDE_CODE_BETA = "claude-code-20250219";
+var INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+var TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+var DEFAULT_CLAUDE_CODE_HEADERS = Object.freeze({
+  "user-agent": "claude-cli/1.0.119 (external, cli)",
+  "x-app": "cli",
+  accept: "application/json",
+  "accept-language": "*",
+  "sec-fetch-mode": "cors",
+  "anthropic-dangerous-direct-browser-access": "true",
+  "x-stainless-lang": "js",
+  "x-stainless-package-version": "0.55.1",
+  "x-stainless-os": "Windows",
+  "x-stainless-arch": "x64",
+  "x-stainless-runtime": "node",
+  "x-stainless-runtime-version": "v20.19.2",
+  "x-stainless-retry-count": "0",
+  "x-stainless-timeout": "60"
+});
+var FORCED_ACCEPT_ENCODING = "identity";
+var CLAUDE_FORWARD_ALLOWLIST = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-language",
+  "sec-fetch-mode",
+  "user-agent",
+  "x-app",
+  "anthropic-dangerous-direct-browser-access",
+  "anthropic-version"
+]);
+var STAINLESS_PREFIX = "x-stainless-";
+function extractClaudeClientHeaders(reqHeaders) {
+  const out = {};
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    const key = rawKey.toLowerCase();
+    if (_chunk3SCOLIPTcjs.NEVER_FORWARD_HEADERS.has(key)) continue;
+    if (!CLAUDE_FORWARD_ALLOWLIST.has(key) && !key.startsWith(STAINLESS_PREFIX)) continue;
+    const value = _chunk3SCOLIPTcjs.flattenHeaderValue.call(void 0, rawVal);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function buildAnthropicBeta(model, callerBeta) {
+  const isHaiku = typeof model === "string" && model.toLowerCase().includes("haiku");
+  const baseline = isHaiku ? [OAUTH_BETA, INTERLEAVED_THINKING_BETA] : [CLAUDE_CODE_BETA, OAUTH_BETA, INTERLEAVED_THINKING_BETA, TOOL_STREAMING_BETA];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (flag) => {
+    const trimmed = flag.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    out.push(trimmed);
+  };
+  baseline.forEach(add);
+  if (callerBeta) callerBeta.split(",").forEach(add);
+  return out.join(",");
+}
+
 // src/provider-proxy/usage/recordAnthropicUsage.ts
 function readAnthropicUsage(usage) {
   if (!usage) return null;
@@ -506,6 +613,10 @@ function emitAnthropicUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: _nullishCoalesce(_optionalChain([attribution, 'access', _12 => _12.routeLease, 'optionalAccess', _13 => _13.runId]), () => ( null)),
+    routeLeaseId: _nullishCoalesce(_optionalChain([attribution, 'access', _14 => _14.routeLease, 'optionalAccess', _15 => _15.leaseId]), () => ( null)),
+    routeLeaseConsumer: _nullishCoalesce(_optionalChain([attribution, 'access', _16 => _16.routeLease, 'optionalAccess', _17 => _17.consumer]), () => ( null)),
+    routeLeaseStageId: _nullishCoalesce(_optionalChain([attribution, 'access', _18 => _18.routeLease, 'optionalAccess', _19 => _19.stageId]), () => ( null)),
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -520,13 +631,13 @@ function recordAnthropicNonStreamUsage(recorder, bodyText, attribution) {
       parsed.usage,
       attribution
     );
-  } catch (e4) {
+  } catch (e6) {
   }
 }
 function recordAnthropicStreamUsage(recorder, rawUsage, attribution) {
   try {
     emitAnthropicUsageRecord(recorder, rawUsage, attribution);
-  } catch (e5) {
+  } catch (e7) {
   }
 }
 
@@ -540,12 +651,12 @@ function getSharedExecutor() {
 }
 var sharedResponses = null;
 function getResponsesEndpointTransformer() {
-  if (!sharedResponses) sharedResponses = new (0, _chunk6VUQPOV3cjs.OpenAIResponseTransformer)();
+  if (!sharedResponses) sharedResponses = new (0, _chunkOVQBNVSVcjs.OpenAIResponseTransformer)();
   return sharedResponses;
 }
 var sharedAnthropic = null;
 function getAnthropicEndpointTransformer() {
-  if (!sharedAnthropic) sharedAnthropic = new (0, _chunk4VLRHHFEcjs.AnthropicTransformer)();
+  if (!sharedAnthropic) sharedAnthropic = new (0, _chunkOXHNSZ53cjs.AnthropicTransformer)();
   return sharedAnthropic;
 }
 var sharedGemini = null;
@@ -576,7 +687,7 @@ function rewriteJsonModel(bodyText, rewriteModel) {
       changed = true;
     }
     return changed ? JSON.stringify(obj) : bodyText;
-  } catch (e6) {
+  } catch (e8) {
     return bodyText;
   }
 }
@@ -609,7 +720,7 @@ function rewriteSseLine(line, rewriteModel) {
     }
     if (!changed) return line;
     return `data:${leadingSpace}${JSON.stringify(obj)}${newline}`;
-  } catch (e7) {
+  } catch (e9) {
     return line;
   }
 }
@@ -620,7 +731,7 @@ function tapSseDataLine(line, onEvent) {
   if (!payload || payload === "[DONE]") return;
   try {
     onEvent(JSON.parse(payload));
-  } catch (e8) {
+  } catch (e10) {
   }
 }
 async function relaySseBody(res, body, options) {
@@ -653,7 +764,7 @@ async function relaySseBody(res, body, options) {
     res.end();
   }
 }
-async function relayResponse(res, providerResponse, isStream, rewriteModel, usageTap) {
+async function relayResponse(res, providerResponse, isStream, rewriteModel, usageTap, onSseEvent) {
   const contentType = _nullishCoalesce(providerResponse.headers.get("Content-Type"), () => ( ""));
   const status = providerResponse.status && providerResponse.status >= 100 ? providerResponse.status : 200;
   const upstreamIsSse = contentType.includes("text/event-stream");
@@ -667,13 +778,16 @@ async function relayResponse(res, providerResponse, isStream, rewriteModel, usag
       res.end();
       return null;
     }
-    if (rewriteModel || usageTap) {
+    if (rewriteModel || usageTap || onSseEvent) {
       let capturedUsage = null;
       await relaySseBody(res, providerResponse.body, {
         rewriteModel,
-        onSseEvent: usageTap ? (event) => {
-          const raw = usageTap.extractUsage(event);
-          if (raw) capturedUsage = raw;
+        onSseEvent: onSseEvent || usageTap ? (event) => {
+          _optionalChain([onSseEvent, 'optionalCall', _20 => _20(event)]);
+          if (usageTap) {
+            const raw = usageTap.extractUsage(event);
+            if (raw) capturedUsage = raw;
+          }
         } : void 0
       });
       if (capturedUsage) usageTap.onUsage(capturedUsage);
@@ -717,7 +831,7 @@ async function aggregateAnthropicSseToJsonBody(response, rewriteModel) {
     let ev;
     try {
       ev = JSON.parse(payload);
-    } catch (e9) {
+    } catch (e11) {
       continue;
     }
     switch (ev["type"]) {
@@ -772,7 +886,7 @@ async function aggregateAnthropicSseToJsonBody(response, rewriteModel) {
       let input = {};
       try {
         input = blk.inputJson ? JSON.parse(blk.inputJson) : {};
-      } catch (e10) {
+      } catch (e12) {
         input = {};
       }
       return { type: "tool_use", id: _nullishCoalesce(blk.id, () => ( "")), name: _nullishCoalesce(blk.name, () => ( "")), input };
@@ -822,7 +936,7 @@ function resolveApiKey(apiKey) {
 }
 async function resolvePoolBoundKey(deps, providerId, provider, sessionId, preferredKeyId, boundKeyFallbackPolicy) {
   if (preferredKeyId) {
-    const preferred = await _optionalChain([deps, 'access', _8 => _8.apiKeyPool, 'optionalAccess', _9 => _9.getKeyById, 'call', _10 => _10(providerId, preferredKeyId, sessionId)]);
+    const preferred = await _optionalChain([deps, 'access', _21 => _21.apiKeyPool, 'optionalAccess', _22 => _22.getKeyById, 'call', _23 => _23(providerId, preferredKeyId, sessionId)]);
     if (preferred) return preferred;
     if (boundKeyFallbackPolicy !== "pool") return "";
   }
@@ -848,7 +962,7 @@ async function buildSubscriptionPlan(res, route, deps, anthropicBody, routeModel
     resolvedModel = mapped.resolvedModel;
     scenario = mapped.scenario;
   }
-  const sessionKey = _chunkEJLH6NFTcjs.deriveSubscriptionSessionKey.call(void 0, anthropicBody);
+  const sessionKey = _chunkJ3QQ6JS5cjs.deriveSubscriptionSessionKey.call(void 0, anthropicBody);
   const plan = buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey);
   if (!plan) {
     writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
@@ -857,11 +971,11 @@ async function buildSubscriptionPlan(res, route, deps, anthropicBody, routeModel
   return plan;
 }
 function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey) {
-  const upstreamUrl = _optionalChain([profile, 'access', _11 => _11.resolveUpstreamUrl, 'optionalCall', _12 => _12(resolvedModel, route.subscriptionConfig)]);
+  const upstreamUrl = _optionalChain([profile, 'access', _24 => _24.resolveUpstreamUrl, 'optionalCall', _25 => _25(resolvedModel, route.subscriptionConfig)]);
   if (!upstreamUrl) return null;
   const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkYNJNTCSQcjs.SubscriptionAuthSource)(profile)));
   const sameFormat = profile.mode === "pass-through" || upstreamUrl.endsWith("/v1/messages");
-  const overrideNames = _optionalChain([profile, 'access', _13 => _13.resolveProviderTransformerNames, 'optionalCall', _14 => _14(
+  const overrideNames = _optionalChain([profile, 'access', _26 => _26.resolveProviderTransformerNames, 'optionalCall', _27 => _27(
     resolvedModel,
     route.subscriptionConfig
   )]);
@@ -926,7 +1040,7 @@ function buildSubscriptionRequestSummary(anthropicBody) {
     estimatedInputTokens: Math.ceil(totalChars / 4),
     // Single source of truth (shared with the dispatcher builder) so both
     // ingress paths yield identical `matchText` for the same body.
-    matchText: _chunkEJLH6NFTcjs.collectMatchText.call(void 0, anthropicBody)
+    matchText: _chunkJ3QQ6JS5cjs.collectMatchText.call(void 0, anthropicBody)
   };
 }
 function collectText(value) {
@@ -960,7 +1074,7 @@ async function runPipeline(anthropicBody, plan, reportSelection) {
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
     reportSelection: (accountId, isActive) => {
       proxyAccountId = accountId;
-      _optionalChain([reportSelection, 'optionalCall', _15 => _15(accountId, isActive)]);
+      _optionalChain([reportSelection, 'optionalCall', _28 => _28(accountId, isActive)]);
     }
   });
   let rawStatus = null;
@@ -982,10 +1096,19 @@ async function runPipeline(anthropicBody, plan, reportSelection) {
     },
     fetchFn: (url, headers, body) => {
       console.info(`[ProviderProxy:anthropic] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+      return _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
-        { providerId: proxyProviderId(plan), accountId: proxyAccountId }
+        {
+          providerId: proxyProviderId(plan),
+          accountId: proxyAccountId,
+          routeActivity: plan.isSubscription ? {
+            endpoint: "messages",
+            sessionKey: plan.sessionKey,
+            sessionSource: plan.sessionKey ? "content-fingerprint" : "none",
+            model: resolvedModel
+          } : void 0
+        }
       ).then((r) => {
         rawStatus = r.status;
         return r;
@@ -1009,10 +1132,11 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
     reportSelection: (accountId, isActive, remapped) => {
       proxyAccountId = accountId;
       remappedModel = remapped;
-      _optionalChain([reportSelection, 'optionalCall', _16 => _16(accountId, isActive, remapped)]);
+      _optionalChain([reportSelection, 'optionalCall', _29 => _29(accountId, isActive, remapped)]);
     }
   });
-  if (plan.isSubscription && plan.transformerProvider.name === "claude") {
+  const isClaudeSubscription = plan.isSubscription && plan.transformerProvider.name === "claude";
+  if (isClaudeSubscription) {
     _chunk6RPZADX3cjs.applyFingerprint.call(void 0, 
       _chunkRPII3E6Zcjs.getSharedIdentityStore.call(void 0, ),
       headers,
@@ -1021,18 +1145,38 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
       options.callerIdentity
     );
   }
+  if (isClaudeSubscription) {
+    _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, _nullishCoalesce(options.callerClientHeaders, () => ( {})));
+    _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, DEFAULT_CLAUDE_CODE_HEADERS);
+  }
+  _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, { "anthropic-version": DEFAULT_ANTHROPIC_VERSION });
+  headers["accept-encoding"] = FORCED_ACCEPT_ENCODING;
   const applyRemap = remappedModel !== void 0 && outboundRemapApplies(plan);
   const outboundBody = applyRemap ? rewriteBodyModel(rawBody, remappedModel) : rawBody;
   const outboundModel = applyRemap ? remappedModel : plan.resolvedModel;
+  if (isClaudeSubscription) {
+    headers["anthropic-beta"] = buildAnthropicBeta(outboundModel, options.callerAnthropicBeta);
+  } else if (options.callerAnthropicBeta) {
+    _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, { "anthropic-beta": options.callerAnthropicBeta });
+  }
   console.info(
     `[ProviderProxy:anthropic] (subscription same-format) -> ${plan.upstreamUrl} model=${outboundModel} stream=${plan.isStream}`
   );
-  const response = await _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+  const response = await _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
     plan.upstreamUrl,
     { method: "POST", headers, body: outboundBody },
-    { providerId: proxyProviderId(plan), accountId: proxyAccountId }
+    {
+      providerId: proxyProviderId(plan),
+      accountId: proxyAccountId,
+      routeActivity: plan.isSubscription ? {
+        endpoint: "messages",
+        sessionKey: plan.sessionKey,
+        sessionSource: plan.sessionKey ? "content-fingerprint" : "none",
+        model: outboundModel
+      } : void 0
+    }
   );
-  return { response, rawStatus: response.status };
+  return { response, rawStatus: response.status, actualModel: outboundModel };
 }
 function outboundRemapApplies(plan) {
   return plan.isSubscription && plan.transformerProvider.name === "claude";
@@ -1043,7 +1187,7 @@ function rewriteBodyModel(rawBody, model) {
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return rawBody;
     parsed.model = model;
     return JSON.stringify(parsed);
-  } catch (e11) {
+  } catch (e13) {
     return rawBody;
   }
 }
@@ -1056,7 +1200,7 @@ async function runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan
   const first = await runOnce();
   let result = first;
   if (first.rawStatus === 401) {
-    const refreshed = await _optionalChain([plan, 'access', _17 => _17.auth, 'access', _18 => _18.onUnauthorized, 'optionalCall', _19 => _19(plan.sessionKey)]);
+    const refreshed = await _optionalChain([plan, 'access', _30 => _30.auth, 'access', _31 => _31.onUnauthorized, 'optionalCall', _32 => _32(plan.sessionKey)]);
     if (refreshed) {
       console.info("[ProviderProxy:anthropic] 401 \u2192 token refreshed; retrying once");
       result = await runOnce();
@@ -1071,7 +1215,7 @@ async function readBoundedBody(response, max = 2048) {
   try {
     const text = await response.clone().text();
     return text.slice(0, max);
-  } catch (e12) {
+  } catch (e14) {
     return void 0;
   }
 }
@@ -1079,9 +1223,9 @@ async function markSubscriptionHealth(plan, selectedAccountId, result) {
   if (!plan.isSubscription || selectedAccountId === void 0) return;
   const providerId = plan.transformerProvider.name;
   const status = result.rawStatus;
-  const { resetHeaderSeconds, retryAfterSeconds } = _chunkYK57NMIFcjs.resolveResetSeconds.call(void 0, providerId, result.response.headers);
+  const { resetHeaderSeconds, retryAfterSeconds } = _chunkYWL7YZWScjs.resolveResetSeconds.call(void 0, providerId, result.response.headers);
   const bodyText = status === 403 ? await readBoundedBody(result.response) : void 0;
-  _chunkYK57NMIFcjs.getSharedAccountHealth.call(void 0, ).recordUpstreamOutcome(providerId, selectedAccountId, {
+  _chunkYWL7YZWScjs.getSharedAccountHealth.call(void 0, ).recordUpstreamOutcome(providerId, selectedAccountId, {
     status,
     resetHeaderSeconds,
     retryAfterSeconds,
@@ -1099,7 +1243,7 @@ function breakerOutcome(rawStatus) {
 function recordBreakerOutcome(profile, modelId, rawStatus) {
   const outcome = breakerOutcome(rawStatus);
   if (outcome === "neutral") return;
-  _optionalChain([profile, 'optionalAccess', _20 => _20.recordModelOutcome, 'optionalCall', _21 => _21(modelId, outcome === "success")]);
+  _optionalChain([profile, 'optionalAccess', _33 => _33.recordModelOutcome, 'optionalCall', _34 => _34(modelId, outcome === "success")]);
 }
 async function runSubscriptionAttemptOutcome(anthropicBody, relayBody, plan, options = {}) {
   try {
@@ -1118,7 +1262,7 @@ function settleOutcome(outcome) {
 async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialPlan, route, deps, options = {}) {
   const profile = route.subscriptionProfile;
   const scenario = initialPlan.scenario;
-  if (!_optionalChain([profile, 'optionalAccess', _22 => _22.nextFallback]) || scenario === void 0) {
+  if (!_optionalChain([profile, 'optionalAccess', _35 => _35.nextFallback]) || scenario === void 0) {
     const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan, options);
     recordBreakerOutcome(profile, initialPlan.resolvedModel, outcomeStatus(loneOutcome));
     return settleOutcome(loneOutcome);
@@ -1182,7 +1326,7 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
   let anthropicBody;
   try {
     anthropicBody = JSON.parse(rawBody);
-  } catch (e13) {
+  } catch (e15) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -1198,11 +1342,13 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
     const upstreamSse = (_nullishCoalesce(upstreamResponse.headers.get("content-type"), () => ( ""))).includes(
       "text/event-stream"
     );
+    const actualModel = "actualModel" in providerResponse && typeof providerResponse.actualModel === "string" ? providerResponse.actualModel : void 0;
     const usageAttribution = {
       sessionId: route.sessionId,
       providerId: _nullishCoalesce(route.providerId, () => ( "anthropic")),
-      model: plan.resolvedModel,
+      model: _nullishCoalesce(actualModel, () => ( plan.resolvedModel)),
       apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1212,7 +1358,7 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
       extractUsage(event) {
         if (event["type"] === "message_start") {
           const msg = event["message"];
-          const u = _optionalChain([msg, 'optionalAccess', _23 => _23["usage"]]);
+          const u = _optionalChain([msg, 'optionalAccess', _36 => _36["usage"]]);
           if (u) anthropicInputUsage = u;
           return null;
         }
@@ -1302,7 +1448,7 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     isSubscription: false,
     provider,
     apiKey,
-    extendedContextEnabled: _nullishCoalesce(_optionalChain([route, 'access', _24 => _24.anthropicSdkHints, 'optionalAccess', _25 => _25.extendedContext, 'optionalAccess', _26 => _26.enabled]), () => ( false))
+    extendedContextEnabled: _nullishCoalesce(_optionalChain([route, 'access', _37 => _37.anthropicSdkHints, 'optionalAccess', _38 => _38.extendedContext, 'optionalAccess', _39 => _39.enabled]), () => ( false))
   };
 }
 async function runSameFormatFetch(bodyToSend, plan, options, keyOverride) {
@@ -1312,7 +1458,7 @@ async function runSameFormatFetch(bodyToSend, plan, options, keyOverride) {
   }
   const effectiveKey = _nullishCoalesce(_nullishCoalesce(keyOverride, () => ( apiKey)), () => ( ""));
   const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, effectiveKey);
-  const callerBeta = _optionalChain([options, 'access', _27 => _27.callerAnthropicBeta, 'optionalAccess', _28 => _28.trim, 'call', _29 => _29()]);
+  const callerBeta = _optionalChain([options, 'access', _40 => _40.callerAnthropicBeta, 'optionalAccess', _41 => _41.trim, 'call', _42 => _42()]);
   if (callerBeta) {
     const existing = _nullishCoalesce(headers["anthropic-beta"], () => ( headers["Anthropic-Beta"]));
     const parts = new Set(
@@ -1326,7 +1472,7 @@ async function runSameFormatFetch(bodyToSend, plan, options, keyOverride) {
   _chunkGBHYAGX3cjs.injectExtendedContextBeta.call(void 0, headers, resolvedModel, _nullishCoalesce(extendedContextEnabled, () => ( false)));
   const url = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: resolvedModel, stream: isStream });
   console.info(`[ProviderProxy:anthropic] (same-format) -> ${url} model=${resolvedModel} stream=${isStream}`);
-  const response = await _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+  const response = await _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
     url,
     { method: "POST", headers, body: bodyToSend },
     { providerId: "byo" }
@@ -1338,7 +1484,7 @@ function resolveSameFormatBody(anthropicBody, rawBody, plan) {
   try {
     const m = JSON.parse(rawBody).model;
     originalModel = typeof m === "string" ? m : void 0;
-  } catch (e14) {
+  } catch (e16) {
     originalModel = void 0;
   }
   return plan.resolvedModel !== originalModel ? JSON.stringify(anthropicBody) : rawBody;
@@ -1347,8 +1493,8 @@ async function runPipelineWithPoolReporting(anthropicBody, rawBody, plan, option
   const sameFormatBody = plan.sameFormat ? resolveSameFormatBody(anthropicBody, rawBody, plan) : rawBody;
   const runOnce = (keyOverride) => plan.sameFormat ? runSameFormatFetch(sameFormatBody, plan, options, keyOverride) : runPipeline(anthropicBody, plan);
   const first = await runOnce();
-  const outcome = await _optionalChain([plan, 'access', _30 => _30.auth, 'access', _31 => _31.onResult, 'optionalCall', _32 => _32(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _33 => _33.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _43 => _43.auth, 'access', _44 => _44.onResult, 'optionalCall', _45 => _45(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _46 => _46.rebound])) {
     console.info(
       "[ProviderProxy:anthropic] pool re-bound key after status",
       first.rawStatus,
@@ -1370,7 +1516,12 @@ async function handleAnthropicMessagesRequest(req, res, route, deps) {
     const callerBetaRaw = req.headers["anthropic-beta"];
     const callerAnthropicBeta = Array.isArray(callerBetaRaw) ? callerBetaRaw.join(",") : callerBetaRaw;
     const callerIdentity = _chunk6RPZADX3cjs.captureCallerIdentity.call(void 0, _chunkRPII3E6Zcjs.getSharedIdentityStore.call(void 0, ), req.headers);
-    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta, callerIdentity });
+    const callerClientHeaders = extractClaudeClientHeaders(req.headers);
+    await handleAnthropicMessagesByo(res, rawBody, route, deps, {
+      callerAnthropicBeta,
+      callerIdentity,
+      callerClientHeaders
+    });
     return;
   }
   const hints = route.anthropicSdkHints;
@@ -1456,6 +1607,10 @@ function emitGeminiUsageRecord(recorder, rawUsageMetadata, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: _nullishCoalesce(_optionalChain([attribution, 'access', _47 => _47.routeLease, 'optionalAccess', _48 => _48.runId]), () => ( null)),
+    routeLeaseId: _nullishCoalesce(_optionalChain([attribution, 'access', _49 => _49.routeLease, 'optionalAccess', _50 => _50.leaseId]), () => ( null)),
+    routeLeaseConsumer: _nullishCoalesce(_optionalChain([attribution, 'access', _51 => _51.routeLease, 'optionalAccess', _52 => _52.consumer]), () => ( null)),
+    routeLeaseStageId: _nullishCoalesce(_optionalChain([attribution, 'access', _53 => _53.routeLease, 'optionalAccess', _54 => _54.stageId]), () => ( null)),
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1470,13 +1625,13 @@ function recordGeminiNonStreamUsage(recorder, bodyText, attribution) {
       parsed.usageMetadata,
       attribution
     );
-  } catch (e15) {
+  } catch (e17) {
   }
 }
 function recordGeminiStreamUsage(recorder, rawUsageMetadata, attribution) {
   try {
     emitGeminiUsageRecord(recorder, rawUsageMetadata, attribution);
-  } catch (e16) {
+  } catch (e18) {
   }
 }
 
@@ -1485,14 +1640,14 @@ var GENERATE_CONTENT_ACTION = ":generateContent";
 var STREAM_GENERATE_CONTENT_ACTION = ":streamGenerateContent";
 function isGeminiGenerateContentRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _34 => _34.split, 'call', _35 => _35("?"), 'access', _36 => _36[0], 'optionalAccess', _37 => _37.replace, 'call', _38 => _38(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _55 => _55.split, 'call', _56 => _56("?"), 'access', _57 => _57[0], 'optionalAccess', _58 => _58.replace, 'call', _59 => _59(/\/+$/, "")]), () => ( ""));
   const lastSegment = _nullishCoalesce(path.split("/").pop(), () => ( ""));
   return lastSegment.includes(STREAM_GENERATE_CONTENT_ACTION) || lastSegment.includes(GENERATE_CONTENT_ACTION);
 }
 function isGeminiStreamRequest(url) {
   if (!url) return false;
   const [path, query = ""] = url.split("?");
-  const lastSegment = _nullishCoalesce((_nullishCoalesce(_optionalChain([path, 'optionalAccess', _39 => _39.replace, 'call', _40 => _40(/\/+$/, "")]), () => ( ""))).split("/").pop(), () => ( ""));
+  const lastSegment = _nullishCoalesce((_nullishCoalesce(_optionalChain([path, 'optionalAccess', _60 => _60.replace, 'call', _61 => _61(/\/+$/, "")]), () => ( ""))).split("/").pop(), () => ( ""));
   if (lastSegment.includes(STREAM_GENERATE_CONTENT_ACTION)) return true;
   return /(^|&)alt=sse(&|$)/.test(query);
 }
@@ -1500,7 +1655,7 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
   let geminiBody;
   try {
     geminiBody = JSON.parse(rawBody);
-  } catch (e17) {
+  } catch (e19) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -1521,6 +1676,7 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
       providerId: _nullishCoalesce(route.providerId, () => ( "gemini")),
       model: resolvedModel,
       apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1622,7 +1778,7 @@ async function runPipeline2(geminiBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.log(`[ProviderProxy:gemini] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+      return _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
         { providerId: "byo" }
@@ -1637,8 +1793,8 @@ async function runPipeline2(geminiBody, plan) {
 }
 async function runPipelineWithPoolReporting2(geminiBody, plan) {
   const first = await runPipeline2(geminiBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _41 => _41.auth, 'access', _42 => _42.onResult, 'optionalCall', _43 => _43(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _44 => _44.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _62 => _62.auth, 'access', _63 => _63.onResult, 'optionalCall', _64 => _64(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _65 => _65.rebound])) {
     console.log(
       "[ProviderProxy:gemini] pool re-bound key after status",
       first.rawStatus,
@@ -1677,6 +1833,10 @@ function emitChatCompletionsUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: _nullishCoalesce(_optionalChain([attribution, 'access', _66 => _66.routeLease, 'optionalAccess', _67 => _67.runId]), () => ( null)),
+    routeLeaseId: _nullishCoalesce(_optionalChain([attribution, 'access', _68 => _68.routeLease, 'optionalAccess', _69 => _69.leaseId]), () => ( null)),
+    routeLeaseConsumer: _nullishCoalesce(_optionalChain([attribution, 'access', _70 => _70.routeLease, 'optionalAccess', _71 => _71.consumer]), () => ( null)),
+    routeLeaseStageId: _nullishCoalesce(_optionalChain([attribution, 'access', _72 => _72.routeLease, 'optionalAccess', _73 => _73.stageId]), () => ( null)),
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1691,20 +1851,20 @@ function recordChatCompletionsNonStreamUsage(recorder, bodyText, attribution) {
       parsed.usage,
       attribution
     );
-  } catch (e18) {
+  } catch (e20) {
   }
 }
 function recordChatCompletionsStreamUsage(recorder, rawUsage, attribution) {
   try {
     emitChatCompletionsUsageRecord(recorder, rawUsage, attribution);
-  } catch (e19) {
+  } catch (e21) {
   }
 }
 
 // src/provider-proxy/ingress/openaiChatIngress.ts
 function isOpenAIChatRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _45 => _45.split, 'call', _46 => _46("?"), 'access', _47 => _47[0], 'optionalAccess', _48 => _48.replace, 'call', _49 => _49(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _74 => _74.split, 'call', _75 => _75("?"), 'access', _76 => _76[0], 'optionalAccess', _77 => _77.replace, 'call', _78 => _78(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/chat/completions");
 }
 var CHAT_BRIDGE_SUBSCRIPTION_PROVIDERS = /* @__PURE__ */ new Set(["claude"]);
@@ -1713,7 +1873,7 @@ async function handleOpenAIChatRequest(res, rawBody, route, deps) {
   let chatBody;
   try {
     chatBody = JSON.parse(rawBody);
-  } catch (e20) {
+  } catch (e22) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -1729,6 +1889,7 @@ async function handleOpenAIChatRequest(res, rawBody, route, deps) {
       providerId: _nullishCoalesce(route.providerId, () => ( "openai")),
       model: resolvedModel,
       apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1826,7 +1987,7 @@ async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream)
     );
     return null;
   }
-  const upstreamUrl = _optionalChain([profile, 'access', _50 => _50.resolveUpstreamUrl, 'optionalCall', _51 => _51(resolvedModel)]);
+  const upstreamUrl = _optionalChain([profile, 'access', _79 => _79.resolveUpstreamUrl, 'optionalCall', _80 => _80(resolvedModel)]);
   if (!upstreamUrl) {
     writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
     return null;
@@ -1891,7 +2052,7 @@ async function runPipeline3(chatBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.log(`[ProviderProxy:chat] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+      return _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
         { providerId: plan.proxyProviderId, accountId: proxyAccountId }
@@ -1906,8 +2067,8 @@ async function runPipeline3(chatBody, plan) {
 }
 async function runPipelineWithPoolReporting3(chatBody, plan) {
   const first = await runPipeline3(chatBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _52 => _52.auth, 'access', _53 => _53.onResult, 'optionalCall', _54 => _54(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _55 => _55.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _81 => _81.auth, 'access', _82 => _82.onResult, 'optionalCall', _83 => _83(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _84 => _84.rebound])) {
     console.log(
       "[ProviderProxy:chat] pool re-bound key after status",
       first.rawStatus,
@@ -1920,7 +2081,7 @@ async function runPipelineWithPoolReporting3(chatBody, plan) {
 async function runPipelineWithSubscriptionRetry2(chatBody, plan) {
   const first = await runPipeline3(chatBody, plan);
   if (first.rawStatus !== 401) return first;
-  const refreshed = await _optionalChain([plan, 'access', _56 => _56.auth, 'access', _57 => _57.onUnauthorized, 'optionalCall', _58 => _58()]);
+  const refreshed = await _optionalChain([plan, 'access', _85 => _85.auth, 'access', _86 => _86.onUnauthorized, 'optionalCall', _87 => _87()]);
   if (!refreshed) {
     console.warn("[ProviderProxy:chat] 401 not recoverable (onUnauthorized returned false)");
     return first;
@@ -1957,6 +2118,12 @@ function emitResponsesUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: _nullishCoalesce(_optionalChain([attribution, 'access', _88 => _88.routeLease, 'optionalAccess', _89 => _89.runId]), () => ( null)),
+    routeLeaseId: _nullishCoalesce(_optionalChain([attribution, 'access', _90 => _90.routeLease, 'optionalAccess', _91 => _91.leaseId]), () => ( null)),
+    routeLeaseConsumer: _nullishCoalesce(_optionalChain([attribution, 'access', _92 => _92.routeLease, 'optionalAccess', _93 => _93.consumer]), () => ( null)),
+    routeLeaseStageId: _nullishCoalesce(_optionalChain([attribution, 'access', _94 => _94.routeLease, 'optionalAccess', _95 => _95.stageId]), () => ( null)),
+    cacheKeySource: attribution.cacheKeySource,
+    cacheKeyInjected: attribution.cacheKeyInjected,
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1971,32 +2138,92 @@ function recordResponsesNonStreamUsage(recorder, bodyText, attribution) {
       parsed.usage,
       attribution
     );
-  } catch (e21) {
+  } catch (e23) {
   }
 }
 function recordResponsesStreamUsage(recorder, rawUsage, attribution) {
   try {
     emitResponsesUsageRecord(recorder, rawUsage, attribution);
-  } catch (e22) {
+  } catch (e24) {
   }
 }
 
+// src/provider-proxy/ingress/codexUsageLimitDetection.ts
+var PROVIDER_ID = "codex";
+var DEFAULT_QUOTA_COOLDOWN_MS = 5 * 6e4;
+var QUOTA_EXHAUSTED_PERCENT = 90;
+function parseTryAgainDeadline(bodyText) {
+  const match = bodyText.match(/try again (?:at|on)\s+(.+?)(?:[.\n]|$)/i);
+  if (!match) return void 0;
+  const cleaned = match[1].replace(/(\d+)(st|nd|rd|th)/giu, "$1").trim();
+  const ms = Date.parse(cleaned);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+function deadlineFromAllowanceSnapshot(accountId, now) {
+  const snapshot = _chunkHVBBDBS3cjs.getSharedAccountAllowanceStore.call(void 0, ).get(PROVIDER_ID, accountId, now);
+  if (!snapshot) return void 0;
+  const candidates = snapshot.windows.filter(
+    (w) => typeof w.usedPercent === "number" && w.usedPercent >= QUOTA_EXHAUSTED_PERCENT && typeof w.resetsAt === "string"
+  ).map((w) => ({ ms: Date.parse(w.resetsAt), usedPercent: w.usedPercent })).filter((x) => Number.isFinite(x.ms) && x.ms > now).sort((a, b) => b.usedPercent - a.usedPercent);
+  return _optionalChain([candidates, 'access', _96 => _96[0], 'optionalAccess', _97 => _97.ms]);
+}
+function resolveCodexQuotaDeadline(accountId, bodyText, now = Date.now()) {
+  const parsed = parseTryAgainDeadline(bodyText);
+  const parsedDeadline = parsed !== void 0 && parsed > now ? parsed : void 0;
+  return _nullishCoalesce(_nullishCoalesce(deadlineFromAllowanceSnapshot(accountId, now), () => ( parsedDeadline)), () => ( now + DEFAULT_QUOTA_COOLDOWN_MS));
+}
+function markCodexUsageLimitExhaustion(accountId, bodyText, now = Date.now()) {
+  if (!accountId) return;
+  const deadline = resolveCodexQuotaDeadline(accountId, bodyText, now);
+  _chunkYWL7YZWScjs.getSharedAccountHealth.call(void 0, ).markQuotaExhausted(PROVIDER_ID, accountId, deadline, now);
+}
+
 // src/provider-proxy/ingress/openaiResponsesIngress.ts
+var SERVER_OVERLOADED_CODES = /* @__PURE__ */ new Set(["server_is_overloaded", "slow_down"]);
+function isCodexServerOverloadEvent(event) {
+  if (event["type"] !== "response.failed") return false;
+  const error = _optionalChain([event, 'access', _98 => _98["response"], 'optionalAccess', _99 => _99["error"]]);
+  const code = _optionalChain([error, 'optionalAccess', _100 => _100["code"]]);
+  return typeof code === "string" && SERVER_OVERLOADED_CODES.has(code);
+}
 function isOpenAIResponsesRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _59 => _59.split, 'call', _60 => _60("?"), 'access', _61 => _61[0], 'optionalAccess', _62 => _62.replace, 'call', _63 => _63(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _101 => _101.split, 'call', _102 => _102("?"), 'access', _103 => _103[0], 'optionalAccess', _104 => _104.replace, 'call', _105 => _105(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/responses");
 }
+var SAFE_INJECTED_CACHE_KEY_SOURCES = /* @__PURE__ */ new Set([
+  "session-header",
+  "thread-header",
+  "body-session-id",
+  "body-thread-id",
+  "content-fingerprint"
+]);
+function isSafeInjectedCacheKeySource(source) {
+  return SAFE_INJECTED_CACHE_KEY_SOURCES.has(source);
+}
+function ensureCodexPromptCacheKey(body, proxyProviderId2, derivedSession) {
+  if (typeof body.prompt_cache_key === "string" && body.prompt_cache_key.trim()) {
+    return { cacheKeySource: "client", cacheKeyInjected: false };
+  }
+  if (proxyProviderId2 !== "codex" || !isSafeInjectedCacheKeySource(derivedSession.source)) {
+    return { cacheKeySource: "none", cacheKeyInjected: false };
+  }
+  body.prompt_cache_key = `omnicross:${derivedSession.source}:${derivedSession.key}`;
+  return {
+    cacheKeySource: derivedSession.source,
+    cacheKeyInjected: true
+  };
+}
 async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHeaders = {}) {
   let responsesBody;
   try {
     responsesBody = JSON.parse(rawBody);
-  } catch (e23) {
+  } catch (e25) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
   const isStream = responsesBody.stream === true;
-  const derivedSession = _chunkEJLH6NFTcjs.deriveGatewaySessionKey.call(void 0, responsesBody, requestHeaders, {
+  const derivedSession = _chunkJ3QQ6JS5cjs.deriveGatewaySessionKey.call(void 0, responsesBody, requestHeaders, {
     endpoint: "responses",
     // A verified outbound key is the strongest route-local fallback. Resident
     // proxy callers without one still get a stable run/session bucket; the
@@ -2007,14 +2234,32 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHe
   const resolvedModel = route.model;
   responsesBody.model = resolvedModel;
   try {
-    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan3(
+      res,
+      route,
+      deps,
+      resolvedModel,
+      isStream,
+      sessionKey,
+      derivedSession.source,
+      requestHeaders
+    ) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
     if (!plan) return;
-    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry3(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    const cacheKeyAttribution = ensureCodexPromptCacheKey(
+      responsesBody,
+      plan.proxyProviderId,
+      derivedSession
+    );
+    let providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry3(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    providerResponse = await retryAroundCodexUsageLimit(responsesBody, plan, providerResponse);
     const usageAttribution = {
       sessionId: route.sessionId,
       providerId: _nullishCoalesce(route.providerId, () => ( "codex")),
-      model: resolvedModel,
+      model: _nullishCoalesce(providerResponse.actualModel, () => ( resolvedModel)),
       apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+      routeLease: route.routeLease,
+      cacheKeySource: cacheKeyAttribution.cacheKeySource,
+      cacheKeyInjected: cacheKeyAttribution.cacheKeyInjected,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -2023,19 +2268,40 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHe
       extractUsage(event) {
         if (event["type"] !== "response.completed") return null;
         const response = event["response"];
-        const usage = _optionalChain([response, 'optionalAccess', _64 => _64["usage"]]);
+        const usage = _optionalChain([response, 'optionalAccess', _106 => _106["usage"]]);
         return _nullishCoalesce(usage, () => ( null));
       },
       onUsage(rawUsage) {
         recordResponsesStreamUsage(usageRecorder, rawUsage, usageAttribution);
       }
     } : void 0;
+    const overloadActivityId = providerResponse.activityRecordId;
+    const overloadAccountId = providerResponse.accountId;
+    const overloadProviderId = plan.proxyProviderId;
+    let overloadRecorded = false;
+    const overloadDetector = (event) => {
+      if (overloadRecorded || !isCodexServerOverloadEvent(event)) return;
+      overloadRecorded = true;
+      if (overloadActivityId) {
+        _chunkNKVZ6Z3Ycjs.getSharedAccountRouteActivity.call(void 0, ).amend(overloadActivityId, {
+          streamError: "server_overloaded"
+        });
+      }
+      if (overloadAccountId) {
+        _chunkOTZC4TNHcjs.getSharedOverloadCounter.call(void 0, ).recordOverload({
+          providerId: overloadProviderId,
+          accountId: overloadAccountId,
+          endpoint: "responses"
+        });
+      }
+    };
     const bodyText = await relayResponse(
       res,
       providerResponse.response,
       isStream,
       route.requestedModel,
-      usageTap
+      usageTap,
+      overloadDetector
     );
     if (bodyText && deps.usageRecorder) {
       recordResponsesNonStreamUsage(deps.usageRecorder, bodyText, usageAttribution);
@@ -2099,13 +2365,13 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     proxyProviderId: "byo"
   };
 }
-async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey) {
+async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey, sessionSource, requestHeaders) {
   const profile = route.subscriptionProfile;
   if (!profile) {
     writeError(res, 502, "Subscription mode requires a codex subscription profile");
     return null;
   }
-  const upstreamUrl = _optionalChain([profile, 'access', _65 => _65.resolveUpstreamUrl, 'optionalCall', _66 => _66(resolvedModel)]);
+  const upstreamUrl = _optionalChain([profile, 'access', _107 => _107.resolveUpstreamUrl, 'optionalCall', _108 => _108(resolvedModel)]);
   if (!upstreamUrl) {
     writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
     return null;
@@ -2142,6 +2408,7 @@ async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream,
   return {
     auth,
     sessionKey,
+    sessionSource,
     preferredAccountId: route.preferredAccountId,
     preferredAccountGroup: route.preferredAccountGroup,
     boundAccountFallbackPolicy: route.boundAccountFallbackPolicy,
@@ -2154,7 +2421,10 @@ async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream,
     // profile's `resolveUpstreamUrl` for non-Code-Assist subscriptions.
     resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : typeof config.url === "string" ? config.url : upstreamUrl,
     upstreamUrl,
-    proxyProviderId: profile.authStrategy.providerId
+    proxyProviderId: profile.authStrategy.providerId,
+    // Only the codex backend understands these; other subscription providers
+    // (gemini Code Assist) share this relay and must not receive them.
+    callerClientHeaders: profile.authStrategy.providerId === "codex" ? _chunk3SCOLIPTcjs.extractCodexClientHeaders.call(void 0, requestHeaders) : void 0
   };
 }
 async function resolveGeminiCodeAssistProject(profile, hints) {
@@ -2172,6 +2442,8 @@ async function runPipeline4(responsesBody, plan) {
   const endpointTransformer = getResponsesEndpointTransformer();
   const { auth, sessionKey, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
   let proxyAccountId;
+  let actualModel = resolvedModel;
+  let activityRecordId;
   const authHeaders = {};
   await auth.applyHeaders(authHeaders, {
     upstreamUrl,
@@ -2180,10 +2452,13 @@ async function runPipeline4(responsesBody, plan) {
     preferredAccountId: plan.preferredAccountId,
     preferredAccountGroup: plan.preferredAccountGroup,
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
-    reportSelection: (accountId) => {
+    reportSelection: (accountId, _isActive, remappedModel) => {
       proxyAccountId = accountId;
+      if (remappedModel) actualModel = remappedModel;
     }
   });
+  responsesBody.model = actualModel;
+  transformerProvider.models = [actualModel];
   let rawStatus = null;
   const { response } = await _chunkMUHWHQVMcjs.executeProviderCall.call(void 0, {
     executor,
@@ -2199,14 +2474,31 @@ async function runPipeline4(responsesBody, plan) {
           if (value !== void 0 && !(key in headers)) headers[key] = value;
         }
       }
+      if (plan.proxyProviderId === "codex") {
+        _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, _nullishCoalesce(plan.callerClientHeaders, () => ( {})));
+        _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, _chunk3SCOLIPTcjs.DEFAULT_CODEX_CLI_HEADERS);
+        _chunk3SCOLIPTcjs.fillMissingHeaders.call(void 0, headers, { accept: _chunk3SCOLIPTcjs.codexAcceptHeader.call(void 0, isStream) });
+      }
       return headers;
     },
     fetchFn: (url, headers, body) => {
-      console.log(`[ProviderProxy:responses] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return _chunkKCVJWJSTcjs.fetchUpstream.call(void 0, 
+      console.log(`[ProviderProxy:responses] -> ${url} model=${actualModel} stream=${isStream}`);
+      return _chunkRJUONLUQcjs.fetchUpstream.call(void 0, 
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
-        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+        {
+          providerId: plan.proxyProviderId,
+          accountId: proxyAccountId,
+          routeActivity: plan.proxyProviderId === "byo" ? void 0 : {
+            endpoint: "responses",
+            sessionKey,
+            sessionSource: _nullishCoalesce(plan.sessionSource, () => ( "none")),
+            model: actualModel,
+            onRecorded: (record) => {
+              activityRecordId = record.id;
+            }
+          }
+        }
       ).then((r) => {
         rawStatus = r.status;
         return r;
@@ -2214,12 +2506,12 @@ async function runPipeline4(responsesBody, plan) {
     },
     runResponseChain: true
   });
-  return { response, rawStatus };
+  return { response, rawStatus, accountId: proxyAccountId, actualModel, activityRecordId };
 }
 async function runPipelineWithPoolReporting4(responsesBody, plan) {
   const first = await runPipeline4(responsesBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _67 => _67.auth, 'access', _68 => _68.onResult, 'optionalCall', _69 => _69(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _70 => _70.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _109 => _109.auth, 'access', _110 => _110.onResult, 'optionalCall', _111 => _111(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _112 => _112.rebound])) {
     console.log(
       "[ProviderProxy:responses] pool re-bound key after status",
       first.rawStatus,
@@ -2232,7 +2524,7 @@ async function runPipelineWithPoolReporting4(responsesBody, plan) {
 async function runPipelineWithSubscriptionRetry3(responsesBody, plan) {
   const first = await runPipeline4(responsesBody, plan);
   if (first.rawStatus !== 401) return first;
-  const refreshed = await _optionalChain([plan, 'access', _71 => _71.auth, 'access', _72 => _72.onUnauthorized, 'optionalCall', _73 => _73(plan.sessionKey)]);
+  const refreshed = await _optionalChain([plan, 'access', _113 => _113.auth, 'access', _114 => _114.onUnauthorized, 'optionalCall', _115 => _115(plan.sessionKey)]);
   if (!refreshed) {
     console.warn("[ProviderProxy:responses] 401 not recoverable (onUnauthorized returned false)");
     return first;
@@ -2240,6 +2532,22 @@ async function runPipelineWithSubscriptionRetry3(responsesBody, plan) {
   console.log("[ProviderProxy:responses] 401 \u2192 token refreshed; retrying once");
   return runPipeline4(responsesBody, plan);
 }
+var MAX_QUOTA_RETRIES = 3;
+function isCodexAccountQuota429(plan, result) {
+  return plan.proxyProviderId === "codex" && !!result.accountId && result.rawStatus === 429;
+}
+async function retryAroundCodexUsageLimit(responsesBody, plan, first, runAttempt = runPipelineWithSubscriptionRetry3) {
+  if (!isCodexAccountQuota429(plan, first)) return first;
+  let current = first;
+  for (let attempt = 0; attempt < MAX_QUOTA_RETRIES; attempt++) {
+    const errorBody = await current.response.text().catch(() => "");
+    markCodexUsageLimitExhaustion(current.accountId, errorBody);
+    const next = await runAttempt(responsesBody, plan);
+    if (!isCodexAccountQuota429(plan, next)) return next;
+    current = next;
+  }
+  return current;
+}
 
 // src/provider-proxy/providerProxyRouter.ts
 function extractRouteToken(authHeader) {
@@ -2254,7 +2562,7 @@ function resolveRouteToken(req) {
   if (fromAuth) return fromAuth;
   const googKey = req.headers["x-goog-api-key"];
   const value = Array.isArray(googKey) ? googKey[0] : googKey;
-  return _optionalChain([value, 'optionalAccess', _74 => _74.trim, 'call', _75 => _75()]) || void 0;
+  return _optionalChain([value, 'optionalAccess', _116 => _116.trim, 'call', _117 => _117()]) || void 0;
 }
 async function routeRequest(req, res, routes, deps) {
   const token = resolveRouteToken(req);
@@ -2294,7 +2602,7 @@ function isLoopbackAddress(addr) {
   return normalized === "127.0.0.1" || normalized.startsWith("127.") || normalized === "::1" || addr === "::1";
 }
 var ProviderProxy = (_class2 = class {
-  constructor(deps, routes) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+  constructor(deps, routes) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
     this.deps = deps;
     this.routes = _nullishCoalesce(routes, () => ( new ProviderProxyRouteMap()));
   }
@@ -2302,6 +2610,7 @@ var ProviderProxy = (_class2 = class {
   __init2() {this.server = null}
   __init3() {this.port = 0}
   
+  __init4() {this.beforeStop = /* @__PURE__ */ new Set()}
   /**
    * Start the resident listener on a stable port on 127.0.0.1. Idempotent —
    * a second `start()` returns the already-bound port.
@@ -2342,6 +2651,12 @@ var ProviderProxy = (_class2 = class {
   }
   /** Stop the listener, clear all routes, and release the port. */
   async stop() {
+    for (const cleanup of [...this.beforeStop]) {
+      try {
+        await cleanup();
+      } catch (e26) {
+      }
+    }
     this.routes.clear();
     const server = this.server;
     if (!server) return;
@@ -2358,6 +2673,15 @@ var ProviderProxy = (_class2 = class {
   getBaseUrl() {
     return `http://127.0.0.1:${this.port}`;
   }
+  /** Register daemon-owned cleanup that must run before route-map teardown. */
+  registerBeforeStop(cleanup) {
+    this.beforeStop.add(cleanup);
+    return () => this.beforeStop.delete(cleanup);
+  }
+  /** Whether the resident listener has completed binding. */
+  isReady() {
+    return this.server !== null && this.port > 0;
+  }
   /**
    * The SHARED route map. Exposed so the outbound API server
    * (`outbound-api-server`) can mint per-request routes on the SAME map and
@@ -2374,19 +2698,819 @@ var ProviderProxy = (_class2 = class {
   getDeps() {
     return this.deps;
   }
-  /** Register a route for one run; returns the crypto route token (task 2.2). */
-  addRoute(context, idleMs) {
-    return this.routes.addRoute(context, idleMs);
+  /** Register a route for one run; returns the crypto route token (task 2.2). */
+  addRoute(context, idleMsOrOptions) {
+    return this.routes.addRoute(context, idleMsOrOptions);
+  }
+  /** Re-arm one route while retaining the exact same bearer token. */
+  renewRoute(token, idleMs) {
+    return this.routes.renewRoute(token, idleMs);
+  }
+  /** Remove a route at run end. Returns true if an entry existed. */
+  removeRoute(token) {
+    return this.routes.removeRoute(token);
+  }
+  /** Live-route count (diagnostics / tests). */
+  routeCount() {
+    return this.routes.size();
+  }
+}, _class2);
+
+// src/provider-proxy/RouteLeaseManager.ts
+
+
+// src/provider-proxy/routeLeaseSchema.ts
+
+var ROUTE_LEASE_REQUEST_SCHEMA = "omnicross.route-lease.request/1";
+var ROUTE_LEASE_RESULT_SCHEMA = "omnicross.route-lease/1";
+var ROUTE_LEASE_CAPABILITIES_SCHEMA = "omnicross.route-lease.capabilities/1";
+var ROUTE_LEASE_API_VERSION = 1;
+var ROUTE_LEASE_DEFAULT_TTL_SECONDS = 600;
+var ROUTE_LEASE_MAX_TTL_SECONDS = 3600;
+var ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES = 256;
+var ROUTE_LEASE_MAX_CONSUMER_BYTES = 64;
+var ROUTE_LEASE_MAX_EXECUTION_ID_BYTES = 128;
+var ROUTE_LEASE_MAX_SESSION_ID_BYTES = 512;
+var ROUTE_LEASE_MAX_MODEL_BYTES = 256;
+var ROUTE_LEASE_SESSION_HASH_DOMAIN = "omnicross.route-lease.session/v1";
+var ROUTE_LEASE_CODEX_TOKEN_ENV = "OMNICROSS_CODEX_ROUTE_TOKEN";
+var ROUTE_LEASE_RUNTIMES = ["claude", "codex"];
+var ROUTE_LEASE_CAPABILITIES = Object.freeze({
+  schemaVersion: ROUTE_LEASE_CAPABILITIES_SCHEMA,
+  runtimes: Object.freeze(["claude", "codex"]),
+  upstreamKinds: Object.freeze(["provider", "account", "account-group", "account-pool"]),
+  leaseApiVersion: ROUTE_LEASE_API_VERSION,
+  codexAuthMode: "env_key",
+  maxTtlSeconds: ROUTE_LEASE_MAX_TTL_SECONDS
+});
+var ROUTE_LEASE_RUNTIME_TABLE = Object.freeze({
+  claude: Object.freeze({ endpoint: "messages", ingressFormat: "anthropic-messages", wirePath: "/v1/messages" }),
+  codex: Object.freeze({ endpoint: "responses", ingressFormat: "openai-responses", wirePath: "/openai/responses" })
+});
+var ERROR_DEFAULTS = {
+  invalid_request: { status: 400, retryable: false },
+  runtime_unsupported: { status: 400, retryable: false },
+  model_not_configured: { status: 400, retryable: false },
+  format_unsupported: { status: 400, retryable: false },
+  control_unauthorized: { status: 403, retryable: false },
+  upstream_not_found: { status: 404, retryable: false },
+  lease_not_found: { status: 404, retryable: false },
+  idempotency_conflict: { status: 409, retryable: false },
+  upstream_unavailable: { status: 409, retryable: true },
+  lease_expired: { status: 410, retryable: false },
+  upstream_exhausted: { status: 429, retryable: true },
+  daemon_not_ready: { status: 503, retryable: true }
+};
+var RouteLeaseError = (_class3 = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });_class3.prototype.__init5.call(this);;
+    this.code = code;
+    this.name = "RouteLeaseError";
+    const defaults = ERROR_DEFAULTS[code];
+    this.status = _nullishCoalesce(options.status, () => ( defaults.status));
+    this.retryable = _nullishCoalesce(options.retryable, () => ( defaults.retryable));
+    if (options.retryAfterSeconds !== void 0) {
+      this.retryAfterSeconds = Math.max(1, Math.min(3600, Math.floor(options.retryAfterSeconds)));
+    }
+  }
+  
+  __init5() {this.type = "route_lease_error"}
+  
+  
+  
+  toResponse() {
+    return { error: { type: this.type, code: this.code, message: this.message, retryable: this.retryable } };
+  }
+}, _class3);
+var IDEMPOTENCY_RE = /^[A-Za-z0-9._:-]+$/u;
+var CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/u;
+var PROCESS_SESSION_HMAC_KEY = _crypto.randomBytes.call(void 0, 32);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function normalizedString(value, field, maxBytes, options = {}) {
+  if (typeof value !== "string") throw invalid(`${field} must be a string`);
+  const normalized = value.trim();
+  if (!normalized || byteLength(normalized) > maxBytes || CONTROL_RE.test(normalized)) {
+    throw invalid(`${field} is invalid`);
+  }
+  if (options.asciiPattern && !options.asciiPattern.test(normalized)) {
+    throw invalid(`${field} is invalid`);
+  }
+  return normalized;
+}
+function optionalExecutionId(value, field) {
+  return value === void 0 ? void 0 : normalizedString(value, field, ROUTE_LEASE_MAX_EXECUTION_ID_BYTES);
+}
+function invalid(message) {
+  return new RouteLeaseError("invalid_request", message);
+}
+function normalizeRouteLeaseIdempotencyKey(value) {
+  return normalizedString(value, "Idempotency-Key", ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES, {
+    asciiPattern: IDEMPOTENCY_RE
+  });
+}
+function normalizeRouteLeaseTtl(value) {
+  if (value === void 0) return ROUTE_LEASE_DEFAULT_TTL_SECONDS;
+  if (!Number.isInteger(value) || value < 1 || value > ROUTE_LEASE_MAX_TTL_SECONDS) {
+    throw invalid(`ttlSeconds must be an integer from 1 to ${ROUTE_LEASE_MAX_TTL_SECONDS}`);
+  }
+  return value;
+}
+function normalizeUpstream(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") throw invalid("upstream is invalid");
+  const providerId = normalizedString(value.providerId, "upstream.providerId", 128);
+  switch (value.kind) {
+    case "provider": {
+      const keyId = value.keyId === void 0 ? void 0 : normalizedString(value.keyId, "upstream.keyId", 128);
+      return keyId ? { kind: "provider", providerId, keyId } : { kind: "provider", providerId };
+    }
+    case "account":
+      return {
+        kind: "account",
+        providerId,
+        accountId: normalizedString(value.accountId, "upstream.accountId", 128)
+      };
+    case "account-group":
+      return {
+        kind: "account-group",
+        providerId,
+        group: normalizedString(value.group, "upstream.group", 128)
+      };
+    case "account-pool":
+      return { kind: "account-pool", providerId };
+    default:
+      throw invalid("upstream kind is unsupported");
+  }
+}
+function hashRouteLeaseSessionId(sessionId, hmacKey = PROCESS_SESSION_HMAC_KEY) {
+  return _crypto.createHmac.call(void 0, "sha256", hmacKey).update(ROUTE_LEASE_SESSION_HASH_DOMAIN, "utf8").update("\0", "utf8").update(sessionId, "utf8").digest("hex");
+}
+function canonicalizeRouteLeasePayload(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalizeRouteLeasePayload(entry)).join(",")}]`;
+  }
+  const record = value;
+  const fields = Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalizeRouteLeasePayload(record[key])}`);
+  return `{${fields.join(",")}}`;
+}
+function hashRouteLeasePayload(value) {
+  return _crypto.createHash.call(void 0, "sha256").update(canonicalizeRouteLeasePayload(value), "utf8").digest("hex");
+}
+function parseRouteLeaseCreate(raw, idempotencyHeader, hmacKey = PROCESS_SESSION_HMAC_KEY) {
+  if (!isRecord(raw)) throw invalid("request body must be a JSON object");
+  if (raw.schemaVersion !== ROUTE_LEASE_REQUEST_SCHEMA) {
+    throw invalid(`schemaVersion must be ${ROUTE_LEASE_REQUEST_SCHEMA}`);
+  }
+  const consumer = normalizedString(raw.consumer, "consumer", ROUTE_LEASE_MAX_CONSUMER_BYTES);
+  const runtime = raw.runtime;
+  if (runtime !== "claude" && runtime !== "codex") {
+    throw new RouteLeaseError("runtime_unsupported", "runtime is unsupported");
+  }
+  const upstream = normalizeUpstream(raw.upstream);
+  if (typeof raw.model !== "string" || raw.model.trim().length === 0) {
+    throw new RouteLeaseError("model_not_configured", "model is not configured");
+  }
+  const model = normalizedString(raw.model, "model", ROUTE_LEASE_MAX_MODEL_BYTES);
+  const ttlSeconds = normalizeRouteLeaseTtl(raw.ttlSeconds);
+  const idempotencyKey = normalizeRouteLeaseIdempotencyKey(idempotencyHeader);
+  let execution;
+  let semanticExecution;
+  if (raw.execution !== void 0) {
+    if (!isRecord(raw.execution)) throw invalid("execution must be a JSON object");
+    const runId = optionalExecutionId(raw.execution.runId, "execution.runId");
+    const stageId = optionalExecutionId(raw.execution.stageId, "execution.stageId");
+    let attempt;
+    if (raw.execution.attempt !== void 0) {
+      if (!Number.isSafeInteger(raw.execution.attempt) || raw.execution.attempt < 1) {
+        throw invalid("execution.attempt must be a positive integer");
+      }
+      attempt = raw.execution.attempt;
+    }
+    let sessionId;
+    let sessionIdHash;
+    if (raw.execution.sessionId !== void 0) {
+      sessionId = normalizedString(raw.execution.sessionId, "execution.sessionId", ROUTE_LEASE_MAX_SESSION_ID_BYTES);
+      sessionIdHash = hashRouteLeaseSessionId(sessionId, hmacKey);
+    }
+    if (runId !== void 0 || stageId !== void 0 || attempt !== void 0 || sessionIdHash !== void 0) {
+      execution = { runId, stageId, attempt, sessionIdHash };
+      semanticExecution = { runId, stageId, attempt, sessionId };
+    }
+  }
+  const request = {
+    schemaVersion: ROUTE_LEASE_REQUEST_SCHEMA,
+    consumer,
+    runtime,
+    upstream,
+    model,
+    ...execution ? { execution } : {},
+    ttlSeconds
+  };
+  const semanticPayload = {
+    schemaVersion: request.schemaVersion,
+    consumer,
+    runtime,
+    upstream,
+    model,
+    ...semanticExecution ? { execution: semanticExecution } : {},
+    ttlSeconds
+  };
+  return { request, idempotencyKey, payloadHash: hashRouteLeasePayload(semanticPayload) };
+}
+function routeLeaseRuntime(runtime) {
+  switch (runtime) {
+    case "claude":
+      return ROUTE_LEASE_RUNTIME_TABLE.claude;
+    case "codex":
+      return ROUTE_LEASE_RUNTIME_TABLE.codex;
+    default: {
+      const exhaustive = runtime;
+      throw new RouteLeaseError("runtime_unsupported", `runtime is unsupported: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/provider-proxy/RouteLeaseManager.ts
+var SYSTEM_ROUTE_LEASE_CLOCK = {
+  now: () => Date.now(),
+  setTimeout(callback, delayMs) {
+    const timer = setTimeout(callback, delayMs);
+    _optionalChain([timer, 'access', _118 => _118.unref, 'optionalCall', _119 => _119()]);
+    return timer;
+  },
+  clearTimeout(handle) {
+    clearTimeout(handle);
+  }
+};
+function cloneUpstream(upstream) {
+  return { ...upstream };
+}
+function metadataCopy(metadata) {
+  return {
+    ...metadata,
+    upstream: cloneUpstream(metadata.upstream),
+    ...metadata.execution ? { execution: { ...metadata.execution } } : {}
+  };
+}
+var RouteLeaseManager = (_class4 = class {
+  constructor(routePort, targetResolver, descriptors, options = {}) {;_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);
+    this.routePort = routePort;
+    this.targetResolver = targetResolver;
+    this.descriptors = descriptors;
+    this.clock = _nullishCoalesce(options.clock, () => ( SYSTEM_ROUTE_LEASE_CLOCK));
+    this.hmacKey = _nullishCoalesce(options.hmacKey, () => ( _crypto.randomBytes.call(void 0, 32)));
+    this.tombstoneMaxCount = Math.max(1, _nullishCoalesce(options.tombstoneMaxCount, () => ( 512)));
+    this.tombstoneMaxAgeMs = Math.max(1, _nullishCoalesce(options.tombstoneMaxAgeMs, () => ( 60 * 60 * 1e3)));
+    this.logger = options.logger;
+    this.afterPublish = options.afterPublish;
+  }
+  
+  
+  
+  __init6() {this.active = /* @__PURE__ */ new Map()}
+  __init7() {this.idempotency = /* @__PURE__ */ new Map()}
+  __init8() {this.pendingCreates = /* @__PURE__ */ new Map()}
+  __init9() {this.tombstones = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  
+  
+  __init10() {this.closed = false}
+  parse(raw, idempotencyKey) {
+    return parseRouteLeaseCreate(raw, idempotencyKey, this.hmacKey);
+  }
+  async createFromRequest(raw, idempotencyKey) {
+    return this.create(this.parse(raw, idempotencyKey));
+  }
+  async create(input) {
+    if (this.closed) throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+    const request = input.request;
+    const scope = `${request.consumer}\0${input.idempotencyKey}`;
+    const existing = this.idempotency.get(scope);
+    if (existing) {
+      const lease = this.active.get(existing.leaseId);
+      if (!lease) {
+        this.idempotency.delete(scope);
+      } else if (existing.payloadHash !== input.payloadHash) {
+        throw new RouteLeaseError("idempotency_conflict", "idempotency key is already used for a different live request");
+      } else {
+        return { created: false, result: lease.result };
+      }
+    }
+    const pending = this.pendingCreates.get(scope);
+    if (pending) {
+      if (pending.payloadHash !== input.payloadHash) {
+        throw new RouteLeaseError("idempotency_conflict", "idempotency key is already used for a different live request");
+      }
+      const outcome2 = await pending.outcome;
+      return { created: false, result: outcome2.result };
+    }
+    const outcome = this.createNew(input, scope);
+    const pendingCreate = { payloadHash: input.payloadHash, outcome };
+    this.pendingCreates.set(scope, pendingCreate);
+    try {
+      return await outcome;
+    } finally {
+      if (this.pendingCreates.get(scope) === pendingCreate) this.pendingCreates.delete(scope);
+    }
+  }
+  async createNew(input, scope) {
+    const request = input.request;
+    if (!this.routePort.isReady()) {
+      throw new RouteLeaseError("daemon_not_ready", "resident provider proxy is not ready");
+    }
+    if (!this.descriptors.has(request.runtime)) {
+      throw new RouteLeaseError("runtime_unsupported", "runtime launch adapter is unavailable");
+    }
+    const leaseId = _crypto.randomUUID.call(void 0, );
+    const resolved = await this.targetResolver.resolve(request);
+    this.assertOpen();
+    const route = {
+      ...resolved,
+      sessionId: _nullishCoalesce(_optionalChain([request, 'access', _120 => _120.execution, 'optionalAccess', _121 => _121.sessionIdHash]), () => ( null)),
+      routeLease: {
+        leaseId,
+        consumer: request.consumer,
+        ..._optionalChain([request, 'access', _122 => _122.execution, 'optionalAccess', _123 => _123.runId]) ? { runId: request.execution.runId } : {},
+        ..._optionalChain([request, 'access', _124 => _124.execution, 'optionalAccess', _125 => _125.stageId]) ? { stageId: request.execution.stageId } : {}
+      }
+    };
+    const now = this.clock.now();
+    const ttlMs = request.ttlSeconds * 1e3;
+    const expiresAtMs = now + ttlMs;
+    let routeToken;
+    let published = false;
+    let activeLease;
+    try {
+      routeToken = this.routePort.addRoute(route, {
+        idleMs: ttlMs,
+        onActivity: (at) => this.noteActivity(leaseId, at),
+        onEvicted: () => this.onRouteEvicted(leaseId)
+      });
+      const launch = this.descriptors.build(request.runtime, {
+        proxyBaseUrl: this.routePort.getBaseUrl(),
+        model: request.model,
+        routeToken
+      });
+      this.assertOpen();
+      const metadata = {
+        leaseId,
+        consumer: request.consumer,
+        runtime: request.runtime,
+        upstream: cloneUpstream(request.upstream),
+        model: request.model,
+        createdAt: new Date(now).toISOString(),
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        status: "active",
+        ...request.execution ? { execution: { ...request.execution } } : {}
+      };
+      const result = {
+        schemaVersion: ROUTE_LEASE_RESULT_SCHEMA,
+        ...metadata,
+        status: "active",
+        launch: { env: { ...launch.env }, extraArgs: [...launch.extraArgs] }
+      };
+      const timer = this.clock.setTimeout(() => this.expire(leaseId), ttlMs);
+      activeLease = {
+        leaseId,
+        routeToken,
+        idempotencyScope: scope,
+        payloadHash: input.payloadHash,
+        request,
+        route,
+        result,
+        metadata,
+        expiresAtMs,
+        timer
+      };
+      this.assertOpen();
+      this.active.set(leaseId, activeLease);
+      this.idempotency.set(scope, { leaseId, payloadHash: input.payloadHash });
+      published = true;
+      _optionalChain([this, 'access', _126 => _126.afterPublish, 'optionalCall', _127 => _127()]);
+      if (this.closed) {
+        this.finalize(activeLease, "released");
+        throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+      }
+      return { created: true, result };
+    } catch (error) {
+      if (published && activeLease) {
+        this.active.delete(leaseId);
+        this.idempotency.delete(scope);
+        this.clock.clearTimeout(activeLease.timer);
+      }
+      if (routeToken) this.safeRemoveRoute(routeToken, leaseId);
+      if (error instanceof RouteLeaseError) throw error;
+      throw new RouteLeaseError("upstream_unavailable", "route lease creation failed safely", { cause: error });
+    }
+  }
+  list() {
+    this.pruneTombstones();
+    return [
+      ...[...this.active.values()].map((lease) => metadataCopy(lease.metadata)),
+      ...[...this.tombstones.values()].map((entry) => metadataCopy(entry.metadata))
+    ].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+  get(leaseId) {
+    const active = this.active.get(leaseId);
+    if (active) return metadataCopy(active.metadata);
+    this.pruneTombstones();
+    const tombstone = this.tombstones.get(leaseId);
+    if (tombstone) return metadataCopy(tombstone.metadata);
+    throw new RouteLeaseError("lease_not_found", "route lease was not found");
+  }
+  renew(leaseId, ttlSeconds) {
+    const lease = this.active.get(leaseId);
+    if (!lease) {
+      this.pruneTombstones();
+      const known = this.tombstones.get(leaseId);
+      if (_optionalChain([known, 'optionalAccess', _128 => _128.metadata, 'access', _129 => _129.status]) === "expired") {
+        throw new RouteLeaseError("lease_expired", "route lease has expired");
+      }
+      throw new RouteLeaseError("lease_not_found", "route lease was not found");
+    }
+    const now = this.clock.now();
+    if (now >= lease.expiresAtMs) {
+      this.finalize(lease, "expired");
+      throw new RouteLeaseError("lease_expired", "route lease has expired");
+    }
+    const ttlMs = ttlSeconds * 1e3;
+    const expiresAtMs = now + ttlMs;
+    const nextTimer = this.clock.setTimeout(() => this.expire(leaseId), ttlMs);
+    const previousTimer = lease.timer;
+    lease.timer = nextTimer;
+    lease.expiresAtMs = expiresAtMs;
+    lease.metadata = { ...lease.metadata, expiresAt: new Date(expiresAtMs).toISOString() };
+    this.clock.clearTimeout(previousTimer);
+    if (!this.routePort.renewRoute(lease.routeToken, ttlMs)) {
+      this.finalize(lease, "expired", true);
+      throw new RouteLeaseError("lease_expired", "route lease route has expired");
+    }
+    return { leaseId, expiresAt: lease.metadata.expiresAt, status: "active" };
+  }
+  release(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (!lease) return { leaseId, released: false };
+    this.finalize(lease, "released");
+    return { leaseId, released: true };
+  }
+  shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const lease of [...this.active.values()]) {
+      try {
+        this.finalize(lease, "released");
+      } catch (error) {
+        _optionalChain([this, 'access', _130 => _130.logger, 'optionalAccess', _131 => _131.warn, 'call', _132 => _132("route lease cleanup failed during shutdown", { leaseId: lease.leaseId, error: safeErrorName(error) })]);
+      }
+    }
+  }
+  activeCount() {
+    return this.active.size;
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+    }
+  }
+  noteActivity(leaseId, at) {
+    const lease = this.active.get(leaseId);
+    if (!lease || at >= lease.expiresAtMs) return;
+    lease.metadata = { ...lease.metadata, lastActivityAt: new Date(at).toISOString() };
+  }
+  onRouteEvicted(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (lease) this.finalize(lease, "expired", true);
+  }
+  expire(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (!lease) return;
+    const remaining = lease.expiresAtMs - this.clock.now();
+    if (remaining > 0) {
+      lease.timer = this.clock.setTimeout(() => this.expire(leaseId), remaining);
+      return;
+    }
+    this.finalize(lease, "expired");
+  }
+  finalize(lease, status, routeAlreadyGone = false) {
+    if (this.active.get(lease.leaseId) !== lease) return;
+    this.active.delete(lease.leaseId);
+    this.idempotency.delete(lease.idempotencyScope);
+    this.clock.clearTimeout(lease.timer);
+    if (!routeAlreadyGone) this.safeRemoveRoute(lease.routeToken, lease.leaseId);
+    const metadata = { ...lease.metadata, status };
+    this.tombstones.delete(lease.leaseId);
+    this.tombstones.set(lease.leaseId, { metadata, terminalAtMs: this.clock.now() });
+    this.pruneTombstones();
+  }
+  safeRemoveRoute(routeToken, leaseId) {
+    try {
+      this.routePort.removeRoute(routeToken);
+    } catch (error) {
+      _optionalChain([this, 'access', _133 => _133.logger, 'optionalAccess', _134 => _134.warn, 'call', _135 => _135("route lease route cleanup failed", { leaseId, error: safeErrorName(error) })]);
+    }
+  }
+  pruneTombstones() {
+    const cutoff = this.clock.now() - this.tombstoneMaxAgeMs;
+    for (const [leaseId, tombstone] of this.tombstones) {
+      if (tombstone.terminalAtMs < cutoff) this.tombstones.delete(leaseId);
+    }
+    while (this.tombstones.size > this.tombstoneMaxCount) {
+      const oldest = this.tombstones.keys().next().value;
+      if (!oldest) break;
+      this.tombstones.delete(oldest);
+    }
+  }
+}, _class4);
+function safeErrorName(error) {
+  return error instanceof Error ? error.name : "unknown";
+}
+
+// src/outbound-api/gatewayBindingResolver.ts
+var MESSAGE_FALLBACK_KINDS = ["sonnet", "opus", "haiku", "fable"];
+function nonBlank(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function gatewayBindingAllowsKey(binding, apiKeyId) {
+  const scope = _nullishCoalesce(binding.keyScope, () => ( (_optionalChain([binding, 'access', _136 => _136.apiKeyIds, 'optionalAccess', _137 => _137.length]) ? "selected" : "all")));
+  return scope === "all" || Boolean(_optionalChain([binding, 'access', _138 => _138.apiKeyIds, 'optionalAccess', _139 => _139.includes, 'call', _140 => _140(apiKeyId)]));
+}
+function wildcardMatches(pattern, value) {
+  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join(".*");
+  return new RegExp(`^${escaped}$`, "iu").test(value);
+}
+function resolveGatewayModelMapping(mappings, requestedModel) {
+  if (!nonBlank(requestedModel)) return void 0;
+  const wanted = requestedModel.trim();
+  const exact = (_nullishCoalesce(mappings, () => ( []))).find(
+    (mapping) => nonBlank(mapping.source) && !mapping.source.includes("*") && mapping.source.trim().toLocaleLowerCase() === wanted.toLocaleLowerCase()
+  );
+  if (exact && nonBlank(exact.target)) return exact.target.trim();
+  const wildcard = (_nullishCoalesce(mappings, () => ( []))).find(
+    (mapping) => nonBlank(mapping.source) && mapping.source.includes("*") && wildcardMatches(mapping.source.trim(), wanted)
+  );
+  return wildcard && nonBlank(wildcard.target) ? wildcard.target.trim() : void 0;
+}
+function routeCanServe(binding, requestedModel, role) {
+  if (binding.modelMode === "passthrough") return nonBlank(requestedModel);
+  if (_optionalChain([binding, 'access', _141 => _141.modelMappings, 'optionalAccess', _142 => _142.length])) {
+    return nonBlank(resolveGatewayModelMapping(binding.modelMappings, requestedModel));
+  }
+  if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
+    const map = _nullishCoalesce(binding.modelMap, () => ( {}));
+    const kind = _chunk4VZX5F4Tcjs.detectModelKind.call(void 0, binding.endpoint, requestedModel);
+    if (kind && nonBlank(map[kind])) return true;
+    if (binding.endpoint === "messages") {
+      return MESSAGE_FALLBACK_KINDS.some((candidate) => nonBlank(map[candidate]));
+    }
+    return nonBlank(map.codex);
+  }
+  if (binding.endpoint === "chat" && binding.dispatchMode === "prefix") {
+    return _chunk4VZX5F4Tcjs.resolvePrefixTarget.call(void 0, binding.prefixTargets, requestedModel) !== null;
+  }
+  if (binding.endpoint === "chat") {
+    if (!requestedModel) return false;
+    const wanted = requestedModel.trim().toLowerCase();
+    return (_nullishCoalesce(binding.models, () => ( []))).some((ref) => _optionalChain([modelIdOf, 'call', _143 => _143(ref), 'optionalAccess', _144 => _144.toLowerCase, 'call', _145 => _145()]) === wanted);
+  }
+  return role === "background" ? nonBlank(binding.backgroundModel) : nonBlank(binding.defaultModel);
+}
+function modelIdOf(ref) {
+  if (!nonBlank(ref)) return void 0;
+  const trimmed = ref.trim();
+  const comma = trimmed.indexOf(",");
+  const modelId = comma >= 0 ? trimmed.slice(comma + 1).trim() : trimmed;
+  return modelId || void 0;
+}
+function targetProviderId(target) {
+  return target.providerId.trim();
+}
+function targetRef(target, ref) {
+  const modelId = _nullishCoalesce(modelIdOf(ref), () => ( ""));
+  return modelId ? `${targetProviderId(target)},${modelId}` : "";
+}
+function targetRefs(target, refs) {
+  return (_nullishCoalesce(refs, () => ( []))).map((ref) => targetRef(target, ref)).filter(nonBlank);
+}
+function targetPrefixRefs(target, refs) {
+  if (!refs) return void 0;
+  const mapped = {};
+  for (const kind of ["claude", "gpt", "gemini"]) {
+    const ref = targetRef(target, refs[kind]);
+    if (ref) mapped[kind] = ref;
+  }
+  return mapped.claude || mapped.gpt || mapped.gemini ? mapped : void 0;
+}
+function applySingleModel(config, binding, targetModel) {
+  const ref = targetRef(binding.target, targetModel);
+  if (!ref) return;
+  if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
+    config.modelMap = Object.fromEntries(
+      _chunk4VZX5F4Tcjs.modelKindsForEndpoint.call(void 0, binding.endpoint).map((kind) => [kind, ref])
+    );
+  } else if (binding.endpoint === "chat") {
+    config.models = [ref];
+    config.dispatchMode = "list";
+  } else {
+    config.defaultModel = ref;
+    config.backgroundModel = ref;
+  }
+}
+function gatewayBindingToEndpointConfig(binding, requestedModel) {
+  const target = binding.target;
+  const config = {
+    endpoint: binding.endpoint,
+    useSubscription: target.kind !== "provider"
+  };
+  const usesGenericModelHandling = binding.modelMode === "passthrough" || Boolean(_optionalChain([binding, 'access', _146 => _146.modelMappings, 'optionalAccess', _147 => _147.length]));
+  const dynamicModel = binding.modelMode === "passthrough" ? requestedModel : resolveGatewayModelMapping(binding.modelMappings, requestedModel);
+  if (usesGenericModelHandling) {
+    if (nonBlank(dynamicModel)) applySingleModel(config, binding, dynamicModel);
+  } else if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
+    config.modelMap = Object.fromEntries(
+      Object.entries(_nullishCoalesce(binding.modelMap, () => ( {}))).map(([kind, ref]) => [kind, targetRef(target, ref)])
+    );
+  } else if (binding.endpoint === "chat") {
+    config.models = targetRefs(target, binding.models);
+    if (binding.dispatchMode === "prefix") {
+      config.dispatchMode = "prefix";
+      config.prefixTargets = targetPrefixRefs(target, binding.prefixTargets);
+    }
+  } else {
+    config.defaultModel = targetRef(target, binding.defaultModel);
+    config.backgroundModel = targetRef(target, binding.backgroundModel);
+    if (binding.backgroundModelIds) config.backgroundModelIds = [...binding.backgroundModelIds];
+  }
+  if (target.kind === "account") {
+    config.boundAccountId = target.accountId;
+    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  } else if (target.kind === "account-group") {
+    config.boundAccountGroup = target.group;
+    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  } else if (target.kind === "provider" && target.keyId) {
+    config.boundKeyId = target.keyId;
+    config.boundKeyFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  }
+  return config;
+}
+function candidateGatewayBindings(bindings, apiKeyId, endpoint) {
+  const candidates = (_nullishCoalesce(bindings, () => ( []))).filter(
+    (binding) => binding.enabled && binding.endpoint === endpoint && gatewayBindingAllowsKey(binding, apiKeyId)
+  );
+  const scopeOf = (binding) => _nullishCoalesce(binding.keyScope, () => ( (_optionalChain([binding, 'access', _148 => _148.apiKeyIds, 'optionalAccess', _149 => _149.length]) ? "selected" : "all")));
+  const scoped = candidates.filter((binding) => scopeOf(binding) === "selected");
+  const pool = scoped.length > 0 ? scoped : candidates.filter((binding) => scopeOf(binding) === "all");
+  return pool.sort(
+    (left, right) => (_nullishCoalesce(left.priority, () => ( 100))) - (_nullishCoalesce(right.priority, () => ( 100))) || left.id.localeCompare(right.id)
+  );
+}
+function candidateBackgroundModelIds(bindings, apiKeyId, endpoint) {
+  const ids = [
+    ...new Set(
+      candidateGatewayBindings(bindings, apiKeyId, endpoint).flatMap(
+        (binding) => _nullishCoalesce(binding.backgroundModelIds, () => ( []))
+      )
+    )
+  ];
+  return ids.length > 0 ? ids : void 0;
+}
+function resolveGatewayBinding(input) {
+  const candidates = candidateGatewayBindings(input.bindings, input.apiKeyId, input.endpoint);
+  const binding = _nullishCoalesce(candidates.find(
+    (candidate) => candidate.fallback === "fail" || routeCanServe(candidate, input.requestedModel, input.role)
+  ), () => ( candidates[0]));
+  if (!binding) return { source: "none" };
+  return {
+    source: "binding",
+    binding,
+    config: gatewayBindingToEndpointConfig(binding, input.requestedModel)
+  };
+}
+
+// src/provider-proxy/RouteLeaseTargetResolver.ts
+function resolveEnvKey(raw) {
+  if (!raw) return "";
+  return raw.startsWith("$") ? _nullishCoalesce(process.env[raw.slice(1)], () => ( "")) : raw;
+}
+function providerSupportsModel(provider, model) {
+  const flat = _nullishCoalesce(provider.models, () => ( []));
+  const configured = _nullishCoalesce(provider.modelConfigs, () => ( []));
+  if (flat.length === 0 && configured.length === 0) return false;
+  return flat.includes(model) || configured.some((entry) => entry.id === model && entry.enabled !== false);
+}
+function syntheticBinding(request) {
+  const runtime = routeLeaseRuntime(request.runtime);
+  return {
+    id: "route-lease-ephemeral",
+    name: "Route Lease ephemeral target",
+    enabled: true,
+    endpoint: runtime.endpoint,
+    target: request.upstream,
+    fallback: "fail",
+    modelMode: "passthrough"
+  };
+}
+function transformerRegistered(llmConfig, name) {
+  return Boolean(_optionalChain([llmConfig, 'access', _150 => _150.getTransformerService, 'call', _151 => _151(), 'optionalAccess', _152 => _152.getTransformer, 'call', _153 => _153(name)]));
+}
+var RouteLeaseTargetResolver = class {
+  constructor(llmConfig, options = {}) {
+    this.llmConfig = llmConfig;
+    this.options = options;
+  }
+  
+  
+  async resolve(request) {
+    const runtime = routeLeaseRuntime(request.runtime);
+    await this.preflightTarget(request);
+    const binding = syntheticBinding(request);
+    const config = gatewayBindingToEndpointConfig(binding, request.model);
+    const result = await _chunk4VZX5F4Tcjs.resolveRoute.call(void 0, {
+      config,
+      ingressFormat: runtime.ingressFormat,
+      llmConfig: this.llmConfig,
+      requestedModel: request.model,
+      sessionId: _nullishCoalesce(_optionalChain([request, 'access', _154 => _154.execution, 'optionalAccess', _155 => _155.sessionIdHash]), () => ( null))
+    });
+    if (!result.ok) {
+      throw new RouteLeaseError(
+        result.error.status === 404 ? "upstream_not_found" : "upstream_unavailable",
+        "the selected upstream could not be resolved"
+      );
+    }
+    return { ...result.route, requestedModel: void 0 };
   }
-  /** Remove a route at run end. Returns true if an entry existed. */
-  removeRoute(token) {
-    return this.routes.removeRoute(token);
+  async preflightTarget(request) {
+    const target = request.upstream;
+    if (target.kind !== "provider") {
+      await this.preflightSubscription(target, request.model);
+      return;
+    }
+    const provider = await this.llmConfig.getProvider(target.providerId);
+    if (!provider) throw new RouteLeaseError("upstream_not_found", "provider was not found");
+    if (provider.enabled === false) throw new RouteLeaseError("upstream_unavailable", "provider is disabled");
+    if (!providerSupportsModel(provider, request.model)) {
+      throw new RouteLeaseError("model_not_configured", "model is not configured for the provider");
+    }
+    if (target.keyId) {
+      const availability = await _optionalChain([this, 'access', _156 => _156.options, 'access', _157 => _157.providerKeys, 'optionalAccess', _158 => _158.getKeyAvailability, 'optionalCall', _159 => _159(
+        target.providerId,
+        target.keyId
+      )]);
+      if (availability === "not-found") {
+        throw new RouteLeaseError("upstream_not_found", "the selected provider key was not found");
+      }
+      const usable = availability === "usable" || availability === void 0 && Boolean(this.options.providerKeys) && await this.options.providerKeys.hasUsableKey(target.providerId, target.keyId);
+      if (!usable) {
+        throw new RouteLeaseError("upstream_unavailable", "the selected provider key is unavailable");
+      }
+    } else {
+      const directKey = resolveEnvKey(provider.api_key);
+      const poolAvailability = await _optionalChain([this, 'access', _160 => _160.options, 'access', _161 => _161.providerKeys, 'optionalAccess', _162 => _162.getPoolAvailability, 'optionalCall', _163 => _163(target.providerId)]);
+      const poolReady = poolAvailability ? poolAvailability.outcome === "usable" : this.options.providerKeys ? await this.options.providerKeys.hasUsableKeys(target.providerId) : false;
+      if (!directKey && _optionalChain([poolAvailability, 'optionalAccess', _164 => _164.outcome]) === "exhausted") {
+        throw new RouteLeaseError("upstream_exhausted", "provider key pool is temporarily exhausted", {
+          retryAfterSeconds: poolAvailability.retryAfterSeconds
+        });
+      }
+      if (!directKey && !poolReady) {
+        throw new RouteLeaseError("upstream_unavailable", "provider has no usable credential");
+      }
+    }
+    const sameFormat = request.runtime === "claude" && provider.apiFormat === "anthropic" || request.runtime === "codex" && provider.apiFormat === "openai-response";
+    if (!sameFormat) {
+      try {
+        const chain = await _chunkQXD4MV2Xcjs.resolveProviderChain.call(void 0, this.llmConfig, provider.id, request.model);
+        if (!chain.hasTransformers) {
+          throw new RouteLeaseError("format_unsupported", "no transformer chain supports this runtime and upstream");
+        }
+      } catch (error) {
+        if (error instanceof RouteLeaseError) throw error;
+        throw new RouteLeaseError("format_unsupported", "the transformer chain could not be resolved", { cause: error });
+      }
+    }
   }
-  /** Live-route count (diagnostics / tests). */
-  routeCount() {
-    return this.routes.size();
+  async preflightSubscription(target, model) {
+    const registry = _chunkQBZJ7P2Tcjs.getSubscriptionRegistryForOutbound.call(void 0, );
+    const profile = _nullishCoalesce(_optionalChain([registry, 'optionalAccess', _165 => _165.getProfile, 'call', _166 => _166(target.providerId)]), () => ( null));
+    if (!profile) throw new RouteLeaseError("upstream_not_found", "subscription provider was not found");
+    await _optionalChain([this, 'access', _167 => _167.options, 'access', _168 => _168.subscriptions, 'optionalAccess', _169 => _169.assertAvailable, 'call', _170 => _170(target, model)]);
+    const names = _nullishCoalesce(_nullishCoalesce(_optionalChain([profile, 'access', _171 => _171.resolveProviderTransformerNames, 'optionalCall', _172 => _172(model)]), () => ( profile.providerTransformerNames)), () => ( []));
+    if (names.some((name) => !transformerRegistered(this.llmConfig, name))) {
+      throw new RouteLeaseError("format_unsupported", "a required transformer is unavailable");
+    }
+    if (_optionalChain([profile, 'access', _173 => _173.modelTransformerNames, 'optionalAccess', _174 => _174.some, 'call', _175 => _175((name) => !transformerRegistered(this.llmConfig, name))])) {
+      throw new RouteLeaseError("format_unsupported", "a required model transformer is unavailable");
+    }
   }
-}, _class2);
+};
 
 // src/provider-proxy/index.ts
 var instance = null;
@@ -2409,9 +3533,9 @@ var _os = require('os');
 var _healthloggingtypes = require('@omnicross/contracts/health-logging-types');
 
 // src/outbound-api/keyedMutex.ts
-var KeyedMutex = (_class3 = class {constructor() { _class3.prototype.__init4.call(this); }
+var KeyedMutex = (_class5 = class {constructor() { _class5.prototype.__init11.call(this); }
   /** key → the tail of the pending-op chain (resolves when the last op frees). */
-  __init4() {this.tails = /* @__PURE__ */ new Map()}
+  __init11() {this.tails = /* @__PURE__ */ new Map()}
   /**
    * Run `fn` exclusively for `key`: it starts only after every previously
    * enqueued op for the SAME key has settled, and the next waiter starts only
@@ -2434,7 +3558,7 @@ var KeyedMutex = (_class3 = class {constructor() { _class3.prototype.__init4.cal
       if (this.tails.get(key) === chain) this.tails.delete(key);
     }
   }
-}, _class3);
+}, _class5);
 
 // src/outbound-api/outboundApiRouter.ts
 var _stream = require('stream');
@@ -2462,11 +3586,11 @@ var DEFAULT_ACCOUNT_HEALTH = {
   overloadCooldownMs: 10 * 6e4
 };
 function normalizeAccountHealth(raw) {
-  const ah = _optionalChain([raw, 'optionalAccess', _76 => _76.accountHealth]);
+  const ah = _optionalChain([raw, 'optionalAccess', _176 => _176.accountHealth]);
   return {
-    overloadCooldownEnabled: _optionalChain([ah, 'optionalAccess', _77 => _77.overloadCooldownEnabled]) !== false,
+    overloadCooldownEnabled: _optionalChain([ah, 'optionalAccess', _177 => _177.overloadCooldownEnabled]) !== false,
     overloadCooldownMs: clampNumber(
-      _optionalChain([ah, 'optionalAccess', _78 => _78.overloadCooldownMs]),
+      _optionalChain([ah, 'optionalAccess', _178 => _178.overloadCooldownMs]),
       6e4,
       36e5,
       DEFAULT_ACCOUNT_HEALTH.overloadCooldownMs
@@ -2488,25 +3612,25 @@ var DEFAULT_ALLOWANCE_SCHEDULING = {
   priorityPenalty: 100
 };
 function normalizeAllowanceScheduling(raw) {
-  const value = _optionalChain([raw, 'optionalAccess', _79 => _79.allowanceScheduling]);
+  const value = _optionalChain([raw, 'optionalAccess', _179 => _179.allowanceScheduling]);
   const demoteAtPercent = clampNumber(
-    _optionalChain([value, 'optionalAccess', _80 => _80.demoteAtPercent]),
+    _optionalChain([value, 'optionalAccess', _180 => _180.demoteAtPercent]),
     0,
     100,
     DEFAULT_ALLOWANCE_SCHEDULING.demoteAtPercent
   );
   const requestedPause = clampNumber(
-    _optionalChain([value, 'optionalAccess', _81 => _81.pauseAtPercent]),
+    _optionalChain([value, 'optionalAccess', _181 => _181.pauseAtPercent]),
     0,
     100,
     DEFAULT_ALLOWANCE_SCHEDULING.pauseAtPercent
   );
   return {
-    enabled: _optionalChain([value, 'optionalAccess', _82 => _82.enabled]) === true,
+    enabled: _optionalChain([value, 'optionalAccess', _182 => _182.enabled]) === true,
     demoteAtPercent,
     pauseAtPercent: Math.max(demoteAtPercent, requestedPause),
     priorityPenalty: Math.trunc(clampNumber(
-      _optionalChain([value, 'optionalAccess', _83 => _83.priorityPenalty]),
+      _optionalChain([value, 'optionalAccess', _183 => _183.priorityPenalty]),
       1,
       1e3,
       DEFAULT_ALLOWANCE_SCHEDULING.priorityPenalty
@@ -2514,53 +3638,58 @@ function normalizeAllowanceScheduling(raw) {
   };
 }
 function normalizeAccountProbe(raw) {
-  const ap = _optionalChain([raw, 'optionalAccess', _84 => _84.accountProbe]);
+  const ap = _optionalChain([raw, 'optionalAccess', _184 => _184.accountProbe]);
   return {
-    enabled: _optionalChain([ap, 'optionalAccess', _85 => _85.enabled]) === true,
-    intervalMs: clampNumber(_optionalChain([ap, 'optionalAccess', _86 => _86.intervalMs]), 6e4, 864e5, DEFAULT_ACCOUNT_PROBE.intervalMs),
-    onlyMultiAccount: _optionalChain([ap, 'optionalAccess', _87 => _87.onlyMultiAccount]) !== false,
-    timeoutMs: clampNumber(_optionalChain([ap, 'optionalAccess', _88 => _88.timeoutMs]), 1e3, 6e4, DEFAULT_ACCOUNT_PROBE.timeoutMs),
+    enabled: _optionalChain([ap, 'optionalAccess', _185 => _185.enabled]) === true,
+    intervalMs: clampNumber(_optionalChain([ap, 'optionalAccess', _186 => _186.intervalMs]), 6e4, 864e5, DEFAULT_ACCOUNT_PROBE.intervalMs),
+    onlyMultiAccount: _optionalChain([ap, 'optionalAccess', _187 => _187.onlyMultiAccount]) !== false,
+    timeoutMs: clampNumber(_optionalChain([ap, 'optionalAccess', _188 => _188.timeoutMs]), 1e3, 6e4, DEFAULT_ACCOUNT_PROBE.timeoutMs),
     historySize: Math.trunc(
-      clampNumber(_optionalChain([ap, 'optionalAccess', _89 => _89.historySize]), 1, 200, DEFAULT_ACCOUNT_PROBE.historySize)
+      clampNumber(_optionalChain([ap, 'optionalAccess', _189 => _189.historySize]), 1, 200, DEFAULT_ACCOUNT_PROBE.historySize)
     ),
-    staggerMs: clampNumber(_optionalChain([ap, 'optionalAccess', _90 => _90.staggerMs]), 0, 6e4, DEFAULT_ACCOUNT_PROBE.staggerMs)
+    staggerMs: clampNumber(_optionalChain([ap, 'optionalAccess', _190 => _190.staggerMs]), 0, 6e4, DEFAULT_ACCOUNT_PROBE.staggerMs)
   };
 }
 function normalizeAudit(raw) {
-  const a = _optionalChain([raw, 'optionalAccess', _91 => _91.audit]);
+  const a = _optionalChain([raw, 'optionalAccess', _191 => _191.audit]);
   return {
-    enabled: _optionalChain([a, 'optionalAccess', _92 => _92.enabled]) === true,
-    captureBodies: _optionalChain([a, 'optionalAccess', _93 => _93.captureBodies]) === true,
-    maxBodyBytes: Math.trunc(
-      clampNumber(_optionalChain([a, 'optionalAccess', _94 => _94.maxBodyBytes]), 256, 1048576, _audittypes.DEFAULT_AUDIT_CONFIG.maxBodyBytes)
-    ),
+    enabled: _optionalChain([a, 'optionalAccess', _192 => _192.enabled]) === true,
+    captureBodies: _optionalChain([a, 'optionalAccess', _193 => _193.captureBodies]) === true,
+    maxBodyBytes: normalizeMaxBodyBytes(_optionalChain([a, 'optionalAccess', _194 => _194.maxBodyBytes])),
     retentionDays: Math.trunc(
-      clampNumber(_optionalChain([a, 'optionalAccess', _95 => _95.retentionDays]), 1, 365, _audittypes.DEFAULT_AUDIT_CONFIG.retentionDays)
+      clampNumber(_optionalChain([a, 'optionalAccess', _195 => _195.retentionDays]), 1, 365, _audittypes.DEFAULT_AUDIT_CONFIG.retentionDays)
     ),
-    trustForwardedFor: _optionalChain([a, 'optionalAccess', _96 => _96.trustForwardedFor]) === true
+    trustForwardedFor: _optionalChain([a, 'optionalAccess', _196 => _196.trustForwardedFor]) === true
   };
 }
+function normalizeMaxBodyBytes(value) {
+  if (value === -1) return -1;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return _audittypes.DEFAULT_AUDIT_CONFIG.maxBodyBytes;
+  }
+  return Math.trunc(Math.min(1048576, value));
+}
 function normalizeBilling(raw) {
-  const b = _optionalChain([raw, 'optionalAccess', _97 => _97.billing]);
+  const b = _optionalChain([raw, 'optionalAccess', _197 => _197.billing]);
   const config = {
-    enabled: _optionalChain([b, 'optionalAccess', _98 => _98.enabled]) === true,
+    enabled: _optionalChain([b, 'optionalAccess', _198 => _198.enabled]) === true,
     maxRetryAgeMs: Math.trunc(
-      clampNumber(_optionalChain([b, 'optionalAccess', _99 => _99.maxRetryAgeMs]), 6e4, 2592e6, _billingtypes.DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
+      clampNumber(_optionalChain([b, 'optionalAccess', _199 => _199.maxRetryAgeMs]), 6e4, 2592e6, _billingtypes.DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
     )
   };
-  if (typeof _optionalChain([b, 'optionalAccess', _100 => _100.endpoint]) === "string" && b.endpoint.trim()) config.endpoint = b.endpoint.trim();
-  if (typeof _optionalChain([b, 'optionalAccess', _101 => _101.secret]) === "string" && b.secret.length > 0) config.secret = b.secret;
+  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;
   return config;
 }
 var DEFAULT_FINGERPRINT = { enabled: false };
 function normalizeFingerprint(raw) {
-  const f = _optionalChain([raw, 'optionalAccess', _102 => _102.fingerprint]);
-  const out = { enabled: _optionalChain([f, 'optionalAccess', _103 => _103.enabled]) === true };
-  if (typeof _optionalChain([f, 'optionalAccess', _104 => _104.ua]) === "string" && f.ua.trim().length > 0) out.ua = f.ua.trim();
+  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();
   return out;
 }
 function normalizeVoucher(raw) {
-  return { enabled: _optionalChain([raw, 'optionalAccess', _105 => _105.voucher, 'optionalAccess', _106 => _106.enabled]) === true };
+  return { enabled: _optionalChain([raw, 'optionalAccess', _205 => _205.voucher, 'optionalAccess', _206 => _206.enabled]) === true };
 }
 var PROXY_TYPES = ["http", "https", "socks5"];
 function normalizeProxyConfig(raw) {
@@ -2644,14 +3773,14 @@ function clampNumber(value, min, max, fallback) {
   return Math.min(max, Math.max(min, n));
 }
 function normalizeQueueSegments(raw) {
-  const umq = _optionalChain([raw, 'optionalAccess', _107 => _107.userMessageQueue]);
-  const cq = _optionalChain([raw, 'optionalAccess', _108 => _108.concurrencyQueue]);
+  const umq = _optionalChain([raw, 'optionalAccess', _207 => _207.userMessageQueue]);
+  const cq = _optionalChain([raw, 'optionalAccess', _208 => _208.concurrencyQueue]);
   return {
     userMessageQueue: {
-      enabled: _optionalChain([umq, 'optionalAccess', _109 => _109.enabled]) === true,
-      delayMs: clampNumber(_optionalChain([umq, 'optionalAccess', _110 => _110.delayMs]), 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
+      enabled: _optionalChain([umq, 'optionalAccess', _209 => _209.enabled]) === true,
+      delayMs: clampNumber(_optionalChain([umq, 'optionalAccess', _210 => _210.delayMs]), 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
       waitTimeoutMs: clampNumber(
-        _optionalChain([umq, 'optionalAccess', _111 => _111.waitTimeoutMs]),
+        _optionalChain([umq, 'optionalAccess', _211 => _211.waitTimeoutMs]),
         1e3,
         3e5,
         DEFAULT_USER_MESSAGE_QUEUE.waitTimeoutMs
@@ -2659,14 +3788,14 @@ function normalizeQueueSegments(raw) {
     },
     concurrencyQueue: {
       maxQueueSizeFactor: clampNumber(
-        _optionalChain([cq, 'optionalAccess', _112 => _112.maxQueueSizeFactor]),
+        _optionalChain([cq, 'optionalAccess', _212 => _212.maxQueueSizeFactor]),
         1,
         10,
         DEFAULT_CONCURRENCY_QUEUE.maxQueueSizeFactor
       ),
-      minQueueSize: clampNumber(_optionalChain([cq, 'optionalAccess', _113 => _113.minQueueSize]), 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
+      minQueueSize: clampNumber(_optionalChain([cq, 'optionalAccess', _213 => _213.minQueueSize]), 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
       waitTimeoutMs: clampNumber(
-        _optionalChain([cq, 'optionalAccess', _114 => _114.waitTimeoutMs]),
+        _optionalChain([cq, 'optionalAccess', _214 => _214.waitTimeoutMs]),
         1e3,
         3e5,
         DEFAULT_CONCURRENCY_QUEUE.waitTimeoutMs
@@ -2779,7 +3908,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', _115 => _115.models, 'optionalAccess', _116 => _116.some, 'call', _117 => _117((value) => typeof value === "string" && value.trim())])) || Boolean(_optionalChain([config, 'access', _118 => _118.defaultModel, 'optionalAccess', _119 => _119.trim, 'call', _120 => _120()])) || Boolean(_optionalChain([config, 'access', _121 => _121.backgroundModel, 'optionalAccess', _122 => _122.trim, 'call', _123 => _123()])) || Boolean(Object.values(_nullishCoalesce(config.prefixTargets, () => ( {}))).some((value) => _optionalChain([value, 'optionalAccess', _124 => _124.trim, 'call', _125 => _125()])));
+  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()])));
 }
 function splitModelRef(ref) {
   if (typeof ref !== "string") return null;
@@ -2847,7 +3976,7 @@ function legacyEndpointToBindings(config) {
     if (!parsed) continue;
     const route = routeFor(parsed.providerId);
     route[field] = ref;
-    if (_optionalChain([config, 'access', _126 => _126.backgroundModelIds, 'optionalAccess', _127 => _127.length])) {
+    if (_optionalChain([config, 'access', _226 => _226.backgroundModelIds, 'optionalAccess', _227 => _227.length])) {
       route.backgroundModelIds = [...config.backgroundModelIds];
     }
   }
@@ -2997,167 +4126,6 @@ function mergeServerConfig(current, patch) {
   });
 }
 
-// src/outbound-api/gatewayBindingResolver.ts
-var MESSAGE_FALLBACK_KINDS = ["sonnet", "opus", "haiku", "fable"];
-function nonBlank(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function gatewayBindingAllowsKey(binding, apiKeyId) {
-  const scope = _nullishCoalesce(binding.keyScope, () => ( (_optionalChain([binding, 'access', _128 => _128.apiKeyIds, 'optionalAccess', _129 => _129.length]) ? "selected" : "all")));
-  return scope === "all" || Boolean(_optionalChain([binding, 'access', _130 => _130.apiKeyIds, 'optionalAccess', _131 => _131.includes, 'call', _132 => _132(apiKeyId)]));
-}
-function wildcardMatches(pattern, value) {
-  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join(".*");
-  return new RegExp(`^${escaped}$`, "iu").test(value);
-}
-function resolveGatewayModelMapping(mappings, requestedModel) {
-  if (!nonBlank(requestedModel)) return void 0;
-  const wanted = requestedModel.trim();
-  const exact = (_nullishCoalesce(mappings, () => ( []))).find(
-    (mapping) => nonBlank(mapping.source) && !mapping.source.includes("*") && mapping.source.trim().toLocaleLowerCase() === wanted.toLocaleLowerCase()
-  );
-  if (exact && nonBlank(exact.target)) return exact.target.trim();
-  const wildcard = (_nullishCoalesce(mappings, () => ( []))).find(
-    (mapping) => nonBlank(mapping.source) && mapping.source.includes("*") && wildcardMatches(mapping.source.trim(), wanted)
-  );
-  return wildcard && nonBlank(wildcard.target) ? wildcard.target.trim() : void 0;
-}
-function routeCanServe(binding, requestedModel, role) {
-  if (binding.modelMode === "passthrough") return nonBlank(requestedModel);
-  if (_optionalChain([binding, 'access', _133 => _133.modelMappings, 'optionalAccess', _134 => _134.length])) {
-    return nonBlank(resolveGatewayModelMapping(binding.modelMappings, requestedModel));
-  }
-  if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
-    const map = _nullishCoalesce(binding.modelMap, () => ( {}));
-    const kind = _chunk4VZX5F4Tcjs.detectModelKind.call(void 0, binding.endpoint, requestedModel);
-    if (kind && nonBlank(map[kind])) return true;
-    if (binding.endpoint === "messages") {
-      return MESSAGE_FALLBACK_KINDS.some((candidate) => nonBlank(map[candidate]));
-    }
-    return nonBlank(map.codex);
-  }
-  if (binding.endpoint === "chat" && binding.dispatchMode === "prefix") {
-    return _chunk4VZX5F4Tcjs.resolvePrefixTarget.call(void 0, binding.prefixTargets, requestedModel) !== null;
-  }
-  if (binding.endpoint === "chat") {
-    if (!requestedModel) return false;
-    const wanted = requestedModel.trim().toLowerCase();
-    return (_nullishCoalesce(binding.models, () => ( []))).some((ref) => _optionalChain([modelIdOf, 'call', _135 => _135(ref), 'optionalAccess', _136 => _136.toLowerCase, 'call', _137 => _137()]) === wanted);
-  }
-  return role === "background" ? nonBlank(binding.backgroundModel) : nonBlank(binding.defaultModel);
-}
-function modelIdOf(ref) {
-  if (!nonBlank(ref)) return void 0;
-  const trimmed = ref.trim();
-  const comma = trimmed.indexOf(",");
-  const modelId = comma >= 0 ? trimmed.slice(comma + 1).trim() : trimmed;
-  return modelId || void 0;
-}
-function targetProviderId(target) {
-  return target.providerId.trim();
-}
-function targetRef(target, ref) {
-  const modelId = _nullishCoalesce(modelIdOf(ref), () => ( ""));
-  return modelId ? `${targetProviderId(target)},${modelId}` : "";
-}
-function targetRefs(target, refs) {
-  return (_nullishCoalesce(refs, () => ( []))).map((ref) => targetRef(target, ref)).filter(nonBlank);
-}
-function targetPrefixRefs(target, refs) {
-  if (!refs) return void 0;
-  const mapped = {};
-  for (const kind of ["claude", "gpt", "gemini"]) {
-    const ref = targetRef(target, refs[kind]);
-    if (ref) mapped[kind] = ref;
-  }
-  return mapped.claude || mapped.gpt || mapped.gemini ? mapped : void 0;
-}
-function applySingleModel(config, binding, targetModel) {
-  const ref = targetRef(binding.target, targetModel);
-  if (!ref) return;
-  if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
-    config.modelMap = Object.fromEntries(
-      _chunk4VZX5F4Tcjs.modelKindsForEndpoint.call(void 0, binding.endpoint).map((kind) => [kind, ref])
-    );
-  } else if (binding.endpoint === "chat") {
-    config.models = [ref];
-    config.dispatchMode = "list";
-  } else {
-    config.defaultModel = ref;
-    config.backgroundModel = ref;
-  }
-}
-function gatewayBindingToEndpointConfig(binding, requestedModel) {
-  const target = binding.target;
-  const config = {
-    endpoint: binding.endpoint,
-    useSubscription: target.kind !== "provider"
-  };
-  const usesGenericModelHandling = binding.modelMode === "passthrough" || Boolean(_optionalChain([binding, 'access', _138 => _138.modelMappings, 'optionalAccess', _139 => _139.length]));
-  const dynamicModel = binding.modelMode === "passthrough" ? requestedModel : resolveGatewayModelMapping(binding.modelMappings, requestedModel);
-  if (usesGenericModelHandling) {
-    if (nonBlank(dynamicModel)) applySingleModel(config, binding, dynamicModel);
-  } else if (_chunk4VZX5F4Tcjs.isKindMappedEndpoint.call(void 0, binding.endpoint)) {
-    config.modelMap = Object.fromEntries(
-      Object.entries(_nullishCoalesce(binding.modelMap, () => ( {}))).map(([kind, ref]) => [kind, targetRef(target, ref)])
-    );
-  } else if (binding.endpoint === "chat") {
-    config.models = targetRefs(target, binding.models);
-    if (binding.dispatchMode === "prefix") {
-      config.dispatchMode = "prefix";
-      config.prefixTargets = targetPrefixRefs(target, binding.prefixTargets);
-    }
-  } else {
-    config.defaultModel = targetRef(target, binding.defaultModel);
-    config.backgroundModel = targetRef(target, binding.backgroundModel);
-    if (binding.backgroundModelIds) config.backgroundModelIds = [...binding.backgroundModelIds];
-  }
-  if (target.kind === "account") {
-    config.boundAccountId = target.accountId;
-    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  } else if (target.kind === "account-group") {
-    config.boundAccountGroup = target.group;
-    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  } else if (target.kind === "provider" && target.keyId) {
-    config.boundKeyId = target.keyId;
-    config.boundKeyFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  }
-  return config;
-}
-function candidateGatewayBindings(bindings, apiKeyId, endpoint) {
-  const candidates = (_nullishCoalesce(bindings, () => ( []))).filter(
-    (binding) => binding.enabled && binding.endpoint === endpoint && gatewayBindingAllowsKey(binding, apiKeyId)
-  );
-  const scopeOf = (binding) => _nullishCoalesce(binding.keyScope, () => ( (_optionalChain([binding, 'access', _140 => _140.apiKeyIds, 'optionalAccess', _141 => _141.length]) ? "selected" : "all")));
-  const scoped = candidates.filter((binding) => scopeOf(binding) === "selected");
-  const pool = scoped.length > 0 ? scoped : candidates.filter((binding) => scopeOf(binding) === "all");
-  return pool.sort(
-    (left, right) => (_nullishCoalesce(left.priority, () => ( 100))) - (_nullishCoalesce(right.priority, () => ( 100))) || left.id.localeCompare(right.id)
-  );
-}
-function candidateBackgroundModelIds(bindings, apiKeyId, endpoint) {
-  const ids = [
-    ...new Set(
-      candidateGatewayBindings(bindings, apiKeyId, endpoint).flatMap(
-        (binding) => _nullishCoalesce(binding.backgroundModelIds, () => ( []))
-      )
-    )
-  ];
-  return ids.length > 0 ? ids : void 0;
-}
-function resolveGatewayBinding(input) {
-  const candidates = candidateGatewayBindings(input.bindings, input.apiKeyId, input.endpoint);
-  const binding = _nullishCoalesce(candidates.find(
-    (candidate) => candidate.fallback === "fail" || routeCanServe(candidate, input.requestedModel, input.role)
-  ), () => ( candidates[0]));
-  if (!binding) return { source: "none" };
-  return {
-    source: "binding",
-    binding,
-    config: gatewayBindingToEndpointConfig(binding, input.requestedModel)
-  };
-}
-
 // src/outbound-api/outboundApiKeyAuth.ts
 
 
@@ -3240,7 +4208,8 @@ async function createNamedKey(db, name) {
     id,
     name,
     keyHash: hashKey(secret),
-    keyPrefix: prefix
+    keyPrefix: prefix,
+    plaintext: secret
   });
   return {
     id: row.id,
@@ -3261,7 +4230,8 @@ async function createIntegrationKey(db, name, allowedEndpoints = ["responses", "
     keyPrefix: prefix,
     kind: "integration",
     allowedEndpoints: [...new Set(allowedEndpoints)],
-    loopbackOnly: true
+    loopbackOnly: true,
+    plaintext: secret
   });
   return {
     id: row.id,
@@ -3333,42 +4303,42 @@ async function verifyPresentedKey(db, presentedKey) {
 }
 
 // src/outbound-api/outboundConcurrencyGate.ts
-var ConcurrencyQueueFullError = (_class4 = class extends Error {
+var ConcurrencyQueueFullError = (_class6 = class extends Error {
   constructor(apiKeyId, maxQueueSize) {
-    super(`concurrency queue full (max ${maxQueueSize}) for key '${apiKeyId}'`);_class4.prototype.__init5.call(this);;
+    super(`concurrency queue full (max ${maxQueueSize}) for key '${apiKeyId}'`);_class6.prototype.__init12.call(this);;
     this.apiKeyId = apiKeyId;
     this.maxQueueSize = maxQueueSize;
     this.name = "ConcurrencyQueueFullError";
   }
   
   
-  __init5() {this.code = "concurrency_queue_full"}
-}, _class4);
-var ConcurrencyWaitTimeoutError = (_class5 = class extends Error {
+  __init12() {this.code = "concurrency_queue_full"}
+}, _class6);
+var ConcurrencyWaitTimeoutError = (_class7 = class extends Error {
   constructor(apiKeyId, waitTimeoutMs) {
-    super(`concurrency wait timed out after ${waitTimeoutMs}ms for key '${apiKeyId}'`);_class5.prototype.__init6.call(this);;
+    super(`concurrency wait timed out after ${waitTimeoutMs}ms for key '${apiKeyId}'`);_class7.prototype.__init13.call(this);;
     this.apiKeyId = apiKeyId;
     this.waitTimeoutMs = waitTimeoutMs;
     this.name = "ConcurrencyWaitTimeoutError";
   }
   
   
-  __init6() {this.code = "concurrency_wait_timeout"}
-}, _class5);
-var ConcurrencyWaitCancelledError = (_class6 = class extends Error {
+  __init13() {this.code = "concurrency_wait_timeout"}
+}, _class7);
+var ConcurrencyWaitCancelledError = (_class8 = class extends Error {
   constructor(apiKeyId) {
-    super(`concurrency wait cancelled for key '${apiKeyId}'`);_class6.prototype.__init7.call(this);;
+    super(`concurrency wait cancelled for key '${apiKeyId}'`);_class8.prototype.__init14.call(this);;
     this.apiKeyId = apiKeyId;
     this.name = "ConcurrencyWaitCancelledError";
   }
   
-  __init7() {this.code = "concurrency_wait_cancelled"}
-}, _class6);
+  __init14() {this.code = "concurrency_wait_cancelled"}
+}, _class8);
 function isConcurrencyRejection(err) {
   return err instanceof ConcurrencyQueueFullError || err instanceof ConcurrencyWaitTimeoutError || err instanceof ConcurrencyWaitCancelledError;
 }
-var OutboundConcurrencyGate = (_class7 = class {constructor() { _class7.prototype.__init8.call(this); }
-  __init8() {this.states = /* @__PURE__ */ new Map()}
+var OutboundConcurrencyGate = (_class9 = class {constructor() { _class9.prototype.__init15.call(this); }
+  __init15() {this.states = /* @__PURE__ */ new Map()}
   ensure(apiKeyId) {
     let state = this.states.get(apiKeyId);
     if (!state) {
@@ -3492,17 +4462,17 @@ var OutboundConcurrencyGate = (_class7 = class {constructor() { _class7.prototyp
     }
     this.states.clear();
   }
-}, _class7);
+}, _class9);
 
 // src/outbound-api/outboundRateLimiter.ts
 var DEFAULT_WINDOW_MS = 6e4;
 var DEFAULT_MAX_REQUESTS = 60;
-var OutboundRateLimiter = (_class8 = class {
+var OutboundRateLimiter = (_class10 = class {
   
   
   /** apiKeyId → ascending request timestamps within the current window. */
-  __init9() {this.hits = /* @__PURE__ */ new Map()}
-  constructor(options = {}) {;_class8.prototype.__init9.call(this);
+  __init16() {this.hits = /* @__PURE__ */ new Map()}
+  constructor(options = {}) {;_class10.prototype.__init16.call(this);
     this.windowMs = _nullishCoalesce(options.windowMs, () => ( DEFAULT_WINDOW_MS));
     this.maxRequests = _nullishCoalesce(options.maxRequests, () => ( DEFAULT_MAX_REQUESTS));
   }
@@ -3518,8 +4488,8 @@ var OutboundRateLimiter = (_class8 = class {
    * recorded (no bucket growth).
    */
   check(apiKeyId, now = Date.now(), override) {
-    const maxRequests = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _142 => _142.maxRequests]), () => ( this.maxRequests));
-    const windowMs = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _143 => _143.windowMs]), () => ( this.windowMs));
+    const maxRequests = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _228 => _228.maxRequests]), () => ( this.maxRequests));
+    const windowMs = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _229 => _229.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);
@@ -3544,7 +4514,7 @@ var OutboundRateLimiter = (_class8 = class {
   reset() {
     this.hits.clear();
   }
-}, _class8);
+}, _class10);
 
 // src/outbound-api/userMessageDetection.ts
 function asArray(v) {
@@ -3564,7 +4534,7 @@ function isUserMessageAnthropic(body) {
   if (typeof content === "string") return true;
   if (Array.isArray(content)) {
     const hasToolResult = content.some(
-      (block) => _optionalChain([asObject, 'call', _144 => _144(block), 'optionalAccess', _145 => _145["type"]]) === "tool_result"
+      (block) => _optionalChain([asObject, 'call', _230 => _230(block), 'optionalAccess', _231 => _231["type"]]) === "tool_result"
     );
     return !hasToolResult;
   }
@@ -3593,7 +4563,7 @@ function isUserMessageGemini(body) {
   if (!lastContent || lastContent["role"] !== "user") return false;
   const parts = asArray(lastContent["parts"]);
   const hasFunctionResponse = parts.some(
-    (part) => _optionalChain([asObject, 'call', _146 => _146(part), 'optionalAccess', _147 => _147["functionResponse"]]) !== void 0
+    (part) => _optionalChain([asObject, 'call', _232 => _232(part), 'optionalAccess', _233 => _233["functionResponse"]]) !== void 0
   );
   return !hasFunctionResponse;
 }
@@ -3615,22 +4585,22 @@ function isUserMessageRequest(endpoint, parsedBody) {
 }
 
 // src/outbound-api/userMessageSerialQueue.ts
-var SerialQueueTimeoutError = (_class9 = class extends Error {
+var SerialQueueTimeoutError = (_class11 = class extends Error {
   constructor(providerId, waitTimeoutMs) {
-    super(`user-message serial queue wait timed out after ${waitTimeoutMs}ms for '${providerId}'`);_class9.prototype.__init10.call(this);;
+    super(`user-message serial queue wait timed out after ${waitTimeoutMs}ms for '${providerId}'`);_class11.prototype.__init17.call(this);;
     this.providerId = providerId;
     this.waitTimeoutMs = waitTimeoutMs;
     this.name = "SerialQueueTimeoutError";
   }
   
   
-  __init10() {this.code = "serial_queue_timeout"}
-}, _class9);
+  __init17() {this.code = "serial_queue_timeout"}
+}, _class11);
 function isSerialQueueTimeout(err) {
   return err instanceof SerialQueueTimeoutError;
 }
-var UserMessageSerialQueue = (_class10 = class {constructor() { _class10.prototype.__init11.call(this); }
-  __init11() {this.states = /* @__PURE__ */ new Map()}
+var UserMessageSerialQueue = (_class12 = class {constructor() { _class12.prototype.__init18.call(this); }
+  __init18() {this.states = /* @__PURE__ */ new Map()}
   ensure(providerId) {
     let state = this.states.get(providerId);
     if (!state) {
@@ -3745,7 +4715,7 @@ var UserMessageSerialQueue = (_class10 = class {constructor() { _class10.prototy
     }
     this.states.clear();
   }
-}, _class10);
+}, _class12);
 
 // src/outbound-api/voucher.ts
 
@@ -3767,14 +4737,14 @@ function newVoucherId() {
 }
 function computeVoucherGrant(voucher, currentKey, now) {
   if (voucher.type === "credit") {
-    const current = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _148 => _148.totalCostLimitUsd]), () => ( 0));
+    const current = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _234 => _234.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', _149 => _149.expiresAt]), () => ( now));
+  const currentExpiry = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _235 => _235.expiresAt]), () => ( now));
   let granted = currentExpiry + (_nullishCoalesce(voucher.renewalDays, () => ( 0))) * DAY_MS2;
   if (voucher.maxExpiryDays != null) {
     granted = Math.min(granted, now + voucher.maxExpiryDays * DAY_MS2);
@@ -3805,7 +4775,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', _150 => _150.split, 'call', _151 => _151("?"), 'access', _152 => _152[0], 'optionalAccess', _153 => _153.replace, 'call', _154 => _154(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _236 => _236.split, 'call', _237 => _237("?"), 'access', _238 => _238[0], 'optionalAccess', _239 => _239.replace, 'call', _240 => _240(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/redeem");
 }
 function writeErr(res, status, message, headers = {}) {
@@ -3835,8 +4805,8 @@ function grantToResult(type, granted) {
 function currentResult(type, keyRow) {
   const result = { type };
   if (type === "credit") {
-    if (_optionalChain([keyRow, 'optionalAccess', _155 => _155.totalCostLimitUsd]) != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
-  } else if (_optionalChain([keyRow, 'optionalAccess', _156 => _156.expiresAt]) != null) {
+    if (_optionalChain([keyRow, 'optionalAccess', _241 => _241.totalCostLimitUsd]) != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
+  } else if (_optionalChain([keyRow, 'optionalAccess', _242 => _242.expiresAt]) != null) {
     result.expiresAt = keyRow.expiresAt;
   }
   return result;
@@ -3874,7 +4844,7 @@ async function handleVoucherRedeem(req, res, deps, voucherEnabled, redeemLimiter
   let code;
   try {
     code = raw ? JSON.parse(raw)["code"] : void 0;
-  } catch (e24) {
+  } catch (e27) {
     writeErr(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -3923,7 +4893,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', _157 => _157.status]) === "redeemed" && after.redeemedByKeyId === verifiedKeyId) {
+      if (_optionalChain([after, 'optionalAccess', _243 => _243.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" };
@@ -3984,10 +4954,10 @@ function extractPresentedKey(req) {
   }
   const xApiKey = req.headers["x-api-key"];
   const xApi = Array.isArray(xApiKey) ? xApiKey[0] : xApiKey;
-  if (_optionalChain([xApi, 'optionalAccess', _158 => _158.trim, 'call', _159 => _159()])) return xApi.trim();
+  if (_optionalChain([xApi, 'optionalAccess', _244 => _244.trim, 'call', _245 => _245()])) return xApi.trim();
   const goog = req.headers["x-goog-api-key"];
   const g = Array.isArray(goog) ? goog[0] : goog;
-  return _optionalChain([g, 'optionalAccess', _160 => _160.trim, 'call', _161 => _161()]) || void 0;
+  return _optionalChain([g, 'optionalAccess', _246 => _246.trim, 'call', _247 => _247()]) || void 0;
 }
 function isLoopbackPeer(address) {
   if (!address) return false;
@@ -3996,7 +4966,7 @@ function isLoopbackPeer(address) {
 }
 function selectEndpoint(method, url) {
   if (method !== "POST" || !url) return null;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _162 => _162.split, 'call', _163 => _163("?"), 'access', _164 => _164[0], 'optionalAccess', _165 => _165.replace, 'call', _166 => _166(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _248 => _248.split, 'call', _249 => _249("?"), 'access', _250 => _250[0], 'optionalAccess', _251 => _251.replace, 'call', _252 => _252(/\/+$/, "")]), () => ( ""));
   if (path.endsWith("/chat/completions")) return "chat";
   if (path.endsWith("/responses")) return "responses";
   if (path.includes("/v1/messages")) return "messages";
@@ -4014,7 +4984,7 @@ function extractGeminiModelFromUrl(url) {
 }
 function isModelsListRequest(url) {
   if (!url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _167 => _167.split, 'call', _168 => _168("?"), 'access', _169 => _169[0], 'optionalAccess', _170 => _170.replace, 'call', _171 => _171(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _253 => _253.split, 'call', _254 => _254("?"), 'access', _255 => _255[0], 'optionalAccess', _256 => _256.replace, 'call', _257 => _257(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/models");
 }
 function writeModelsList(res, config, apiKeyId, allowedEndpoints) {
@@ -4062,7 +5032,7 @@ function shimAuthHeader(req, routeToken) {
 }
 async function handleOutboundRequest(req, res, deps, config, rateLimiter, serialQueue, concurrencyGate, redeemLimiter, redeemMutex) {
   const now = Date.now();
-  const audit = _chunkUNWKG6EIcjs.beginAuditCapture.call(void 0, req, res, now);
+  const audit = _chunkXPIOJQS2cjs.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);
@@ -4077,7 +5047,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', _172 => _172.socket, 'optionalAccess', _173 => _173.remoteAddress]))) {
+  if (verified.loopbackOnly && !isLoopbackPeer(_optionalChain([req, 'access', _258 => _258.socket, 'optionalAccess', _259 => _259.remoteAddress]))) {
     writeJsonError(res, 403, "This integration key is restricted to loopback clients");
     return;
   }
@@ -4090,7 +5060,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       req,
       res,
       deps,
-      _optionalChain([config, 'access', _174 => _174.voucher, 'optionalAccess', _175 => _175.enabled]) === true,
+      _optionalChain([config, 'access', _260 => _260.voucher, 'optionalAccess', _261 => _261.enabled]) === true,
       _nullishCoalesce(redeemLimiter, () => ( getFallbackRedeemLimiter())),
       verified.id,
       _nullishCoalesce(presented, () => ( "")),
@@ -4188,7 +5158,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
     let parsedBody = {};
     try {
       parsedBody = rawBody ? JSON.parse(rawBody) : {};
-    } catch (e25) {
+    } catch (e28) {
       writeJsonError(res, 400, "Invalid JSON in request body");
       return;
     }
@@ -4259,7 +5229,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
     }
     let releaseSerial = null;
     const providerKey = resolved.route.providerId;
-    if (_optionalChain([config, 'access', _176 => _176.userMessageQueue, 'optionalAccess', _177 => _177.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
+    if (_optionalChain([config, 'access', _262 => _262.userMessageQueue, 'optionalAccess', _263 => _263.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
       const umq = config.userMessageQueue;
       try {
         const serialSlot = await serialQueue.acquire(providerKey, {
@@ -4337,37 +5307,37 @@ function makeReplayRequest(req, rawBody) {
 var DEFAULT_OUTBOUND_PORT = 8765;
 var LOOPBACK_ADDR = "127.0.0.1";
 var LAN_ADDR = "0.0.0.0";
-var OutboundApiServer = (_class11 = class {
-  constructor(deps, onPortChange) {;_class11.prototype.__init12.call(this);_class11.prototype.__init13.call(this);_class11.prototype.__init14.call(this);_class11.prototype.__init15.call(this);_class11.prototype.__init16.call(this);_class11.prototype.__init17.call(this);_class11.prototype.__init18.call(this);_class11.prototype.__init19.call(this);_class11.prototype.__init20.call(this);_class11.prototype.__init21.call(this);
+var OutboundApiServer = (_class13 = class {
+  constructor(deps, onPortChange) {;_class13.prototype.__init19.call(this);_class13.prototype.__init20.call(this);_class13.prototype.__init21.call(this);_class13.prototype.__init22.call(this);_class13.prototype.__init23.call(this);_class13.prototype.__init24.call(this);_class13.prototype.__init25.call(this);_class13.prototype.__init26.call(this);_class13.prototype.__init27.call(this);_class13.prototype.__init28.call(this);
     this.deps = deps;
     this.onPortChange = onPortChange;
   }
   
   
-  __init12() {this.server = null}
-  __init13() {this.boundPort = 0}
-  __init14() {this.boundAddr = LOOPBACK_ADDR}
-  __init15() {this.endpoints = []}
-  __init16() {this.bindings = []}
+  __init19() {this.server = null}
+  __init20() {this.boundPort = 0}
+  __init21() {this.boundAddr = LOOPBACK_ADDR}
+  __init22() {this.endpoints = []}
+  __init23() {this.bindings = []}
   
   
   
-  __init17() {this.rateLimiter = new OutboundRateLimiter()}
+  __init24() {this.rateLimiter = new OutboundRateLimiter()}
   /**
    * Redeem-attempt limiter (voucher-redemption #9, design D6) — a SEPARATE bucket
    * from the traffic `rateLimiter`, keyed by the authenticating key id, so
    * brute-forcing `CC_` codes is throttled (a handful/min) without touching the
    * per-key request rate. Conservative fixed defaults (10 / 60s).
    */
-  __init18() {this.redeemLimiter = new OutboundRateLimiter({ maxRequests: 10, windowMs: 6e4 })}
+  __init25() {this.redeemLimiter = new OutboundRateLimiter({ maxRequests: 10, windowMs: 6e4 })}
   /**
    * Per-key redeem mutex (voucher-redemption #9, MJ1 fix). One instance for the
    * server's lifetime so concurrent redeem REQUESTS for the same key serialize
    * (relative grant increments accumulate instead of clobbering a snapshot).
    */
-  __init19() {this.redeemMutex = new KeyedMutex()}
-  __init20() {this.serialQueue = new UserMessageSerialQueue()}
-  __init21() {this.concurrencyGate = new OutboundConcurrencyGate()}
+  __init26() {this.redeemMutex = new KeyedMutex()}
+  __init27() {this.serialQueue = new UserMessageSerialQueue()}
+  __init28() {this.concurrencyGate = new OutboundConcurrencyGate()}
   /**
    * Apply a config. Restarts the listener ONLY when the bind address or port
    * changes (or when toggling enabled); per-endpoint routing config is updated
@@ -4399,7 +5369,7 @@ var OutboundApiServer = (_class11 = class {
     const actualPort = await this.listen(bindAddr, port);
     this.boundAddr = bindAddr;
     this.boundPort = actualPort;
-    if (actualPort !== port) _optionalChain([this, 'access', _178 => _178.onPortChange, 'optionalCall', _179 => _179(actualPort)]);
+    if (actualPort !== port) _optionalChain([this, 'access', _264 => _264.onPortChange, 'optionalCall', _265 => _265(actualPort)]);
     this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
@@ -4468,7 +5438,7 @@ var OutboundApiServer = (_class11 = 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', _180 => _180.split, 'call', _181 => _181("?"), 'access', _182 => _182[0], 'optionalAccess', _183 => _183.replace, 'call', _184 => _184(/\/+$/, "")]) || "/";
+    const path = _optionalChain([(_nullishCoalesce(req.url, () => ( "/"))), 'access', _266 => _266.split, 'call', _267 => _267("?"), 'access', _268 => _268[0], 'optionalAccess', _269 => _269.replace, 'call', _270 => _270(/\/+$/, "")]) || "/";
     if (path !== "/health" && path !== "/healthz") return false;
     const report = provider();
     res.writeHead(_healthloggingtypes.healthHttpStatus.call(void 0, report.status), { "Content-Type": "application/json" });
@@ -4538,7 +5508,7 @@ var OutboundApiServer = (_class11 = class {
       concurrency: this.concurrencyGate.getStatus()
     };
   }
-}, _class11);
+}, _class13);
 function formatUrls(base) {
   return {
     chat: `${base}/v1/chat/completions`,
@@ -4579,13 +5549,13 @@ function startOfLocalWeek(ts) {
   day.setDate(day.getDate() - day.getDay());
   return day.getTime();
 }
-var KeySpendTracker = (_class12 = class {
-  constructor(seeder) {;_class12.prototype.__init22.call(this);
+var KeySpendTracker = (_class14 = class {
+  constructor(seeder) {;_class14.prototype.__init29.call(this);
     this.seeder = seeder;
   }
   
   /** apiKeyId → live accumulated spend (seeded lazily). */
-  __init22() {this.spend = /* @__PURE__ */ new Map()}
+  __init29() {this.spend = /* @__PURE__ */ new Map()}
   /**
    * Read the key's accumulated spend, seeding from the durable store on a cache
    * miss and rolling the daily/weekly windows on a hit.
@@ -4638,7 +5608,7 @@ var KeySpendTracker = (_class12 = class {
     });
     return { dailyUsd, dailyWindowStart, weeklyUsd, weeklyWindowStart, totalUsd };
   }
-}, _class12);
+}, _class14);
 function rollWindows(s, now) {
   const day = startOfLocalDay(now);
   if (s.dailyWindowStart !== day) {
@@ -4746,14 +5716,14 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       };
     }
     const anthropicResponse2 = await response2.json();
-    const openaiResponse2 = _chunkWYTEQ4Q5cjs.convertAnthropicToOpenAI.call(void 0, anthropicResponse2);
+    const openaiResponse2 = _chunkGDIXXKF2cjs.convertAnthropicToOpenAI.call(void 0, anthropicResponse2);
     const choice2 = openaiResponse2.choices[0];
     return {
       success: true,
       message: {
         id: `assistant-${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice2, 'access', _185 => _185.message, 'optionalAccess', _186 => _186.content]) || "",
+        content: _optionalChain([choice2, 'access', _271 => _271.message, 'optionalAccess', _272 => _272.content]) || "",
         timestamp: Date.now()
       },
       usage: openaiResponse2.usage ? {
@@ -4777,7 +5747,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
   const config = {
     defaultModel: options.model
   };
-  const anthropicRequest = _chunkWYTEQ4Q5cjs.convertOpenAIToAnthropic.call(void 0, openaiRequest, config);
+  const anthropicRequest = _chunkGDIXXKF2cjs.convertOpenAIToAnthropic.call(void 0, openaiRequest, config);
   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 });
@@ -4794,7 +5764,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
     };
   }
   const anthropicResponse = await response.json();
-  const openaiResponse = _chunkWYTEQ4Q5cjs.convertAnthropicToOpenAI.call(void 0, anthropicResponse);
+  const openaiResponse = _chunkGDIXXKF2cjs.convertAnthropicToOpenAI.call(void 0, anthropicResponse);
   const choice = openaiResponse.choices[0];
   return {
     success: true,
@@ -4858,7 +5828,7 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
   const candidate = candidates[0];
   const content = candidate.content;
   let textContent = "";
-  if (_optionalChain([content, 'optionalAccess', _187 => _187.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _273 => _273.parts])) {
     for (const part of content.parts) {
       if (part.text) {
         textContent += part.text;
@@ -4991,7 +5961,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _188 => _188.onError, 'optionalCall', _189 => _189(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _274 => _274.onError, 'optionalCall', _275 => _275(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai", {
@@ -5001,7 +5971,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     onVideo: callbacks.onVideo,
     onError: callbacks.onError
   });
-  _optionalChain([callbacks, 'access', _190 => _190.onDone, 'optionalCall', _191 => _191(
+  _optionalChain([callbacks, 'access', _276 => _276.onDone, 'optionalCall', _277 => _277(
     {
       id: messageId,
       role: "assistant",
@@ -5059,7 +6029,7 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
       temperature: thinkingConfig ? void 0 : options.temperature,
       stream: true
     };
-    anthropicRequest = _chunkWYTEQ4Q5cjs.convertOpenAIToAnthropic.call(void 0, openaiRequest, config);
+    anthropicRequest = _chunkGDIXXKF2cjs.convertOpenAIToAnthropic.call(void 0, openaiRequest, config);
     if (thinkingConfig) {
       anthropicRequest.thinking = thinkingConfig;
       delete anthropicRequest.temperature;
@@ -5073,7 +6043,7 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   logger.info("Streaming Anthropic completion request", {
     url: apiUrl,
     model: anthropicRequest.model,
-    messagesCount: _optionalChain([anthropicRequest, 'access', _192 => _192.messages, 'optionalAccess', _193 => _193.length]),
+    messagesCount: _optionalChain([anthropicRequest, 'access', _278 => _278.messages, 'optionalAccess', _279 => _279.length]),
     max_tokens: anthropicRequest.max_tokens,
     temperature: anthropicRequest.temperature,
     stream: anthropicRequest.stream,
@@ -5090,7 +6060,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', _194 => _194.onError, 'optionalCall', _195 => _195(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _280 => _280.onError, 'optionalCall', _281 => _281(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "anthropic", {
@@ -5101,10 +6071,10 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   });
   logger.info("Anthropic stream complete", {
     contentLength: result.content.length,
-    reasoningLength: _optionalChain([result, 'access', _196 => _196.reasoning, 'optionalAccess', _197 => _197.length]) || 0,
+    reasoningLength: _optionalChain([result, 'access', _282 => _282.reasoning, 'optionalAccess', _283 => _283.length]) || 0,
     blocksCount: result.blocks.length
   });
-  _optionalChain([callbacks, 'access', _198 => _198.onDone, 'optionalCall', _199 => _199(
+  _optionalChain([callbacks, 'access', _284 => _284.onDone, 'optionalCall', _285 => _285(
     {
       id: messageId,
       role: "assistant",
@@ -5160,7 +6130,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', _200 => _200.onError, 'optionalCall', _201 => _201(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _286 => _286.onError, 'optionalCall', _287 => _287(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "gemini", {
@@ -5169,7 +6139,7 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
     onError: callbacks.onError
   });
   logger.info("Gemini stream complete", { contentLength: result.content.length });
-  _optionalChain([callbacks, 'access', _202 => _202.onDone, 'optionalCall', _203 => _203(
+  _optionalChain([callbacks, 'access', _288 => _288.onDone, 'optionalCall', _289 => _289(
     {
       id: messageId,
       role: "assistant",
@@ -5221,7 +6191,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _204 => _204.onError, 'optionalCall', _205 => _205(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _290 => _290.onError, 'optionalCall', _291 => _291(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai-response", {
@@ -5230,7 +6200,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', _206 => _206.onDone, 'optionalCall', _207 => _207(
+  _optionalChain([callbacks, 'access', _292 => _292.onDone, 'optionalCall', _293 => _293(
     {
       id: messageId,
       role: "assistant",
@@ -5258,7 +6228,7 @@ async function resolveEffectiveMaxTokens(llmConfig, _getProvider, logger, _provi
   }
   try {
     const globalParams = await llmConfig.getGlobalModelParameters();
-    if (_optionalChain([globalParams, 'optionalAccess', _208 => _208.maxTokens, 'optionalAccess', _209 => _209.enabled]) && globalParams.maxTokens.value > 0) {
+    if (_optionalChain([globalParams, 'optionalAccess', _294 => _294.maxTokens, 'optionalAccess', _295 => _295.enabled]) && globalParams.maxTokens.value > 0) {
       logger.debug("Using global maxTokens", { maxTokens: globalParams.maxTokens.value });
       return globalParams.maxTokens.value;
     }
@@ -5286,7 +6256,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', _210 => _210.name, 'optionalAccess', _211 => _211.toLowerCase, 'call', _212 => _212()]) || "";
+  const providerName = _optionalChain([provider, 'optionalAccess', _296 => _296.name, 'optionalAccess', _297 => _297.toLowerCase, 'call', _298 => _298()]) || "";
   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);
@@ -5323,7 +6293,7 @@ function logToolFormat(tools, logger) {
       tools: openaiTools.map((t) => t.function.name),
       firstTool: {
         name: firstTool.function.name,
-        description: _optionalChain([firstTool, 'access', _213 => _213.function, 'access', _214 => _214.description, 'optionalAccess', _215 => _215.slice, 'call', _216 => _216(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _299 => _299.function, 'access', _300 => _300.description, 'optionalAccess', _301 => _301.slice, 'call', _302 => _302(0, 100)]),
         parameters: firstTool.function.parameters
       }
     });
@@ -5334,7 +6304,7 @@ function logToolFormat(tools, logger) {
       tools: anthropicTools.map((t) => t.name),
       firstTool: {
         name: firstTool.name,
-        description: _optionalChain([firstTool, 'access', _217 => _217.description, 'optionalAccess', _218 => _218.slice, 'call', _219 => _219(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _303 => _303.description, 'optionalAccess', _304 => _304.slice, 'call', _305 => _305(0, 100)]),
         input_schema: firstTool.input_schema
       }
     });
@@ -5345,9 +6315,9 @@ function logToolFormat(tools, logger) {
       count: allDeclarations.length,
       tools: allDeclarations.map((t) => t.name),
       firstTool: {
-        name: _optionalChain([allDeclarations, 'access', _220 => _220[0], 'optionalAccess', _221 => _221.name]),
-        description: _optionalChain([allDeclarations, 'access', _222 => _222[0], 'optionalAccess', _223 => _223.description, 'optionalAccess', _224 => _224.slice, 'call', _225 => _225(0, 100)]),
-        parameters: _optionalChain([allDeclarations, 'access', _226 => _226[0], 'optionalAccess', _227 => _227.parameters])
+        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])
       }
     });
   }
@@ -5381,7 +6351,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: _chunk4VLRHHFEcjs.resolveAnthropicMaxTokens.call(void 0, actualModel, options.maxTokens),
+      max_tokens: _chunkOXHNSZ53cjs.resolveAnthropicMaxTokens.call(void 0, actualModel, options.maxTokens),
       temperature: _nullishCoalesce(options.temperature, () => ( 0.7)),
       stream: true,
       tools: options.tools
@@ -5410,7 +6380,7 @@ function buildToolRequest(apiFormat, conversationMessages, actualModel, options,
 function extractDeltaContent(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _228 => _228.candidates, 'optionalAccess', _229 => _229[0], 'optionalAccess', _230 => _230.content, 'optionalAccess', _231 => _231.parts]) || [];
+    const parts = _optionalChain([json, 'access', _314 => _314.candidates, 'optionalAccess', _315 => _315[0], 'optionalAccess', _316 => _316.content, 'optionalAccess', _317 => _317.parts]) || [];
     let text = "";
     for (const part of parts) {
       if (part.thought === true) continue;
@@ -5418,15 +6388,15 @@ function extractDeltaContent(rawJson, apiFormat) {
     }
     return text;
   } else if (apiFormat === "anthropic") {
-    return _optionalChain([json, 'access', _232 => _232.delta, 'optionalAccess', _233 => _233.text]) || "";
+    return _optionalChain([json, 'access', _318 => _318.delta, 'optionalAccess', _319 => _319.text]) || "";
   } else {
-    return _optionalChain([json, 'access', _234 => _234.choices, 'optionalAccess', _235 => _235[0], 'optionalAccess', _236 => _236.delta, 'optionalAccess', _237 => _237.content]) || "";
+    return _optionalChain([json, 'access', _320 => _320.choices, 'optionalAccess', _321 => _321[0], 'optionalAccess', _322 => _322.delta, 'optionalAccess', _323 => _323.content]) || "";
   }
 }
 function extractDeltaReasoning(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _238 => _238.candidates, 'optionalAccess', _239 => _239[0], 'optionalAccess', _240 => _240.content, 'optionalAccess', _241 => _241.parts]) || [];
+    const parts = _optionalChain([json, 'access', _324 => _324.candidates, 'optionalAccess', _325 => _325[0], 'optionalAccess', _326 => _326.content, 'optionalAccess', _327 => _327.parts]) || [];
     let reasoning = "";
     for (const part of parts) {
       if (part.thought === true && part.text) reasoning += part.text;
@@ -5435,14 +6405,14 @@ function extractDeltaReasoning(rawJson, apiFormat) {
   } else if (apiFormat === "anthropic") {
     return "";
   } else {
-    const delta = _optionalChain([json, 'access', _242 => _242.choices, 'optionalAccess', _243 => _243[0], 'optionalAccess', _244 => _244.delta]);
-    return (_optionalChain([delta, 'optionalAccess', _245 => _245.thinking, 'optionalAccess', _246 => _246.content]) || "") + (_optionalChain([delta, 'optionalAccess', _247 => _247.reasoning_content]) || "");
+    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]) || "");
   }
 }
 function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pendingOpenAIToolCalls) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _248 => _248.candidates, 'optionalAccess', _249 => _249[0], 'optionalAccess', _250 => _250.content, 'optionalAccess', _251 => _251.parts]) || [];
+    const parts = _optionalChain([json, 'access', _334 => _334.candidates, 'optionalAccess', _335 => _335[0], 'optionalAccess', _336 => _336.content, 'optionalAccess', _337 => _337.parts]) || [];
     for (const part of parts) {
       if (part.functionCall) {
         logger.info("Function call detected", { functionCall: part.functionCall });
@@ -5452,13 +6422,13 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           args: part.functionCall.args || {}
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _252 => _252.onToolCall, 'optionalCall', _253 => _253(toolCall)]);
+        _optionalChain([callbacks, 'access', _338 => _338.onToolCall, 'optionalCall', _339 => _339(toolCall)]);
         logger.info("Tool called", { toolName: toolCall.name });
       }
     }
   } else if (apiFormat !== "anthropic") {
-    const delta = _optionalChain([json, 'access', _254 => _254.choices, 'optionalAccess', _255 => _255[0], 'optionalAccess', _256 => _256.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _257 => _257.tool_calls]) && pendingOpenAIToolCalls) {
+    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) {
       for (const tc of delta.tool_calls) {
         const index = _nullishCoalesce(tc.index, () => ( 0));
         let pending = pendingOpenAIToolCalls.get(index);
@@ -5467,8 +6437,8 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           pendingOpenAIToolCalls.set(index, pending);
         }
         if (tc.id) pending.id = tc.id;
-        if (_optionalChain([tc, 'access', _258 => _258.function, 'optionalAccess', _259 => _259.name])) pending.name += tc.function.name;
-        if (_optionalChain([tc, 'access', _260 => _260.function, 'optionalAccess', _261 => _261.arguments])) pending.arguments += tc.function.arguments;
+        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;
       }
     }
   }
@@ -5483,7 +6453,7 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
           args: JSON.parse(pending.arguments || "{}")
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _262 => _262.onToolCall, 'optionalCall', _263 => _263(toolCall)]);
+        _optionalChain([callbacks, 'access', _348 => _348.onToolCall, 'optionalCall', _349 => _349(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, {
@@ -5497,38 +6467,38 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
 function parseStreamChunk(rawJson, apiFormat, callbacks, logger) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const candidate = _optionalChain([json, 'access', _264 => _264.candidates, 'optionalAccess', _265 => _265[0]]);
+    const candidate = _optionalChain([json, 'access', _350 => _350.candidates, 'optionalAccess', _351 => _351[0]]);
     if (!candidate) {
       logger.warn("No candidate found in Gemini response");
       return;
     }
-    const parts = _optionalChain([candidate, 'access', _266 => _266.content, 'optionalAccess', _267 => _267.parts]) || [];
+    const parts = _optionalChain([candidate, 'access', _352 => _352.content, 'optionalAccess', _353 => _353.parts]) || [];
     for (const part of parts) {
       if (part.thought === true && part.text) {
-        _optionalChain([callbacks, 'access', _268 => _268.onReasoning, 'optionalCall', _269 => _269(part.text)]);
+        _optionalChain([callbacks, 'access', _354 => _354.onReasoning, 'optionalCall', _355 => _355(part.text)]);
         continue;
       } else if (part.thoughtSignature && !part.thought) {
         logger.debug("Gemini returned thoughtSignature without thought content");
       }
       if (part.text) {
-        _optionalChain([callbacks, 'access', _270 => _270.onDelta, 'optionalCall', _271 => _271(part.text)]);
+        _optionalChain([callbacks, 'access', _356 => _356.onDelta, 'optionalCall', _357 => _357(part.text)]);
       }
     }
   } else if (apiFormat === "anthropic") {
     const delta = json.delta;
-    if (_optionalChain([delta, 'optionalAccess', _272 => _272.text])) {
-      _optionalChain([callbacks, 'access', _273 => _273.onDelta, 'optionalCall', _274 => _274(delta.text)]);
+    if (_optionalChain([delta, 'optionalAccess', _358 => _358.text])) {
+      _optionalChain([callbacks, 'access', _359 => _359.onDelta, 'optionalCall', _360 => _360(delta.text)]);
     }
   } else {
-    const delta = _optionalChain([json, 'access', _275 => _275.choices, 'optionalAccess', _276 => _276[0], 'optionalAccess', _277 => _277.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _278 => _278.content])) {
-      _optionalChain([callbacks, 'access', _279 => _279.onDelta, 'optionalCall', _280 => _280(delta.content)]);
+    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)]);
     }
-    if (_optionalChain([delta, 'optionalAccess', _281 => _281.thinking, 'optionalAccess', _282 => _282.content])) {
-      _optionalChain([callbacks, 'access', _283 => _283.onReasoning, 'optionalCall', _284 => _284(delta.thinking.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', _285 => _285.reasoning_content])) {
-      _optionalChain([callbacks, 'access', _286 => _286.onReasoning, 'optionalCall', _287 => _287(delta.reasoning_content)]);
+    if (_optionalChain([delta, 'optionalAccess', _371 => _371.reasoning_content])) {
+      _optionalChain([callbacks, 'access', _372 => _372.onReasoning, 'optionalCall', _373 => _373(delta.reasoning_content)]);
     }
   }
 }
@@ -5541,7 +6511,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content: reasoning
     };
     blocks.push(thinkingBlock);
-    _optionalChain([callbacks, 'access', _288 => _288.onBlock, 'optionalCall', _289 => _289(thinkingBlock)]);
+    _optionalChain([callbacks, 'access', _374 => _374.onBlock, 'optionalCall', _375 => _375(thinkingBlock)]);
   }
   if (content && content.trim()) {
     const textBlock = {
@@ -5550,7 +6520,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content
     };
     blocks.push(textBlock);
-    _optionalChain([callbacks, 'access', _290 => _290.onBlock, 'optionalCall', _291 => _291(textBlock)]);
+    _optionalChain([callbacks, 'access', _376 => _376.onBlock, 'optionalCall', _377 => _377(textBlock)]);
   }
 }
 async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
@@ -5565,7 +6535,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
       status: "running"
     };
     blocks.push(toolUseBlock);
-    _optionalChain([callbacks, 'access', _292 => _292.onBlock, 'optionalCall', _293 => _293(toolUseBlock)]);
+    _optionalChain([callbacks, 'access', _378 => _378.onBlock, 'optionalCall', _379 => _379(toolUseBlock)]);
     try {
       logger.info("Executing tool", { toolName: toolCall.name });
       const mcpTool = mcpTools.find((t) => t.id === toolCall.name);
@@ -5588,8 +6558,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', _294 => _294.onToolResult, 'optionalCall', _295 => _295(toolCall.id, result)]);
-      const resultText = _optionalChain([result, 'access', _296 => _296.content, 'optionalAccess', _297 => _297[0], 'optionalAccess', _298 => _298.text]) || JSON.stringify(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);
       const toolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -5599,11 +6569,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: result.isError
       };
       blocks.push(toolResultBlock);
-      _optionalChain([callbacks, 'access', _299 => _299.onBlock, 'optionalCall', _300 => _300(toolResultBlock)]);
+      _optionalChain([callbacks, 'access', _385 => _385.onBlock, 'optionalCall', _386 => _386(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', _301 => _301.onBlock, 'optionalCall', _302 => _302({ ...toolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _387 => _387.onBlock, 'optionalCall', _388 => _388({ ...toolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result });
     } catch (error) {
@@ -5613,7 +6583,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true,
         content: [{ type: "text", text: `Error: ${errorMessage}` }]
       };
-      _optionalChain([callbacks, 'access', _303 => _303.onToolResult, 'optionalCall', _304 => _304(toolCall.id, errorResult)]);
+      _optionalChain([callbacks, 'access', _389 => _389.onToolResult, 'optionalCall', _390 => _390(toolCall.id, errorResult)]);
       const errorToolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -5623,11 +6593,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true
       };
       blocks.push(errorToolResultBlock);
-      _optionalChain([callbacks, 'access', _305 => _305.onBlock, 'optionalCall', _306 => _306(errorToolResultBlock)]);
+      _optionalChain([callbacks, 'access', _391 => _391.onBlock, 'optionalCall', _392 => _392(errorToolResultBlock)]);
       const errorToolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
       if (errorToolUseBlockRef && errorToolUseBlockRef.type === "tool_use") {
         errorToolUseBlockRef.status = "error";
-        _optionalChain([callbacks, 'access', _307 => _307.onBlock, 'optionalCall', _308 => _308({ ...errorToolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _393 => _393.onBlock, 'optionalCall', _394 => _394({ ...errorToolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result: errorResult });
     }
@@ -5637,7 +6607,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', _309 => _309.properties])) {
+  if (_optionalChain([toolSchema, 'optionalAccess', _395 => _395.properties])) {
     const expectedParams = Object.keys(toolSchema.properties);
     const paramMappings = {
       "search_query": ["query", "q", "searchQuery", "search"],
@@ -5671,25 +6641,25 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _310 => _310.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _311 => _311.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _396 => _396.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _397 => _397.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _312 => _312.onError, 'optionalCall', _313 => _313(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _398 => _398.onError, 'optionalCall', _399 => _399(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _314 => _314.onError, 'optionalCall', _315 => _315(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _400 => _400.onError, 'optionalCall', _401 => _401(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _316 => _316.onError, 'optionalCall', _317 => _317("API key not configured")]);
+      _optionalChain([callbacks, 'access', _402 => _402.onError, 'optionalCall', _403 => _403("API key not configured")]);
       return;
     }
     const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    _optionalChain([callbacks, 'access', _318 => _318.onStart, 'optionalCall', _319 => _319(messageId)]);
+    _optionalChain([callbacks, 'access', _404 => _404.onStart, 'optionalCall', _405 => _405(messageId)]);
     const globalParams = await llmConfig.getGlobalModelParameters();
     const MAX_ITERATIONS = _nullishCoalesce(globalParams.toolMaxTurns, () => ( 100));
     let iteration = 0;
@@ -5736,12 +6706,12 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       });
       if (!response.ok) {
         const errorText = await response.text();
-        _optionalChain([callbacks, 'access', _320 => _320.onError, 'optionalCall', _321 => _321(`API error (${response.status}): ${errorText}`)]);
+        _optionalChain([callbacks, 'access', _406 => _406.onError, 'optionalCall', _407 => _407(`API error (${response.status}): ${errorText}`)]);
         return;
       }
-      const reader = _optionalChain([response, 'access', _322 => _322.body, 'optionalAccess', _323 => _323.getReader, 'call', _324 => _324()]);
+      const reader = _optionalChain([response, 'access', _408 => _408.body, 'optionalAccess', _409 => _409.getReader, 'call', _410 => _410()]);
       if (!reader) {
-        _optionalChain([callbacks, 'access', _325 => _325.onError, 'optionalCall', _326 => _326("No response body")]);
+        _optionalChain([callbacks, 'access', _411 => _411.onError, 'optionalCall', _412 => _412("No response body")]);
         return;
       }
       const decoder = new TextDecoder();
@@ -5774,7 +6744,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', _327 => _327.onError, 'optionalCall', _328 => _328(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
+                  _optionalChain([callbacks, 'access', _413 => _413.onError, 'optionalCall', _414 => _414(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
                   return;
                 }
                 parseStreamChunk(json, apiFormat, callbacks, logger);
@@ -5807,7 +6777,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
           toolCallsLength: toolCalls.length,
           executableToolCallsLength: executableToolCalls.length,
           hasMcpTools: !!options.mcpTools,
-          mcpToolsLength: _optionalChain([options, 'access', _329 => _329.mcpTools, 'optionalAccess', _330 => _330.length]),
+          mcpToolsLength: _optionalChain([options, 'access', _415 => _415.mcpTools, 'optionalAccess', _416 => _416.length]),
           hasMcpService: !!mcpService
         });
         if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
@@ -5828,7 +6798,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', _331 => _331.content, 'optionalAccess', _332 => _332[0], 'optionalAccess', _333 => _333.text]) || JSON.stringify(result);
+            const resultText = typeof result === "string" ? result : _optionalChain([result, 'access', _417 => _417.content, 'optionalAccess', _418 => _418[0], 'optionalAccess', _419 => _419.text]) || JSON.stringify(result);
             return `Tool ${toolCall.name} result:
 ${resultText}`;
           }).join("\n\n");
@@ -5846,12 +6816,12 @@ ${resultText}`;
         }
       } catch (streamError) {
         logger.error("Stream processing error", streamError instanceof Error ? streamError : void 0);
-        _optionalChain([callbacks, 'access', _334 => _334.onError, 'optionalCall', _335 => _335(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
+        _optionalChain([callbacks, 'access', _420 => _420.onError, 'optionalCall', _421 => _421(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
         return;
       }
     }
     logger.info("Sending final callback", { blocksCount: blocks.length });
-    _optionalChain([callbacks, 'access', _336 => _336.onDone, 'optionalCall', _337 => _337({
+    _optionalChain([callbacks, 'access', _422 => _422.onDone, 'optionalCall', _423 => _423({
       id: messageId,
       role: "assistant",
       content: finalContent,
@@ -5862,7 +6832,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', _338 => _338.onError, 'optionalCall', _339 => _339(message)]);
+    _optionalChain([callbacks, 'access', _424 => _424.onError, 'optionalCall', _425 => _425(message)]);
   }
 }
 
@@ -5913,8 +6883,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _340 => _340.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _341 => _341.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _426 => _426.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _427 => _427.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
       return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -5990,18 +6960,18 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       { endpointTransformer: void 0 }
     );
     const data = await transformedResponse.json();
-    const choice = _optionalChain([data, 'access', _342 => _342.choices, 'optionalAccess', _343 => _343[0]]);
+    const choice = _optionalChain([data, 'access', _428 => _428.choices, 'optionalAccess', _429 => _429[0]]);
     if (!choice) {
       return { success: false, error: "No choices in response" };
     }
-    const rawToolCalls = _optionalChain([choice, 'access', _344 => _344.message, 'optionalAccess', _345 => _345.tool_calls]);
-    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _346 => _346.map, 'call', _347 => _347((tc) => ({
+    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) => ({
       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', _348 => _348.recorder]) && tapped) {
+    if (_optionalChain([recording, 'optionalAccess', _434 => _434.recorder]) && tapped) {
       recording.recorder.record({
         messageId: _nullishCoalesce(options.messageId, () => ( null)),
         parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -6019,9 +6989,9 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       message: {
         id: `msg_${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice, 'access', _349 => _349.message, 'optionalAccess', _350 => _350.content]) || "",
+        content: _optionalChain([choice, 'access', _435 => _435.message, 'optionalAccess', _436 => _436.content]) || "",
         timestamp: Date.now(),
-        thinking: data.reasoning_content || _optionalChain([choice, 'access', _351 => _351.message, 'optionalAccess', _352 => _352.thinking, 'optionalAccess', _353 => _353.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _354 => _354.message, 'optionalAccess', _355 => _355.thinking, 'optionalAccess', _356 => _356.content]) || "", signature: _optionalChain([choice, 'access', _357 => _357.message, 'optionalAccess', _358 => _358.thinking, 'optionalAccess', _359 => _359.signature]) } : void 0,
+        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,
         toolCalls
       },
       usage: data.usage ? {
@@ -6042,21 +7012,21 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _360 => _360.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _361 => _361.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _446 => _446.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _447 => _447.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _362 => _362.onError, 'optionalCall', _363 => _363(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _448 => _448.onError, 'optionalCall', _449 => _449(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _364 => _364.onError, 'optionalCall', _365 => _365(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _450 => _450.onError, 'optionalCall', _451 => _451(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _366 => _366.onError, 'optionalCall', _367 => _367("API key not configured")]);
+      _optionalChain([callbacks, 'access', _452 => _452.onError, 'optionalCall', _453 => _453("API key not configured")]);
       return;
     }
     const { chain, hasTransformers } = await resolveChainWithMain(
@@ -6068,7 +7038,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       return completeStreamFallback(options, callbacks);
     }
     const messageId = `msg_${Date.now()}`;
-    _optionalChain([callbacks, 'access', _368 => _368.onStart, 'optionalCall', _369 => _369(messageId)]);
+    _optionalChain([callbacks, 'access', _454 => _454.onStart, 'optionalCall', _455 => _455(messageId)]);
     const unifiedRequest = buildUnifiedCompletionRequest(actualModel, options, true);
     const transformerProvider = {
       name: provider.name,
@@ -6107,7 +7077,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     });
     if (!response.ok) {
       const errorText = await response.text();
-      _optionalChain([callbacks, 'access', _370 => _370.onError, 'optionalCall', _371 => _371(`API error (${response.status}): ${errorText}`)]);
+      _optionalChain([callbacks, 'access', _456 => _456.onError, 'optionalCall', _457 => _457(`API error (${response.status}): ${errorText}`)]);
       return;
     }
     const transformedResponse = await executor.executeResponseChain(
@@ -6117,9 +7087,9 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       chain,
       { endpointTransformer: void 0 }
     );
-    const reader = _optionalChain([transformedResponse, 'access', _372 => _372.body, 'optionalAccess', _373 => _373.getReader, 'call', _374 => _374()]);
+    const reader = _optionalChain([transformedResponse, 'access', _458 => _458.body, 'optionalAccess', _459 => _459.getReader, 'call', _460 => _460()]);
     if (!reader) {
-      _optionalChain([callbacks, 'access', _375 => _375.onError, 'optionalCall', _376 => _376("No response body")]);
+      _optionalChain([callbacks, 'access', _461 => _461.onError, 'optionalCall', _462 => _462("No response body")]);
       return;
     }
     const decoder = new TextDecoder();
@@ -6137,22 +7107,22 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
             if (data === "[DONE]") continue;
             try {
               const json = JSON.parse(data);
-              const delta = _optionalChain([json, 'access', _377 => _377.choices, 'optionalAccess', _378 => _378[0], 'optionalAccess', _379 => _379.delta]);
-              if (_optionalChain([delta, 'optionalAccess', _380 => _380.content])) {
+              const delta = _optionalChain([json, 'access', _463 => _463.choices, 'optionalAccess', _464 => _464[0], 'optionalAccess', _465 => _465.delta]);
+              if (_optionalChain([delta, 'optionalAccess', _466 => _466.content])) {
                 content += delta.content;
-                _optionalChain([callbacks, 'access', _381 => _381.onDelta, 'optionalCall', _382 => _382(delta.content)]);
+                _optionalChain([callbacks, 'access', _467 => _467.onDelta, 'optionalCall', _468 => _468(delta.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _383 => _383.thinking, 'optionalAccess', _384 => _384.content])) {
+              if (_optionalChain([delta, 'optionalAccess', _469 => _469.thinking, 'optionalAccess', _470 => _470.content])) {
                 reasoning += delta.thinking.content;
-                _optionalChain([callbacks, 'access', _385 => _385.onReasoning, 'optionalCall', _386 => _386(delta.thinking.content)]);
+                _optionalChain([callbacks, 'access', _471 => _471.onReasoning, 'optionalCall', _472 => _472(delta.thinking.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _387 => _387.reasoning_content])) {
+              if (_optionalChain([delta, 'optionalAccess', _473 => _473.reasoning_content])) {
                 reasoning += delta.reasoning_content;
-                _optionalChain([callbacks, 'access', _388 => _388.onReasoning, 'optionalCall', _389 => _389(delta.reasoning_content)]);
+                _optionalChain([callbacks, 'access', _474 => _474.onReasoning, 'optionalCall', _475 => _475(delta.reasoning_content)]);
               }
               if (json.usage) {
                 const tapped = readUsageFromOpenAIResponse(json.usage);
-                if (_optionalChain([recording, 'optionalAccess', _390 => _390.recorder]) && tapped) {
+                if (_optionalChain([recording, 'optionalAccess', _476 => _476.recorder]) && tapped) {
                   recording.recorder.record({
                     messageId: _nullishCoalesce(options.messageId, () => ( null)),
                     parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -6165,7 +7135,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
                     rawUsage: json.usage
                   });
                 }
-                _optionalChain([callbacks, 'access', _391 => _391.onDone, 'optionalCall', _392 => _392(
+                _optionalChain([callbacks, 'access', _477 => _477.onDone, 'optionalCall', _478 => _478(
                   {
                     id: messageId,
                     role: "assistant",
@@ -6186,7 +7156,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
           }
         }
       }
-      _optionalChain([callbacks, 'access', _393 => _393.onDone, 'optionalCall', _394 => _394({
+      _optionalChain([callbacks, 'access', _479 => _479.onDone, 'optionalCall', _480 => _480({
         id: messageId,
         role: "assistant",
         content,
@@ -6198,13 +7168,13 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    _optionalChain([callbacks, 'access', _395 => _395.onError, 'optionalCall', _396 => _396(message)]);
+    _optionalChain([callbacks, 'access', _481 => _481.onError, 'optionalCall', _482 => _482(message)]);
   }
 }
 
 // src/completion/CompletionService.ts
-var CompletionService = (_class13 = class {
-  constructor(paths, llmConfig, logger) {;_class13.prototype.__init23.call(this);_class13.prototype.__init24.call(this);_class13.prototype.__init25.call(this);_class13.prototype.__init26.call(this);
+var CompletionService = (_class15 = class {
+  constructor(paths, llmConfig, logger) {;_class15.prototype.__init30.call(this);_class15.prototype.__init31.call(this);_class15.prototype.__init32.call(this);_class15.prototype.__init33.call(this);
     this.paths = paths;
     this.llmConfig = llmConfig;
     this.logger = logger;
@@ -6212,10 +7182,10 @@ var CompletionService = (_class13 = class {
   
   
   
-  __init23() {this.apiKeyPool = null}
-  __init24() {this.usageRecorder = null}
-  __init25() {this.usageEventSink = null}
-  __init26() {this.visionFallbackProvider = null}
+  __init30() {this.apiKeyPool = null}
+  __init31() {this.usageRecorder = null}
+  __init32() {this.usageEventSink = null}
+  __init33() {this.visionFallbackProvider = null}
   /**
    * Set the API key pool service for multi-key load balancing.
    * When set, keys are resolved via the pool instead of directly from the provider.
@@ -6265,8 +7235,8 @@ var CompletionService = (_class13 = class {
         options.providerId,
         options.model
       );
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _397 => _397.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _398 => _398.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _483 => _483.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _484 => _484.actualModelId]) || options.model;
       const provider = await this.getProvider(actualProviderId);
       if (!provider) {
         return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -6299,7 +7269,7 @@ var CompletionService = (_class13 = class {
         this.apiKeyPool.reportSuccess(options.sessionId);
       }
       if (result.success && result.usage && options.sessionId) {
-        _optionalChain([this, 'access', _399 => _399.usageEventSink, 'optionalAccess', _400 => _400.emit, 'call', _401 => _401({
+        _optionalChain([this, 'access', _485 => _485.usageEventSink, 'optionalAccess', _486 => _486.emit, 'call', _487 => _487({
           sessionId: options.sessionId,
           modelId: actualModel,
           usage: result.usage,
@@ -6328,8 +7298,8 @@ var CompletionService = (_class13 = class {
         options.model
       );
       this.logger.debug("Resolved routed model", { routedInfo });
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _402 => _402.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _403 => _403.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _488 => _488.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _489 => _489.actualModelId]) || options.model;
       this.logger.debug("Resolved provider and model", { actualProviderId, actualModel });
       const provider = await this.getProvider(actualProviderId);
       this.logger.debug("Retrieved provider", provider ? {
@@ -6341,22 +7311,22 @@ var CompletionService = (_class13 = class {
         enabled: provider.enabled
       } : { error: "Provider not found" });
       if (!provider) {
-        _optionalChain([callbacks, 'access', _404 => _404.onError, 'optionalCall', _405 => _405(`Provider not found: ${actualProviderId}`)]);
+        _optionalChain([callbacks, 'access', _490 => _490.onError, 'optionalCall', _491 => _491(`Provider not found: ${actualProviderId}`)]);
         return;
       }
       if (!provider.enabled) {
-        _optionalChain([callbacks, 'access', _406 => _406.onError, 'optionalCall', _407 => _407(`Provider is disabled: ${provider.name}`)]);
+        _optionalChain([callbacks, 'access', _492 => _492.onError, 'optionalCall', _493 => _493(`Provider is disabled: ${provider.name}`)]);
         return;
       }
       const apiKey = await this.resolveApiKeyForRequest(provider, actualProviderId, options.sessionId);
       if (!apiKey) {
-        _optionalChain([callbacks, 'access', _408 => _408.onError, 'optionalCall', _409 => _409("API key not configured")]);
+        _optionalChain([callbacks, 'access', _494 => _494.onError, 'optionalCall', _495 => _495("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', _410 => _410.onStart, 'optionalCall', _411 => _411(messageId)]);
+      _optionalChain([callbacks, 'access', _496 => _496.onStart, 'optionalCall', _497 => _497(messageId)]);
       const resolvedOptions = { ...options, model: actualModel };
       if (options.sessionId) {
         const sid = options.sessionId;
@@ -6365,14 +7335,14 @@ var CompletionService = (_class13 = class {
           ...callbacks,
           onDone: (message, usage, metrics) => {
             if (usage) {
-              _optionalChain([this, 'access', _412 => _412.usageEventSink, 'optionalAccess', _413 => _413.emit, 'call', _414 => _414({
+              _optionalChain([this, 'access', _498 => _498.usageEventSink, 'optionalAccess', _499 => _499.emit, 'call', _500 => _500({
                 sessionId: sid,
                 modelId: actualModel,
                 usage,
                 engineOrigin: "completion"
               })]);
             }
-            _optionalChain([userOnDone, 'optionalCall', _415 => _415(message, usage, metrics)]);
+            _optionalChain([userOnDone, 'optionalCall', _501 => _501(message, usage, metrics)]);
           }
         };
       }
@@ -6388,11 +7358,11 @@ var CompletionService = (_class13 = class {
               retryState.error = { status, message: error };
               return;
             }
-            _optionalChain([callbacks, 'access', _416 => _416.onError, 'optionalCall', _417 => _417(error)]);
+            _optionalChain([callbacks, 'access', _502 => _502.onError, 'optionalCall', _503 => _503(error)]);
           },
           onDone: (message, usage, metrics) => {
             this.apiKeyPool.reportSuccess(options.sessionId);
-            _optionalChain([callbacks, 'access', _418 => _418.onDone, 'optionalCall', _419 => _419(message, usage, metrics)]);
+            _optionalChain([callbacks, 'access', _504 => _504.onDone, 'optionalCall', _505 => _505(message, usage, metrics)]);
           }
         };
         await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
@@ -6413,7 +7383,7 @@ var CompletionService = (_class13 = class {
               // don't fire onStart again
             });
           } else {
-            _optionalChain([callbacks, 'access', _420 => _420.onError, 'optionalCall', _421 => _421(retryState.error.message)]);
+            _optionalChain([callbacks, 'access', _506 => _506.onError, 'optionalCall', _507 => _507(retryState.error.message)]);
           }
         }
       } else {
@@ -6426,7 +7396,7 @@ var CompletionService = (_class13 = 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', _422 => _422.onError, 'optionalCall', _423 => _423(message)]);
+      _optionalChain([callbacks, 'access', _508 => _508.onError, 'optionalCall', _509 => _509(message)]);
     }
   }
   /**
@@ -6466,7 +7436,7 @@ var CompletionService = (_class13 = class {
         return {
           success: true,
           message: "Connection successful",
-          response: _optionalChain([result, 'access', _424 => _424.message, 'optionalAccess', _425 => _425.content]) || "",
+          response: _optionalChain([result, 'access', _510 => _510.message, 'optionalAccess', _511 => _511.content]) || "",
           model: modelId,
           durationMs
         };
@@ -6531,7 +7501,7 @@ ${description}`;
    * 3. Legacy single key from provider config
    */
   async resolveApiKeyForRequest(provider, providerId, sessionId) {
-    if (_optionalChain([provider, 'access', _426 => _426.codingPlan, 'optionalAccess', _427 => _427.enabled]) && provider.codingPlan.apiKey) {
+    if (_optionalChain([provider, 'access', _512 => _512.codingPlan, 'optionalAccess', _513 => _513.enabled]) && provider.codingPlan.apiKey) {
       return this.resolveApiKey(provider.codingPlan.apiKey);
     }
     if (this.apiKeyPool) {
@@ -6697,7 +7667,34 @@ ${description}`;
       builtinExecutor
     );
   }
-}, _class13);
+}, _class15);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -6791,4 +7788,4 @@ ${description}`;
 
 
 
-exports.CompletionService = CompletionService; exports.register = register; exports.emit = emit; exports.attach = attach; exports.release = release; exports.convertMessageToOpenAI = convertMessageToOpenAI; exports.convertMessageToAnthropic = convertMessageToAnthropic; exports.convertMessageToGemini = convertMessageToGemini; exports.getOpenRouterProviderConfig = getOpenRouterProviderConfig; exports.addOpenRouterProviderToRequest = addOpenRouterProviderToRequest; exports.DEFAULT_ROUTE_IDLE_MS = DEFAULT_ROUTE_IDLE_MS; exports.ProviderProxyRouteMap = ProviderProxyRouteMap; exports.getSharedExecutor = getSharedExecutor; exports.getResponsesEndpointTransformer = getResponsesEndpointTransformer; exports.getAnthropicEndpointTransformer = getAnthropicEndpointTransformer; exports.getGeminiEndpointTransformer = getGeminiEndpointTransformer; exports.readBody = readBody; exports.relayResponse = relayResponse; exports.aggregateAnthropicSseToJsonBody = aggregateAnthropicSseToJsonBody; exports.writeError = writeError; exports.writeBoundAccountError = writeBoundAccountError; exports.resolvePoolBoundKey = resolvePoolBoundKey; exports.extractRouteToken = extractRouteToken; exports.isLoopbackAddress = isLoopbackAddress; exports.ProviderProxy = ProviderProxy; exports.getProviderProxy = getProviderProxy; exports.__resetProviderProxyForTests = __resetProviderProxyForTests; exports.KeyedMutex = KeyedMutex; exports.OUTBOUND_API_SERVER_CONFIG_KEY = OUTBOUND_API_SERVER_CONFIG_KEY; exports.DEFAULT_USER_MESSAGE_QUEUE = DEFAULT_USER_MESSAGE_QUEUE; exports.DEFAULT_CONCURRENCY_QUEUE = DEFAULT_CONCURRENCY_QUEUE; exports.DEFAULT_ACCOUNT_PROBE = DEFAULT_ACCOUNT_PROBE; exports.DEFAULT_ALLOWANCE_SCHEDULING = DEFAULT_ALLOWANCE_SCHEDULING; exports.normalizeAllowanceScheduling = normalizeAllowanceScheduling; exports.normalizeAccountProbe = normalizeAccountProbe; exports.normalizeAudit = normalizeAudit; exports.normalizeBilling = normalizeBilling; exports.DEFAULT_FINGERPRINT = DEFAULT_FINGERPRINT; exports.normalizeFingerprint = normalizeFingerprint; exports.normalizeVoucher = normalizeVoucher; exports.normalizeProxyConfig = normalizeProxyConfig; exports.normalizeProxySegment = normalizeProxySegment; exports.normalizeWebhookDestination = normalizeWebhookDestination; exports.normalizeWebhookSegment = normalizeWebhookSegment; exports.normalizeQueueSegments = normalizeQueueSegments; exports.normalizePrefixTargets = normalizePrefixTargets; exports.legacyEndpointsToBindings = legacyEndpointsToBindings; exports.normalizeGatewayBindings = normalizeGatewayBindings; exports.defaultServerConfig = defaultServerConfig; exports.normalizeServerConfig = normalizeServerConfig; exports.loadServerConfig = loadServerConfig; exports.saveServerConfig = saveServerConfig; exports.mergeServerConfig = mergeServerConfig; exports.gatewayBindingToEndpointConfig = gatewayBindingToEndpointConfig; exports.candidateGatewayBindings = candidateGatewayBindings; exports.candidateBackgroundModelIds = candidateBackgroundModelIds; exports.resolveGatewayBinding = resolveGatewayBinding; exports.computeKeyExpiry = computeKeyExpiry; exports.checkKeyQuota = checkKeyQuota; exports.randomBase62 = randomBase62; exports.hashKey = hashKey; exports.createNamedKey = createNamedKey; exports.createIntegrationKey = createIntegrationKey; exports.verifyKey = verifyKey; exports.verifyPresentedKey = verifyPresentedKey; exports.ConcurrencyQueueFullError = ConcurrencyQueueFullError; exports.ConcurrencyWaitTimeoutError = ConcurrencyWaitTimeoutError; exports.ConcurrencyWaitCancelledError = ConcurrencyWaitCancelledError; exports.isConcurrencyRejection = isConcurrencyRejection; exports.OutboundConcurrencyGate = OutboundConcurrencyGate; exports.OutboundRateLimiter = OutboundRateLimiter; exports.isUserMessageRequest = isUserMessageRequest; exports.SerialQueueTimeoutError = SerialQueueTimeoutError; exports.isSerialQueueTimeout = isSerialQueueTimeout; exports.UserMessageSerialQueue = UserMessageSerialQueue; exports.generateVoucherCode = generateVoucherCode; exports.hashVoucherCode = hashVoucherCode; exports.voucherCodePrefix = voucherCodePrefix; exports.newVoucherId = newVoucherId; exports.computeVoucherGrant = computeVoucherGrant; exports.toVoucherInfo = toVoucherInfo; exports.isRedeemRequest = isRedeemRequest; exports.handleVoucherRedeem = handleVoucherRedeem; exports.DEFAULT_OUTBOUND_PORT = DEFAULT_OUTBOUND_PORT; exports.OutboundApiServer = OutboundApiServer; exports.formatUrls = formatUrls; exports.startOfLocalDay = startOfLocalDay; exports.startOfLocalWeek = startOfLocalWeek; exports.KeySpendTracker = KeySpendTracker; exports.getOutboundApiServer = getOutboundApiServer; exports.__resetOutboundApiServerForTests = __resetOutboundApiServerForTests;
+exports.CompletionService = CompletionService; exports.register = register; exports.emit = emit; exports.attach = attach; exports.release = release; exports.convertMessageToOpenAI = convertMessageToOpenAI; exports.convertMessageToAnthropic = convertMessageToAnthropic; exports.convertMessageToGemini = convertMessageToGemini; exports.getOpenRouterProviderConfig = getOpenRouterProviderConfig; exports.addOpenRouterProviderToRequest = addOpenRouterProviderToRequest; exports.DEFAULT_ROUTE_IDLE_MS = DEFAULT_ROUTE_IDLE_MS; exports.ProviderProxyRouteMap = ProviderProxyRouteMap; exports.getSharedExecutor = getSharedExecutor; exports.getResponsesEndpointTransformer = getResponsesEndpointTransformer; exports.getAnthropicEndpointTransformer = getAnthropicEndpointTransformer; exports.getGeminiEndpointTransformer = getGeminiEndpointTransformer; exports.readBody = readBody; exports.relayResponse = relayResponse; exports.aggregateAnthropicSseToJsonBody = aggregateAnthropicSseToJsonBody; exports.writeError = writeError; exports.writeBoundAccountError = writeBoundAccountError; exports.resolvePoolBoundKey = resolvePoolBoundKey; exports.extractRouteToken = extractRouteToken; exports.isLoopbackAddress = isLoopbackAddress; exports.ProviderProxy = ProviderProxy; exports.ROUTE_LEASE_REQUEST_SCHEMA = ROUTE_LEASE_REQUEST_SCHEMA; exports.ROUTE_LEASE_RESULT_SCHEMA = ROUTE_LEASE_RESULT_SCHEMA; exports.ROUTE_LEASE_CAPABILITIES_SCHEMA = ROUTE_LEASE_CAPABILITIES_SCHEMA; exports.ROUTE_LEASE_API_VERSION = ROUTE_LEASE_API_VERSION; exports.ROUTE_LEASE_DEFAULT_TTL_SECONDS = ROUTE_LEASE_DEFAULT_TTL_SECONDS; exports.ROUTE_LEASE_MAX_TTL_SECONDS = ROUTE_LEASE_MAX_TTL_SECONDS; exports.ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES = ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES; exports.ROUTE_LEASE_MAX_CONSUMER_BYTES = ROUTE_LEASE_MAX_CONSUMER_BYTES; exports.ROUTE_LEASE_MAX_EXECUTION_ID_BYTES = ROUTE_LEASE_MAX_EXECUTION_ID_BYTES; exports.ROUTE_LEASE_MAX_SESSION_ID_BYTES = ROUTE_LEASE_MAX_SESSION_ID_BYTES; exports.ROUTE_LEASE_MAX_MODEL_BYTES = ROUTE_LEASE_MAX_MODEL_BYTES; exports.ROUTE_LEASE_SESSION_HASH_DOMAIN = ROUTE_LEASE_SESSION_HASH_DOMAIN; exports.ROUTE_LEASE_CODEX_TOKEN_ENV = ROUTE_LEASE_CODEX_TOKEN_ENV; exports.ROUTE_LEASE_RUNTIMES = ROUTE_LEASE_RUNTIMES; exports.ROUTE_LEASE_CAPABILITIES = ROUTE_LEASE_CAPABILITIES; exports.ROUTE_LEASE_RUNTIME_TABLE = ROUTE_LEASE_RUNTIME_TABLE; exports.RouteLeaseError = RouteLeaseError; exports.normalizeRouteLeaseIdempotencyKey = normalizeRouteLeaseIdempotencyKey; exports.normalizeRouteLeaseTtl = normalizeRouteLeaseTtl; exports.hashRouteLeaseSessionId = hashRouteLeaseSessionId; exports.canonicalizeRouteLeasePayload = canonicalizeRouteLeasePayload; exports.hashRouteLeasePayload = hashRouteLeasePayload; exports.parseRouteLeaseCreate = parseRouteLeaseCreate; exports.routeLeaseRuntime = routeLeaseRuntime; exports.SYSTEM_ROUTE_LEASE_CLOCK = SYSTEM_ROUTE_LEASE_CLOCK; exports.RouteLeaseManager = RouteLeaseManager; exports.gatewayBindingToEndpointConfig = gatewayBindingToEndpointConfig; exports.candidateGatewayBindings = candidateGatewayBindings; exports.candidateBackgroundModelIds = candidateBackgroundModelIds; exports.resolveGatewayBinding = resolveGatewayBinding; exports.RouteLeaseTargetResolver = RouteLeaseTargetResolver; exports.getProviderProxy = getProviderProxy; exports.__resetProviderProxyForTests = __resetProviderProxyForTests; exports.KeyedMutex = KeyedMutex; exports.OUTBOUND_API_SERVER_CONFIG_KEY = OUTBOUND_API_SERVER_CONFIG_KEY; exports.DEFAULT_USER_MESSAGE_QUEUE = DEFAULT_USER_MESSAGE_QUEUE; exports.DEFAULT_CONCURRENCY_QUEUE = DEFAULT_CONCURRENCY_QUEUE; exports.DEFAULT_ACCOUNT_PROBE = DEFAULT_ACCOUNT_PROBE; exports.DEFAULT_ALLOWANCE_SCHEDULING = DEFAULT_ALLOWANCE_SCHEDULING; exports.normalizeAllowanceScheduling = normalizeAllowanceScheduling; exports.normalizeAccountProbe = normalizeAccountProbe; exports.normalizeAudit = normalizeAudit; exports.normalizeBilling = normalizeBilling; exports.DEFAULT_FINGERPRINT = DEFAULT_FINGERPRINT; exports.normalizeFingerprint = normalizeFingerprint; exports.normalizeVoucher = normalizeVoucher; exports.normalizeProxyConfig = normalizeProxyConfig; exports.normalizeProxySegment = normalizeProxySegment; exports.normalizeWebhookDestination = normalizeWebhookDestination; exports.normalizeWebhookSegment = normalizeWebhookSegment; exports.normalizeQueueSegments = normalizeQueueSegments; exports.normalizePrefixTargets = normalizePrefixTargets; exports.legacyEndpointsToBindings = legacyEndpointsToBindings; exports.normalizeGatewayBindings = normalizeGatewayBindings; exports.defaultServerConfig = defaultServerConfig; exports.normalizeServerConfig = normalizeServerConfig; exports.loadServerConfig = loadServerConfig; exports.saveServerConfig = saveServerConfig; exports.mergeServerConfig = mergeServerConfig; exports.computeKeyExpiry = computeKeyExpiry; exports.checkKeyQuota = checkKeyQuota; exports.randomBase62 = randomBase62; exports.hashKey = hashKey; exports.createNamedKey = createNamedKey; exports.createIntegrationKey = createIntegrationKey; exports.verifyKey = verifyKey; exports.verifyPresentedKey = verifyPresentedKey; exports.ConcurrencyQueueFullError = ConcurrencyQueueFullError; exports.ConcurrencyWaitTimeoutError = ConcurrencyWaitTimeoutError; exports.ConcurrencyWaitCancelledError = ConcurrencyWaitCancelledError; exports.isConcurrencyRejection = isConcurrencyRejection; exports.OutboundConcurrencyGate = OutboundConcurrencyGate; exports.OutboundRateLimiter = OutboundRateLimiter; exports.isUserMessageRequest = isUserMessageRequest; exports.SerialQueueTimeoutError = SerialQueueTimeoutError; exports.isSerialQueueTimeout = isSerialQueueTimeout; exports.UserMessageSerialQueue = UserMessageSerialQueue; exports.generateVoucherCode = generateVoucherCode; exports.hashVoucherCode = hashVoucherCode; exports.voucherCodePrefix = voucherCodePrefix; exports.newVoucherId = newVoucherId; exports.computeVoucherGrant = computeVoucherGrant; exports.toVoucherInfo = toVoucherInfo; exports.isRedeemRequest = isRedeemRequest; exports.handleVoucherRedeem = handleVoucherRedeem; exports.DEFAULT_OUTBOUND_PORT = DEFAULT_OUTBOUND_PORT; exports.OutboundApiServer = OutboundApiServer; exports.formatUrls = formatUrls; exports.startOfLocalDay = startOfLocalDay; exports.startOfLocalWeek = startOfLocalWeek; exports.KeySpendTracker = KeySpendTracker; exports.getOutboundApiServer = getOutboundApiServer; exports.__resetOutboundApiServerForTests = __resetOutboundApiServerForTests;