@omnicross/core 0.1.2 → 0.1.3

package/dist/{chunk-SN3YWBX7.cjs → chunk-2FMI2B6V.cjs}

@@ -1,7 +1,4 @@
-"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 _chunkSPVWWUHXcjs = require('./chunk-SPVWWUHX.cjs');
-
+"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 _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
 
@@ -9,7 +6,7 @@ var _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
 var _chunk46ZIFWYGcjs = require('./chunk-46ZIFWYG.cjs');
 
 
-var _chunkGBHYAGX3cjs = require('./chunk-GBHYAGX3.cjs');
+var _chunk4VAVYUZScjs = require('./chunk-4VAVYUZS.cjs');
 
 
 var _chunk7YN22L2Hcjs = require('./chunk-7YN22L2H.cjs');
@@ -18,52 +15,88 @@ var _chunk7YN22L2Hcjs = require('./chunk-7YN22L2H.cjs');
 var _chunk2DCNB7DFcjs = require('./chunk-2DCNB7DF.cjs');
 
 
-var _chunk4VAVYUZScjs = require('./chunk-4VAVYUZS.cjs');
+var _chunk3QOSDDNIcjs = require('./chunk-3QOSDDNI.cjs');
 
 
-var _chunkR3HK6R4Bcjs = require('./chunk-R3HK6R4B.cjs');
+var _chunkGBHYAGX3cjs = require('./chunk-GBHYAGX3.cjs');
 
 
-var _chunkKUU2RNG6cjs = require('./chunk-KUU2RNG6.cjs');
+var _chunkRPII3E6Zcjs = require('./chunk-RPII3E6Z.cjs');
 
 
 
-var _chunkLKZJEL6Ecjs = require('./chunk-LKZJEL6E.cjs');
+var _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
 
 
-var _chunkQXD4MV2Xcjs = require('./chunk-QXD4MV2X.cjs');
+
+var _chunkQWBWGODScjs = require('./chunk-QWBWGODS.cjs');
 
 
 var _chunkNYUNU75Acjs = require('./chunk-NYUNU75A.cjs');
 
 
-var _chunkN3V2J5ZOcjs = require('./chunk-N3V2J5ZO.cjs');
+
+var _chunkVQY5W4YWcjs = require('./chunk-VQY5W4YW.cjs');
+
+
+var _chunkY6OM7EV7cjs = require('./chunk-Y6OM7EV7.cjs');
 
 
 var _chunkSVNDB62Dcjs = require('./chunk-SVNDB62D.cjs');
 
 
+var _chunkR3HK6R4Bcjs = require('./chunk-R3HK6R4B.cjs');
+
+
+
+var _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
+
+
+
+var _chunkL74VDN4Acjs = require('./chunk-L74VDN4A.cjs');
+
+
+var _chunkKUU2RNG6cjs = require('./chunk-KUU2RNG6.cjs');
+
+
+
+var _chunkQ27JY5RGcjs = require('./chunk-Q27JY5RG.cjs');
+
+
+var _chunkQXD4MV2Xcjs = require('./chunk-QXD4MV2X.cjs');
+
+
 
 
 var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
 
-var _chunkG2FUJNA2cjs = require('./chunk-G2FUJNA2.cjs');
 
 
 
-var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
 
 
-var _chunkV5KPWNYXcjs = require('./chunk-V5KPWNYX.cjs');
 
 
+var _chunkSVXC36MUcjs = require('./chunk-SVXC36MU.cjs');
+
+
+
+var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
+
+
+var _chunkS6JGLF3Gcjs = require('./chunk-S6JGLF3G.cjs');
+
 
-var _chunk6VIXXLMXcjs = require('./chunk-6VIXXLMX.cjs');
+var _chunkJMJBSACDcjs = require('./chunk-JMJBSACD.cjs');
 
 
 var _chunkGMMT7RVNcjs = require('./chunk-GMMT7RVN.cjs');
 
+
+
+var _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
+
 // src/completion/StreamEventBuffer.ts
 var TERMINAL_TYPES = /* @__PURE__ */ new Set(["done", "error", "abort"]);
 var QUEUE_CAP = 200;
@@ -325,7 +358,7 @@ function convertMessageToGemini(msg) {
 
 // src/completion/openrouter-utils.ts
 function getOpenRouterProviderConfig(provider, modelId) {
-  if (!_chunk6VIXXLMXcjs.isOpenRouterProvider.call(void 0, provider)) {
+  if (!_chunkUNEFIWXIcjs.isOpenRouterProvider.call(void 0, provider)) {
     return void 0;
   }
   const modelConfig = _optionalChain([provider, 'access', _ => _.modelConfigs, 'optionalAccess', _2 => _2.find, 'call', _3 => _3((m) => m.id === modelId)]);
@@ -462,10 +495,11 @@ function recordAnthropicNonStreamUsage(recorder, bodyText, attribution) {
       sessionId: attribution.sessionId,
       providerId: attribution.providerId,
       model: attribution.model,
-      apiKeyId: null,
+      apiKeyId: attribution.apiKeyId,
       engineOrigin: "codex-ingress",
       usage: tapped,
-      rawUsage: parsed.usage
+      rawUsage: parsed.usage,
+      auditResponse: attribution.auditResponse
     });
   } catch (e4) {
   }
@@ -502,7 +536,84 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
-async function relayResponse(res, providerResponse, isStream) {
+function rewriteJsonModel(bodyText, rewriteModel) {
+  try {
+    const obj = JSON.parse(bodyText);
+    if (!obj || typeof obj !== "object") return bodyText;
+    let changed = false;
+    if (typeof obj.model === "string") {
+      obj.model = rewriteModel;
+      changed = true;
+    }
+    const nested = obj.response;
+    if (nested && typeof nested === "object" && typeof nested.model === "string") {
+      nested.model = rewriteModel;
+      changed = true;
+    }
+    return changed ? JSON.stringify(obj) : bodyText;
+  } catch (e5) {
+    return bodyText;
+  }
+}
+function rewriteSseLine(line, rewriteModel) {
+  if (!line.startsWith("data:") || !line.includes('"model"')) return line;
+  const nl = /\r?\n$/.exec(line);
+  const newline = nl ? nl[0] : "";
+  const withoutNl = newline ? line.slice(0, line.length - newline.length) : line;
+  const afterData = withoutNl.slice("data:".length);
+  const leadingSpace = afterData.startsWith(" ") ? " " : "";
+  const payload = afterData.slice(leadingSpace.length);
+  if (payload === "" || payload === "[DONE]") return line;
+  try {
+    const obj = JSON.parse(payload);
+    if (!obj || typeof obj !== "object") return line;
+    const type = typeof obj.type === "string" ? obj.type : "";
+    let changed = false;
+    if (type === "message_start") {
+      const message = obj.message;
+      if (message && typeof message === "object" && typeof message.model === "string") {
+        message.model = rewriteModel;
+        changed = true;
+      }
+    } else if (type === "response.created" || type === "response.in_progress" || type === "response.completed" || type === "response.failed" || type === "response.incomplete") {
+      const response = obj.response;
+      if (response && typeof response === "object" && typeof response.model === "string") {
+        response.model = rewriteModel;
+        changed = true;
+      }
+    }
+    if (!changed) return line;
+    return `data:${leadingSpace}${JSON.stringify(obj)}${newline}`;
+  } catch (e6) {
+    return line;
+  }
+}
+async function relayStreamWithModelRewrite(res, body, rewriteModel) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let out = "";
+      let nlIndex;
+      while ((nlIndex = buffer.indexOf("\n")) !== -1) {
+        const linePart = buffer.slice(0, nlIndex + 1);
+        buffer = buffer.slice(nlIndex + 1);
+        out += rewriteSseLine(linePart, rewriteModel);
+      }
+      if (out) res.write(out);
+    }
+    const tail = buffer + decoder.decode();
+    if (tail) res.write(rewriteSseLine(tail, rewriteModel));
+  } finally {
+    reader.releaseLock();
+    res.end();
+  }
+}
+async function relayResponse(res, providerResponse, isStream, rewriteModel) {
   const contentType = _nullishCoalesce(providerResponse.headers.get("Content-Type"), () => ( ""));
   const status = providerResponse.status && providerResponse.status >= 100 ? providerResponse.status : 200;
   if (isStream || contentType.includes("text/event-stream")) {
@@ -515,6 +626,10 @@ async function relayResponse(res, providerResponse, isStream) {
       res.end();
       return null;
     }
+    if (rewriteModel) {
+      await relayStreamWithModelRewrite(res, providerResponse.body, rewriteModel);
+      return null;
+    }
     const reader = providerResponse.body.getReader();
     try {
       for (; ; ) {
@@ -529,8 +644,9 @@ async function relayResponse(res, providerResponse, isStream) {
     return null;
   }
   const bodyText = await providerResponse.text();
+  const clientText = rewriteModel ? rewriteJsonModel(bodyText, rewriteModel) : bodyText;
   res.writeHead(status, { "Content-Type": contentType.includes("json") ? contentType : "application/json" });
-  res.end(bodyText);
+  res.end(clientText);
   return bodyText;
 }
 function writeError(res, status, message) {
@@ -568,17 +684,18 @@ async function buildSubscriptionPlan(res, route, deps, anthropicBody, routeModel
     resolvedModel = mapped.resolvedModel;
     scenario = mapped.scenario;
   }
-  const plan = buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario);
+  const sessionKey = _chunkQWBWGODScjs.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");
     return null;
   }
   return plan;
 }
-function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario) {
+function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey) {
   const upstreamUrl = _optionalChain([profile, 'access', _8 => _8.resolveUpstreamUrl, 'optionalCall', _9 => _9(resolvedModel, route.subscriptionConfig)]);
   if (!upstreamUrl) return null;
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkN3V2J5ZOcjs.SubscriptionAuthSource)(profile)));
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkY6OM7EV7cjs.SubscriptionAuthSource)(profile)));
   const sameFormat = profile.mode === "pass-through" || upstreamUrl.endsWith("/v1/messages");
   const overrideNames = _optionalChain([profile, 'access', _10 => _10.resolveProviderTransformerNames, 'optionalCall', _11 => _11(
     resolvedModel,
@@ -622,7 +739,8 @@ function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isS
     upstreamUrl,
     sameFormat,
     isSubscription: true,
-    scenario
+    scenario,
+    sessionKey
   };
 }
 function usesResponsesChain(names) {
@@ -641,7 +759,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: _chunkSPVWWUHXcjs.collectMatchText.call(void 0, anthropicBody)
+    matchText: _chunkQWBWGODScjs.collectMatchText.call(void 0, anthropicBody)
   };
 }
 function collectText(value) {
@@ -657,12 +775,24 @@ function collectText(value) {
   }
   return 0;
 }
-async function runPipeline(anthropicBody, plan) {
+function proxyProviderId(plan) {
+  return plan.isSubscription ? plan.transformerProvider.name : "byo";
+}
+async function runPipeline(anthropicBody, plan, reportSelection) {
   const executor = getSharedExecutor();
   const endpointTransformer = getAnthropicEndpointTransformer();
   const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  let proxyAccountId;
   const authHeaders = {};
-  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  await auth.applyHeaders(authHeaders, {
+    upstreamUrl,
+    model: resolvedModel,
+    sessionKey: plan.sessionKey,
+    reportSelection: (accountId, isActive) => {
+      proxyAccountId = accountId;
+      _optionalChain([reportSelection, 'optionalCall', _12 => _12(accountId, isActive)]);
+    }
+  });
   let rawStatus = null;
   const { response } = await _chunkKUU2RNG6cjs.executeProviderCall.call(void 0, {
     executor,
@@ -682,7 +812,11 @@ async function runPipeline(anthropicBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.info(`[ProviderProxy:anthropic] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+      return _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: proxyProviderId(plan), accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -691,29 +825,95 @@ async function runPipeline(anthropicBody, plan) {
   });
   return { response, rawStatus };
 }
-async function runSubscriptionSameFormatFetch(rawBody, plan) {
+async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, options = {}) {
+  let proxyAccountId;
+  let remappedModel;
   const headers = { "content-type": "application/json" };
   await plan.auth.applyHeaders(headers, {
     upstreamUrl: plan.upstreamUrl,
-    model: plan.resolvedModel
+    model: plan.resolvedModel,
+    sessionKey: plan.sessionKey,
+    reportSelection: (accountId, isActive, remapped) => {
+      proxyAccountId = accountId;
+      remappedModel = remapped;
+      _optionalChain([reportSelection, 'optionalCall', _13 => _13(accountId, isActive, remapped)]);
+    }
   });
+  if (plan.isSubscription && plan.transformerProvider.name === "claude") {
+    _chunk6RPZADX3cjs.applyFingerprint.call(void 0, 
+      _chunkRPII3E6Zcjs.getSharedIdentityStore.call(void 0, ),
+      headers,
+      plan.transformerProvider.name,
+      proxyAccountId,
+      options.callerIdentity
+    );
+  }
+  const applyRemap = remappedModel !== void 0 && outboundRemapApplies(plan);
+  const outboundBody = applyRemap ? rewriteBodyModel(rawBody, remappedModel) : rawBody;
+  const outboundModel = applyRemap ? remappedModel : plan.resolvedModel;
   console.info(
-    `[ProviderProxy:anthropic] (subscription same-format) -> ${plan.upstreamUrl} model=${plan.resolvedModel} stream=${plan.isStream}`
+    `[ProviderProxy:anthropic] (subscription same-format) -> ${plan.upstreamUrl} model=${outboundModel} stream=${plan.isStream}`
+  );
+  const response = await _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+    plan.upstreamUrl,
+    { method: "POST", headers, body: outboundBody },
+    { providerId: proxyProviderId(plan), accountId: proxyAccountId }
   );
-  const response = await fetch(plan.upstreamUrl, { method: "POST", headers, body: rawBody });
   return { response, rawStatus: response.status };
 }
-async function runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan) {
-  const runOnce = () => plan.sameFormat ? runSubscriptionSameFormatFetch(relayBody, plan) : runPipeline(anthropicBody, plan);
+function outboundRemapApplies(plan) {
+  return plan.isSubscription && plan.transformerProvider.name === "claude";
+}
+function rewriteBodyModel(rawBody, model) {
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return rawBody;
+    parsed.model = model;
+    return JSON.stringify(parsed);
+  } catch (e7) {
+    return rawBody;
+  }
+}
+async function runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan, options = {}) {
+  let selectedAccountId;
+  const reportSelection = (accountId) => {
+    selectedAccountId = accountId;
+  };
+  const runOnce = () => plan.sameFormat ? runSubscriptionSameFormatFetch(relayBody, plan, reportSelection, options) : runPipeline(anthropicBody, plan, reportSelection);
   const first = await runOnce();
-  if (first.rawStatus !== 401) return first;
-  const refreshed = await _optionalChain([plan, 'access', _12 => _12.auth, 'access', _13 => _13.onUnauthorized, 'optionalCall', _14 => _14()]);
-  if (!refreshed) {
-    console.warn("[ProviderProxy:anthropic] 401 not recoverable (onUnauthorized returned false)");
-    return first;
+  let result = first;
+  if (first.rawStatus === 401) {
+    const refreshed = await _optionalChain([plan, 'access', _14 => _14.auth, 'access', _15 => _15.onUnauthorized, 'optionalCall', _16 => _16(plan.sessionKey)]);
+    if (refreshed) {
+      console.info("[ProviderProxy:anthropic] 401 \u2192 token refreshed; retrying once");
+      result = await runOnce();
+    } else {
+      console.warn("[ProviderProxy:anthropic] 401 not recoverable (onUnauthorized returned false)");
+    }
   }
-  console.info("[ProviderProxy:anthropic] 401 \u2192 token refreshed; retrying once");
-  return runOnce();
+  await markSubscriptionHealth(plan, selectedAccountId, result);
+  return result;
+}
+async function readBoundedBody(response, max = 2048) {
+  try {
+    const text = await response.clone().text();
+    return text.slice(0, max);
+  } catch (e8) {
+    return void 0;
+  }
+}
+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 } = _chunkVQY5W4YWcjs.resolveResetSeconds.call(void 0, providerId, result.response.headers);
+  const bodyText = status === 403 ? await readBoundedBody(result.response) : void 0;
+  _chunkVQY5W4YWcjs.getSharedAccountHealth.call(void 0, ).recordUpstreamOutcome(providerId, selectedAccountId, {
+    status,
+    resetHeaderSeconds,
+    retryAfterSeconds,
+    bodyText
+  });
 }
 function isFallbackEligibleStatus(rawStatus) {
   return rawStatus === null || rawStatus >= 500 || rawStatus === 429;
@@ -726,11 +926,11 @@ function breakerOutcome(rawStatus) {
 function recordBreakerOutcome(profile, modelId, rawStatus) {
   const outcome = breakerOutcome(rawStatus);
   if (outcome === "neutral") return;
-  _optionalChain([profile, 'optionalAccess', _15 => _15.recordModelOutcome, 'optionalCall', _16 => _16(modelId, outcome === "success")]);
+  _optionalChain([profile, 'optionalAccess', _17 => _17.recordModelOutcome, 'optionalCall', _18 => _18(modelId, outcome === "success")]);
 }
-async function runSubscriptionAttemptOutcome(anthropicBody, relayBody, plan) {
+async function runSubscriptionAttemptOutcome(anthropicBody, relayBody, plan, options = {}) {
   try {
-    return { kind: "result", result: await runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan) };
+    return { kind: "result", result: await runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan, options) };
   } catch (error) {
     return { kind: "thrown", error };
   }
@@ -742,11 +942,11 @@ function settleOutcome(outcome) {
   if (outcome.kind === "thrown") throw outcome.error;
   return outcome.result;
 }
-async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialPlan, route, deps) {
+async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialPlan, route, deps, options = {}) {
   const profile = route.subscriptionProfile;
   const scenario = initialPlan.scenario;
-  if (!_optionalChain([profile, 'optionalAccess', _17 => _17.nextFallback]) || scenario === void 0) {
-    const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan);
+  if (!_optionalChain([profile, 'optionalAccess', _19 => _19.nextFallback]) || scenario === void 0) {
+    const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan, options);
     recordBreakerOutcome(profile, initialPlan.resolvedModel, outcomeStatus(loneOutcome));
     return settleOutcome(loneOutcome);
   }
@@ -757,7 +957,7 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
   if (profile.allowModel && !profile.allowModel(initialPlan.resolvedModel)) {
     attempted.push(initialPlan.resolvedModel);
     const firstAdmitting = profile.nextFallback(scenario, attempted, route.subscriptionConfig);
-    const gatedPlan = firstAdmitting ? buildSubscriptionIterationPlan(profile, route, deps, firstAdmitting.modelId, initialPlan.isStream, scenario) : null;
+    const gatedPlan = firstAdmitting ? buildSubscriptionIterationPlan(profile, route, deps, firstAdmitting.modelId, initialPlan.isStream, scenario, initialPlan.sessionKey) : null;
     if (firstAdmitting && gatedPlan) {
       console.warn(
         `[ProviderProxy:anthropic] subscription primary ${initialPlan.resolvedModel} circuit open -> first admitting fallback ${firstAdmitting.modelId}`
@@ -772,7 +972,7 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
       );
     }
   }
-  let outcome = await runSubscriptionAttemptOutcome(firstBodyObj, firstRelayBody, plan);
+  let outcome = await runSubscriptionAttemptOutcome(firstBodyObj, firstRelayBody, plan, options);
   recordBreakerOutcome(profile, plan.resolvedModel, outcomeStatus(outcome));
   if (!attempted.includes(plan.resolvedModel)) attempted.push(plan.resolvedModel);
   while (attempted.length < MAX_FALLBACK_ATTEMPTS) {
@@ -785,7 +985,8 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
       deps,
       next.modelId,
       plan.isStream,
-      scenario
+      scenario,
+      initialPlan.sessionKey
     );
     if (!nextPlan) return settleOutcome(outcome);
     const sinceLabel = outcome.kind === "thrown" ? "thrown error" : `status ${String(outcome.result.rawStatus)}`;
@@ -796,7 +997,7 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
     const fallbackRelayBody = nextPlan.sameFormat ? JSON.stringify(fallbackBodyObj) : rawBody;
     plan = nextPlan;
     attempted.push(next.modelId);
-    outcome = await runSubscriptionAttemptOutcome(fallbackBodyObj, fallbackRelayBody, plan);
+    outcome = await runSubscriptionAttemptOutcome(fallbackBodyObj, fallbackRelayBody, plan, options);
     recordBreakerOutcome(profile, plan.resolvedModel, outcomeStatus(outcome));
   }
   return settleOutcome(outcome);
@@ -808,7 +1009,7 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
   let anthropicBody;
   try {
     anthropicBody = JSON.parse(rawBody);
-  } catch (e5) {
+  } catch (e9) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -819,13 +1020,16 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
     const plan = route.authMode === "subscription" ? await buildSubscriptionPlan(res, route, deps, anthropicBody, resolvedModel, isStream) : await buildByoPlan(res, route, deps, resolvedModel, isStream);
     if (!plan) return;
     anthropicBody.model = plan.resolvedModel;
-    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry(anthropicBody, rawBody, plan, route, deps) : await runPipelineWithPoolReporting(anthropicBody, rawBody, plan, options);
-    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry(anthropicBody, rawBody, plan, route, deps, options) : await runPipelineWithPoolReporting(anthropicBody, rawBody, plan, options);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream, route.requestedModel);
     if (bodyText && deps.usageRecorder) {
       recordAnthropicNonStreamUsage(deps.usageRecorder, bodyText, {
         sessionId: route.sessionId,
         providerId: _nullishCoalesce(route.providerId, () => ( "anthropic")),
-        model: plan.resolvedModel
+        model: plan.resolvedModel,
+        apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -850,7 +1054,7 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     writeError(res, 502, "API key not configured");
     return null;
   }
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkLKZJEL6Ecjs.LlmConfigProviderAuth)({
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkQ27JY5RGcjs.LlmConfigProviderAuth)({
     provider,
     apiKey,
     apiKeyPool: _nullishCoalesce(deps.apiKeyPool, () => ( null)),
@@ -878,17 +1082,17 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     isSubscription: false,
     provider,
     apiKey,
-    extendedContextEnabled: _nullishCoalesce(_optionalChain([route, 'access', _18 => _18.anthropicSdkHints, 'optionalAccess', _19 => _19.extendedContext, 'optionalAccess', _20 => _20.enabled]), () => ( false))
+    extendedContextEnabled: _nullishCoalesce(_optionalChain([route, 'access', _20 => _20.anthropicSdkHints, 'optionalAccess', _21 => _21.extendedContext, 'optionalAccess', _22 => _22.enabled]), () => ( false))
   };
 }
-async function runSameFormatFetch(rawBody, plan, options, keyOverride) {
+async function runSameFormatFetch(bodyToSend, plan, options, keyOverride) {
   const { provider, apiKey, resolvedModel, isStream, extendedContextEnabled } = plan;
   if (!provider) {
     throw new Error("[ProviderProxy:anthropic] same-format BYO path requires a provider row");
   }
   const effectiveKey = _nullishCoalesce(_nullishCoalesce(keyOverride, () => ( apiKey)), () => ( ""));
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, effectiveKey);
-  const callerBeta = _optionalChain([options, 'access', _21 => _21.callerAnthropicBeta, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, effectiveKey);
+  const callerBeta = _optionalChain([options, 'access', _23 => _23.callerAnthropicBeta, 'optionalAccess', _24 => _24.trim, 'call', _25 => _25()]);
   if (callerBeta) {
     const existing = _nullishCoalesce(headers["anthropic-beta"], () => ( headers["Anthropic-Beta"]));
     const parts = new Set(
@@ -902,14 +1106,29 @@ async function runSameFormatFetch(rawBody, 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 fetch(url, { method: "POST", headers, body: rawBody });
+  const response = await _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+    url,
+    { method: "POST", headers, body: bodyToSend },
+    { providerId: "byo" }
+  );
   return { response, rawStatus: response.status };
 }
+function resolveSameFormatBody(anthropicBody, rawBody, plan) {
+  let originalModel;
+  try {
+    const m = JSON.parse(rawBody).model;
+    originalModel = typeof m === "string" ? m : void 0;
+  } catch (e10) {
+    originalModel = void 0;
+  }
+  return plan.resolvedModel !== originalModel ? JSON.stringify(anthropicBody) : rawBody;
+}
 async function runPipelineWithPoolReporting(anthropicBody, rawBody, plan, options) {
-  const runOnce = (keyOverride) => plan.sameFormat ? runSameFormatFetch(rawBody, plan, options, keyOverride) : runPipeline(anthropicBody, plan);
+  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', _24 => _24.auth, 'access', _25 => _25.onResult, 'optionalCall', _26 => _26(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _27 => _27.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _26 => _26.auth, 'access', _27 => _27.onResult, 'optionalCall', _28 => _28(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _29 => _29.rebound])) {
     console.info(
       "[ProviderProxy:anthropic] pool re-bound key after status",
       first.rawStatus,
@@ -930,7 +1149,8 @@ async function handleAnthropicMessagesRequest(req, res, route, deps) {
     const rawBody = await readBody(req);
     const callerBetaRaw = req.headers["anthropic-beta"];
     const callerAnthropicBeta = Array.isArray(callerBetaRaw) ? callerBetaRaw.join(",") : callerBetaRaw;
-    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta });
+    const callerIdentity = _chunk6RPZADX3cjs.captureCallerIdentity.call(void 0, _chunkRPII3E6Zcjs.getSharedIdentityStore.call(void 0, ), req.headers);
+    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta, callerIdentity });
     return;
   }
   const hints = route.anthropicSdkHints;
@@ -992,12 +1212,13 @@ function recordGeminiNonStreamUsage(recorder, bodyText, attribution) {
       sessionId: attribution.sessionId,
       providerId: attribution.providerId,
       model: attribution.model,
-      apiKeyId: null,
+      apiKeyId: attribution.apiKeyId,
+      auditResponse: attribution.auditResponse,
       engineOrigin: "codex-ingress",
       usage: tapped,
       rawUsage: parsed.usageMetadata
     });
-  } catch (e6) {
+  } catch (e11) {
   }
 }
 
@@ -1006,14 +1227,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', _28 => _28.split, 'call', _29 => _29("?"), 'access', _30 => _30[0], 'optionalAccess', _31 => _31.replace, 'call', _32 => _32(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _30 => _30.split, 'call', _31 => _31("?"), 'access', _32 => _32[0], 'optionalAccess', _33 => _33.replace, 'call', _34 => _34(/\/+$/, "")]), () => ( ""));
   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', _33 => _33.replace, 'call', _34 => _34(/\/+$/, "")]), () => ( ""))).split("/").pop(), () => ( ""));
+  const lastSegment = _nullishCoalesce((_nullishCoalesce(_optionalChain([path, 'optionalAccess', _35 => _35.replace, 'call', _36 => _36(/\/+$/, "")]), () => ( ""))).split("/").pop(), () => ( ""));
   if (lastSegment.includes(STREAM_GENERATE_CONTENT_ACTION)) return true;
   return /(^|&)alt=sse(&|$)/.test(query);
 }
@@ -1021,7 +1242,7 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
   let geminiBody;
   try {
     geminiBody = JSON.parse(rawBody);
-  } catch (e7) {
+  } catch (e12) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -1042,7 +1263,10 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
       recordGeminiNonStreamUsage(deps.usageRecorder, bodyText, {
         sessionId: route.sessionId,
         providerId: _nullishCoalesce(route.providerId, () => ( "gemini")),
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1067,7 +1291,7 @@ async function buildByoPlan2(res, route, deps, resolvedModel, isStream) {
     writeError(res, 502, "API key not configured");
     return null;
   }
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkLKZJEL6Ecjs.LlmConfigProviderAuth)({
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkQ27JY5RGcjs.LlmConfigProviderAuth)({
     provider,
     apiKey,
     apiKeyPool: _nullishCoalesce(deps.apiKeyPool, () => ( null)),
@@ -1117,7 +1341,11 @@ async function runPipeline2(geminiBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.log(`[ProviderProxy:gemini] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+      return _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: "byo" }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1128,8 +1356,8 @@ async function runPipeline2(geminiBody, plan) {
 }
 async function runPipelineWithPoolReporting2(geminiBody, plan) {
   const first = await runPipeline2(geminiBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _35 => _35.auth, 'access', _36 => _36.onResult, 'optionalCall', _37 => _37(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _38 => _38.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _37 => _37.auth, 'access', _38 => _38.onResult, 'optionalCall', _39 => _39(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _40 => _40.rebound])) {
     console.log(
       "[ProviderProxy:gemini] pool re-bound key after status",
       first.rawStatus,
@@ -1169,46 +1397,48 @@ function recordChatCompletionsNonStreamUsage(recorder, bodyText, attribution) {
       sessionId: attribution.sessionId,
       providerId: attribution.providerId,
       model: attribution.model,
-      apiKeyId: null,
+      apiKeyId: attribution.apiKeyId,
+      auditResponse: attribution.auditResponse,
       engineOrigin: "codex-ingress",
       usage: tapped,
       rawUsage: parsed.usage
     });
-  } catch (e8) {
+  } catch (e13) {
   }
 }
 
 // src/provider-proxy/ingress/openaiChatIngress.ts
 function isOpenAIChatRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _39 => _39.split, 'call', _40 => _40("?"), 'access', _41 => _41[0], 'optionalAccess', _42 => _42.replace, 'call', _43 => _43(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _41 => _41.split, 'call', _42 => _42("?"), 'access', _43 => _43[0], 'optionalAccess', _44 => _44.replace, 'call', _45 => _45(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/chat/completions");
 }
+var CHAT_BRIDGE_SUBSCRIPTION_PROVIDERS = /* @__PURE__ */ new Set(["claude"]);
+var IDENTITY_ENDPOINT_TRANSFORMER = { name: "identity-openai-chat" };
 async function handleOpenAIChatRequest(res, rawBody, route, deps) {
   let chatBody;
   try {
     chatBody = JSON.parse(rawBody);
-  } catch (e9) {
+  } catch (e14) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
-  if (route.authMode === "subscription") {
-    writeError(res, 502, "OpenAI Chat Completions ingress does not support subscription auth");
-    return;
-  }
   const isStream = chatBody.stream === true;
   const resolvedModel = route.model;
   chatBody.model = resolvedModel;
   try {
-    const plan = await buildByoPlan3(res, route, deps, resolvedModel, isStream);
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) : await buildByoPlan3(res, route, deps, resolvedModel, isStream);
     if (!plan) return;
-    const providerResponse = await runPipelineWithPoolReporting3(chatBody, plan);
+    const providerResponse = plan.isSubscription ? await runPipelineWithSubscriptionRetry2(chatBody, plan) : await runPipelineWithPoolReporting3(chatBody, plan);
     const bodyText = await relayResponse(res, providerResponse.response, isStream);
     if (bodyText && deps.usageRecorder) {
       recordChatCompletionsNonStreamUsage(deps.usageRecorder, bodyText, {
         sessionId: route.sessionId,
         providerId: _nullishCoalesce(route.providerId, () => ( "openai")),
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1233,7 +1463,7 @@ async function buildByoPlan3(res, route, deps, resolvedModel, isStream) {
     writeError(res, 502, "API key not configured");
     return null;
   }
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkLKZJEL6Ecjs.LlmConfigProviderAuth)({
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkQ27JY5RGcjs.LlmConfigProviderAuth)({
     provider,
     apiKey,
     apiKeyPool: _nullishCoalesce(deps.apiKeyPool, () => ( null)),
@@ -1255,14 +1485,67 @@ async function buildByoPlan3(res, route, deps, resolvedModel, isStream) {
     resolvedModel,
     isStream,
     resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
-    upstreamUrl: byoUrl
+    upstreamUrl: byoUrl,
+    proxyProviderId: "byo",
+    isSubscription: false
+  };
+}
+async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) {
+  const profile = route.subscriptionProfile;
+  if (!profile) {
+    writeError(res, 502, "Subscription mode requires a subscription profile");
+    return null;
+  }
+  const providerId = profile.authStrategy.providerId;
+  if (!CHAT_BRIDGE_SUBSCRIPTION_PROVIDERS.has(providerId)) {
+    writeError(
+      res,
+      501,
+      `the OpenAI-chat\u2192subscription bridge currently supports claude only; subscription provider '${providerId}' is not implemented on this endpoint yet (use the /v1/responses endpoint, a Claude subscription, or a BYO provider)`
+    );
+    return null;
+  }
+  const upstreamUrl = _optionalChain([profile, 'access', _46 => _46.resolveUpstreamUrl, 'optionalCall', _47 => _47(resolvedModel)]);
+  if (!upstreamUrl) {
+    writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
+    return null;
+  }
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkY6OM7EV7cjs.SubscriptionAuthSource)(profile)));
+  const chain = _chunkNYUNU75Acjs.resolveSubscriptionChain.call(void 0, 
+    profile,
+    deps.llmConfig.getTransformerService(),
+    IDENTITY_ENDPOINT_TRANSFORMER
+  );
+  const transformerProvider = {
+    name: providerId,
+    baseUrl: upstreamUrl,
+    apiKey: "",
+    models: [resolvedModel]
+  };
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : typeof config.url === "string" ? config.url : upstreamUrl,
+    upstreamUrl,
+    proxyProviderId: providerId,
+    isSubscription: true
   };
 }
 async function runPipeline3(chatBody, plan) {
   const executor = getSharedExecutor();
   const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  let proxyAccountId;
   const authHeaders = {};
-  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  await auth.applyHeaders(authHeaders, {
+    upstreamUrl,
+    model: resolvedModel,
+    reportSelection: (accountId) => {
+      proxyAccountId = accountId;
+    }
+  });
   let rawStatus = null;
   const { response } = await _chunkKUU2RNG6cjs.executeProviderCall.call(void 0, {
     executor,
@@ -1281,7 +1564,11 @@ async function runPipeline3(chatBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.log(`[ProviderProxy:chat] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+      return _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1292,8 +1579,8 @@ async function runPipeline3(chatBody, plan) {
 }
 async function runPipelineWithPoolReporting3(chatBody, plan) {
   const first = await runPipeline3(chatBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _44 => _44.auth, 'access', _45 => _45.onResult, 'optionalCall', _46 => _46(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _47 => _47.rebound])) {
+  const outcome = await _optionalChain([plan, 'access', _48 => _48.auth, 'access', _49 => _49.onResult, 'optionalCall', _50 => _50(first.rawStatus)]);
+  if (_optionalChain([outcome, 'optionalAccess', _51 => _51.rebound])) {
     console.log(
       "[ProviderProxy:chat] pool re-bound key after status",
       first.rawStatus,
@@ -1303,6 +1590,17 @@ async function runPipelineWithPoolReporting3(chatBody, plan) {
   }
   return first;
 }
+async function runPipelineWithSubscriptionRetry2(chatBody, plan) {
+  const first = await runPipeline3(chatBody, plan);
+  if (first.rawStatus !== 401) return first;
+  const refreshed = await _optionalChain([plan, 'access', _52 => _52.auth, 'access', _53 => _53.onUnauthorized, 'optionalCall', _54 => _54()]);
+  if (!refreshed) {
+    console.warn("[ProviderProxy:chat] 401 not recoverable (onUnauthorized returned false)");
+    return first;
+  }
+  console.log("[ProviderProxy:chat] 401 \u2192 token refreshed; retrying once");
+  return runPipeline3(chatBody, plan);
+}
 
 // src/provider-proxy/usage/recordResponsesUsage.ts
 function readResponsesUsage(usage) {
@@ -1333,26 +1631,27 @@ function recordResponsesNonStreamUsage(recorder, bodyText, attribution) {
       sessionId: attribution.sessionId,
       providerId: attribution.providerId,
       model: attribution.model,
-      apiKeyId: null,
+      apiKeyId: attribution.apiKeyId,
+      auditResponse: attribution.auditResponse,
       engineOrigin: "codex-ingress",
       usage: tapped,
       rawUsage: parsed.usage
     });
-  } catch (e10) {
+  } catch (e15) {
   }
 }
 
 // src/provider-proxy/ingress/openaiResponsesIngress.ts
 function isOpenAIResponsesRequest(method, url) {
   if (method !== "POST" || !url) return false;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _48 => _48.split, 'call', _49 => _49("?"), 'access', _50 => _50[0], 'optionalAccess', _51 => _51.replace, 'call', _52 => _52(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _55 => _55.split, 'call', _56 => _56("?"), 'access', _57 => _57[0], 'optionalAccess', _58 => _58.replace, 'call', _59 => _59(/\/+$/, "")]), () => ( ""));
   return path.endsWith("/responses");
 }
 async function handleOpenAIResponsesRequest(res, rawBody, route, deps) {
   let responsesBody;
   try {
     responsesBody = JSON.parse(rawBody);
-  } catch (e11) {
+  } catch (e16) {
     writeError(res, 400, "Invalid JSON in request body");
     return;
   }
@@ -1360,15 +1659,18 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps) {
   const resolvedModel = route.model;
   responsesBody.model = resolvedModel;
   try {
-    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
     if (!plan) return;
-    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry2(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
-    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry3(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream, route.requestedModel);
     if (bodyText && deps.usageRecorder) {
       recordResponsesNonStreamUsage(deps.usageRecorder, bodyText, {
         sessionId: route.sessionId,
         providerId: _nullishCoalesce(route.providerId, () => ( "codex")),
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: _nullishCoalesce(route.apiKeyId, () => ( null)),
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1393,7 +1695,7 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     writeError(res, 502, "API key not configured");
     return null;
   }
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkLKZJEL6Ecjs.LlmConfigProviderAuth)({
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkQ27JY5RGcjs.LlmConfigProviderAuth)({
     provider,
     apiKey,
     apiKeyPool: _nullishCoalesce(deps.apiKeyPool, () => ( null)),
@@ -1415,21 +1717,22 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     resolvedModel,
     isStream,
     resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
-    upstreamUrl: byoUrl
+    upstreamUrl: byoUrl,
+    proxyProviderId: "byo"
   };
 }
-async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) {
+async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream) {
   const profile = route.subscriptionProfile;
   if (!profile) {
     writeError(res, 502, "Subscription mode requires a codex subscription profile");
     return null;
   }
-  const upstreamUrl = _optionalChain([profile, 'access', _53 => _53.resolveUpstreamUrl, 'optionalCall', _54 => _54(resolvedModel)]);
+  const upstreamUrl = _optionalChain([profile, 'access', _60 => _60.resolveUpstreamUrl, 'optionalCall', _61 => _61(resolvedModel)]);
   if (!upstreamUrl) {
     writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
     return null;
   }
-  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkN3V2J5ZOcjs.SubscriptionAuthSource)(profile)));
+  const auth = _nullishCoalesce(route.auth, () => ( new (0, _chunkY6OM7EV7cjs.SubscriptionAuthSource)(profile)));
   const chain = _chunkNYUNU75Acjs.resolveSubscriptionChain.call(void 0, 
     profile,
     deps.llmConfig.getTransformerService(),
@@ -1459,7 +1762,8 @@ async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream)
     // stream vs non-stream colon-method URL in `config.url`); fall back to the
     // 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
+    upstreamUrl,
+    proxyProviderId: profile.authStrategy.providerId
   };
 }
 async function resolveGeminiCodeAssistProject(profile) {
@@ -1476,8 +1780,15 @@ async function runPipeline4(responsesBody, plan) {
   const executor = getSharedExecutor();
   const endpointTransformer = getResponsesEndpointTransformer();
   const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  let proxyAccountId;
   const authHeaders = {};
-  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  await auth.applyHeaders(authHeaders, {
+    upstreamUrl,
+    model: resolvedModel,
+    reportSelection: (accountId) => {
+      proxyAccountId = accountId;
+    }
+  });
   let rawStatus = null;
   const { response } = await _chunkKUU2RNG6cjs.executeProviderCall.call(void 0, {
     executor,
@@ -1497,7 +1808,11 @@ async function runPipeline4(responsesBody, plan) {
     },
     fetchFn: (url, headers, body) => {
       console.log(`[ProviderProxy:responses] -> ${url} model=${resolvedModel} stream=${isStream}`);
-      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+      return _chunkS6JGLF3Gcjs.fetchUpstream.call(void 0, 
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1508,8 +1823,8 @@ async function runPipeline4(responsesBody, plan) {
 }
 async function runPipelineWithPoolReporting4(responsesBody, plan) {
   const first = await runPipeline4(responsesBody, plan);
-  const outcome = await _optionalChain([plan, 'access', _55 => _55.auth, 'access', _56 => _56.onResult, 'optionalCall', _57 => _57(first.rawStatus)]);
-  if (_optionalChain([outcome, 'optionalAccess', _58 => _58.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:responses] pool re-bound key after status",
       first.rawStatus,
@@ -1519,10 +1834,10 @@ async function runPipelineWithPoolReporting4(responsesBody, plan) {
   }
   return first;
 }
-async function runPipelineWithSubscriptionRetry2(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', _59 => _59.auth, 'access', _60 => _60.onUnauthorized, 'optionalCall', _61 => _61()]);
+  const refreshed = await _optionalChain([plan, 'access', _66 => _66.auth, 'access', _67 => _67.onUnauthorized, 'optionalCall', _68 => _68()]);
   if (!refreshed) {
     console.warn("[ProviderProxy:responses] 401 not recoverable (onUnauthorized returned false)");
     return first;
@@ -1544,7 +1859,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', _62 => _62.trim, 'call', _63 => _63()]) || void 0;
+  return _optionalChain([value, 'optionalAccess', _69 => _69.trim, 'call', _70 => _70()]) || void 0;
 }
 async function routeRequest(req, res, routes, deps) {
   const token = resolveRouteToken(req);
@@ -1696,12 +2011,644 @@ function __resetProviderProxyForTests() {
 // src/outbound-api/OutboundApiServer.ts
 
 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); }
+  /** key → the tail of the pending-op chain (resolves when the last op frees). */
+  __init4() {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
+   * after `fn` settles. Returns `fn`'s result (or rejection). Never lets one op's
+   * failure wedge the queue (waiters proceed regardless).
+   */
+  async runExclusive(key, fn) {
+    const prev = _nullishCoalesce(this.tails.get(key), () => ( Promise.resolve()));
+    let release2;
+    const gate = new Promise((resolve) => {
+      release2 = resolve;
+    });
+    const chain = prev.then(() => gate);
+    this.tails.set(key, chain);
+    await prev.catch(() => void 0);
+    try {
+      return await fn();
+    } finally {
+      release2();
+      if (this.tails.get(key) === chain) this.tails.delete(key);
+    }
+  }
+}, _class3);
 
 // src/outbound-api/outboundApiRouter.ts
 var _stream = require('stream');
 
+// src/pipeline/webhookEmit.ts
+var sink = null;
+function emitWebhookEvent(event) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(event);
+  } catch (e17) {
+  }
+}
+
+// src/outbound-api/apiServerConfig.ts
+var _audittypes = require('@omnicross/contracts/audit-types');
+var _billingtypes = require('@omnicross/contracts/billing-types');
+
+
+
+var _webhooktypes = require('@omnicross/contracts/webhook-types');
+var OUTBOUND_API_SERVER_CONFIG_KEY = "outboundApiServer.config";
+var DEFAULT_USER_MESSAGE_QUEUE = {
+  enabled: false,
+  delayMs: 200,
+  waitTimeoutMs: 6e4
+};
+var DEFAULT_CONCURRENCY_QUEUE = {
+  maxQueueSizeFactor: 2,
+  minQueueSize: 4,
+  waitTimeoutMs: 6e4
+};
+var DEFAULT_ACCOUNT_HEALTH = {
+  overloadCooldownEnabled: true,
+  overloadCooldownMs: 10 * 6e4
+};
+function normalizeAccountHealth(raw) {
+  const ah = _optionalChain([raw, 'optionalAccess', _71 => _71.accountHealth]);
+  return {
+    overloadCooldownEnabled: _optionalChain([ah, 'optionalAccess', _72 => _72.overloadCooldownEnabled]) !== false,
+    overloadCooldownMs: clampNumber(
+      _optionalChain([ah, 'optionalAccess', _73 => _73.overloadCooldownMs]),
+      6e4,
+      36e5,
+      DEFAULT_ACCOUNT_HEALTH.overloadCooldownMs
+    )
+  };
+}
+var DEFAULT_ACCOUNT_PROBE = {
+  enabled: false,
+  intervalMs: 15 * 6e4,
+  onlyMultiAccount: true,
+  timeoutMs: 5e3,
+  historySize: 10,
+  staggerMs: 500
+};
+function normalizeAccountProbe(raw) {
+  const ap = _optionalChain([raw, 'optionalAccess', _74 => _74.accountProbe]);
+  return {
+    enabled: _optionalChain([ap, 'optionalAccess', _75 => _75.enabled]) === true,
+    intervalMs: clampNumber(_optionalChain([ap, 'optionalAccess', _76 => _76.intervalMs]), 6e4, 864e5, DEFAULT_ACCOUNT_PROBE.intervalMs),
+    onlyMultiAccount: _optionalChain([ap, 'optionalAccess', _77 => _77.onlyMultiAccount]) !== false,
+    timeoutMs: clampNumber(_optionalChain([ap, 'optionalAccess', _78 => _78.timeoutMs]), 1e3, 6e4, DEFAULT_ACCOUNT_PROBE.timeoutMs),
+    historySize: Math.trunc(
+      clampNumber(_optionalChain([ap, 'optionalAccess', _79 => _79.historySize]), 1, 200, DEFAULT_ACCOUNT_PROBE.historySize)
+    ),
+    staggerMs: clampNumber(_optionalChain([ap, 'optionalAccess', _80 => _80.staggerMs]), 0, 6e4, DEFAULT_ACCOUNT_PROBE.staggerMs)
+  };
+}
+function normalizeAudit(raw) {
+  const a = _optionalChain([raw, 'optionalAccess', _81 => _81.audit]);
+  return {
+    enabled: _optionalChain([a, 'optionalAccess', _82 => _82.enabled]) === true,
+    captureBodies: _optionalChain([a, 'optionalAccess', _83 => _83.captureBodies]) === true,
+    maxBodyBytes: Math.trunc(
+      clampNumber(_optionalChain([a, 'optionalAccess', _84 => _84.maxBodyBytes]), 256, 1048576, _audittypes.DEFAULT_AUDIT_CONFIG.maxBodyBytes)
+    ),
+    retentionDays: Math.trunc(
+      clampNumber(_optionalChain([a, 'optionalAccess', _85 => _85.retentionDays]), 1, 365, _audittypes.DEFAULT_AUDIT_CONFIG.retentionDays)
+    ),
+    trustForwardedFor: _optionalChain([a, 'optionalAccess', _86 => _86.trustForwardedFor]) === true
+  };
+}
+function normalizeBilling(raw) {
+  const b = _optionalChain([raw, 'optionalAccess', _87 => _87.billing]);
+  const config = {
+    enabled: _optionalChain([b, 'optionalAccess', _88 => _88.enabled]) === true,
+    maxRetryAgeMs: Math.trunc(
+      clampNumber(_optionalChain([b, 'optionalAccess', _89 => _89.maxRetryAgeMs]), 6e4, 2592e6, _billingtypes.DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
+    )
+  };
+  if (typeof _optionalChain([b, 'optionalAccess', _90 => _90.endpoint]) === "string" && b.endpoint.trim()) config.endpoint = b.endpoint.trim();
+  if (typeof _optionalChain([b, 'optionalAccess', _91 => _91.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', _92 => _92.fingerprint]);
+  const out = { enabled: _optionalChain([f, 'optionalAccess', _93 => _93.enabled]) === true };
+  if (typeof _optionalChain([f, 'optionalAccess', _94 => _94.ua]) === "string" && f.ua.trim().length > 0) out.ua = f.ua.trim();
+  return out;
+}
+function normalizeVoucher(raw) {
+  return { enabled: _optionalChain([raw, 'optionalAccess', _95 => _95.voucher, 'optionalAccess', _96 => _96.enabled]) === true };
+}
+var PROXY_TYPES = ["http", "https", "socks5"];
+function normalizeProxyConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  if (typeof r["url"] === "string" && r["url"].trim().length > 0) {
+    return { url: r["url"].trim() };
+  }
+  const type = r["type"];
+  const host = r["host"];
+  const port = r["port"];
+  if (typeof type === "string" && PROXY_TYPES.includes(type) && typeof host === "string" && host.trim().length > 0 && typeof port === "number" && Number.isFinite(port) && port >= 1 && port <= 65535) {
+    const out = {
+      type,
+      host: host.trim(),
+      port: Math.trunc(port)
+    };
+    if (typeof r["username"] === "string" && r["username"].length > 0) out.username = r["username"];
+    if (typeof r["password"] === "string" && r["password"].length > 0) out.password = r["password"];
+    return out;
+  }
+  return void 0;
+}
+function normalizeProxySegment(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  const global = normalizeProxyConfig(r["global"]);
+  if (global) out.global = global;
+  if (r["byProvider"] && typeof r["byProvider"] === "object") {
+    const byProvider = {};
+    for (const [key, value] of Object.entries(r["byProvider"])) {
+      if (!key.trim()) continue;
+      const cfg = normalizeProxyConfig(value);
+      if (cfg) byProvider[key] = cfg;
+    }
+    if (Object.keys(byProvider).length > 0) out.byProvider = byProvider;
+  }
+  return out.global || out.byProvider ? out : void 0;
+}
+function normalizeWebhookDestination(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const id = typeof r["id"] === "string" ? r["id"].trim() : "";
+  const url = typeof r["url"] === "string" ? r["url"].trim() : "";
+  const type = r["type"];
+  if (!id || !url || typeof type !== "string" || !_webhooktypes.WEBHOOK_DESTINATION_TYPES.includes(type)) {
+    return void 0;
+  }
+  const out = {
+    id,
+    type,
+    url,
+    enabled: r["enabled"] !== false
+  };
+  if (typeof r["secret"] === "string" && r["secret"].length > 0) out.secret = r["secret"];
+  if (Array.isArray(r["events"])) {
+    const events = r["events"].filter(
+      (e) => typeof e === "string" && _webhooktypes.WEBHOOK_EVENT_KINDS.includes(e)
+    );
+    if (events.length > 0) out.events = events;
+  }
+  return out;
+}
+function normalizeWebhookSegment(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const destinations = [];
+  if (Array.isArray(r["destinations"])) {
+    for (const entry of r["destinations"]) {
+      const d = normalizeWebhookDestination(entry);
+      if (d) destinations.push(d);
+    }
+  }
+  const enabled = r["enabled"] === true;
+  if (!enabled && destinations.length === 0) return void 0;
+  return { enabled, destinations };
+}
+function clampNumber(value, min, max, fallback) {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function normalizeQueueSegments(raw) {
+  const umq = _optionalChain([raw, 'optionalAccess', _97 => _97.userMessageQueue]);
+  const cq = _optionalChain([raw, 'optionalAccess', _98 => _98.concurrencyQueue]);
+  return {
+    userMessageQueue: {
+      enabled: _optionalChain([umq, 'optionalAccess', _99 => _99.enabled]) === true,
+      delayMs: clampNumber(_optionalChain([umq, 'optionalAccess', _100 => _100.delayMs]), 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
+      waitTimeoutMs: clampNumber(
+        _optionalChain([umq, 'optionalAccess', _101 => _101.waitTimeoutMs]),
+        1e3,
+        3e5,
+        DEFAULT_USER_MESSAGE_QUEUE.waitTimeoutMs
+      )
+    },
+    concurrencyQueue: {
+      maxQueueSizeFactor: clampNumber(
+        _optionalChain([cq, 'optionalAccess', _102 => _102.maxQueueSizeFactor]),
+        1,
+        10,
+        DEFAULT_CONCURRENCY_QUEUE.maxQueueSizeFactor
+      ),
+      minQueueSize: clampNumber(_optionalChain([cq, 'optionalAccess', _103 => _103.minQueueSize]), 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
+      waitTimeoutMs: clampNumber(
+        _optionalChain([cq, 'optionalAccess', _104 => _104.waitTimeoutMs]),
+        1e3,
+        3e5,
+        DEFAULT_CONCURRENCY_QUEUE.waitTimeoutMs
+      )
+    }
+  };
+}
+var ALL_ENDPOINTS = ["chat", "responses", "messages", "gemini"];
+function blankModelMap(endpoint) {
+  const modelMap = {};
+  for (const kind of _chunkSVXC36MUcjs.modelKindsForEndpoint.call(void 0, endpoint)) modelMap[kind] = "";
+  return modelMap;
+}
+function defaultEndpointConfig(endpoint) {
+  if (_chunkSVXC36MUcjs.isKindMappedEndpoint.call(void 0, endpoint)) {
+    return { endpoint, modelMap: blankModelMap(endpoint), useSubscription: false };
+  }
+  if (endpoint === "chat") {
+    return { endpoint, models: [], useSubscription: false };
+  }
+  return {
+    endpoint,
+    defaultModel: "",
+    backgroundModel: "",
+    useSubscription: false
+  };
+}
+function normalizePrefixTargets(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  for (const key of ["claude", "gpt", "gemini"]) {
+    const v = r[key];
+    if (typeof v === "string" && v.trim() !== "") out[key] = v.trim();
+  }
+  return out.claude || out.gpt || out.gemini ? out : void 0;
+}
+function normalizeEndpointConfig(e) {
+  const endpoint = e.endpoint;
+  const useSubscription = e.useSubscription === true;
+  if (_chunkSVXC36MUcjs.isKindMappedEndpoint.call(void 0, endpoint)) {
+    const rawMap = e.modelMap && typeof e.modelMap === "object" ? e.modelMap : {};
+    const modelMap = {};
+    for (const kind of _chunkSVXC36MUcjs.modelKindsForEndpoint.call(void 0, endpoint)) {
+      const v = rawMap[kind];
+      modelMap[kind] = typeof v === "string" ? v : "";
+    }
+    return { endpoint, modelMap, useSubscription };
+  }
+  if (endpoint === "chat") {
+    const models = Array.isArray(e.models) ? e.models.filter((m) => typeof m === "string" && m.trim() !== "") : [];
+    const config2 = { endpoint, models, useSubscription };
+    if (e.dispatchMode === "prefix") {
+      config2.dispatchMode = "prefix";
+      const targets = normalizePrefixTargets(e.prefixTargets);
+      if (targets) config2.prefixTargets = targets;
+    }
+    return config2;
+  }
+  const config = {
+    endpoint,
+    defaultModel: typeof e.defaultModel === "string" ? e.defaultModel : "",
+    backgroundModel: typeof e.backgroundModel === "string" ? e.backgroundModel : "",
+    useSubscription
+  };
+  if (Array.isArray(e.backgroundModelIds)) {
+    config.backgroundModelIds = e.backgroundModelIds;
+  }
+  return config;
+}
+function defaultServerConfig() {
+  const queues = normalizeQueueSegments(void 0);
+  return {
+    enabled: false,
+    networkBinding: false,
+    endpoints: ALL_ENDPOINTS.map(defaultEndpointConfig),
+    port: DEFAULT_OUTBOUND_PORT,
+    userMessageQueue: queues.userMessageQueue,
+    concurrencyQueue: queues.concurrencyQueue,
+    accountHealth: normalizeAccountHealth(void 0),
+    accountProbe: normalizeAccountProbe(void 0),
+    audit: normalizeAudit(void 0),
+    billing: normalizeBilling(void 0),
+    fingerprint: normalizeFingerprint(void 0),
+    voucher: normalizeVoucher(void 0)
+  };
+}
+function normalizeServerConfig(raw) {
+  const base = defaultServerConfig();
+  if (!raw) return base;
+  const byEndpoint = /* @__PURE__ */ new Map();
+  for (const e of _nullishCoalesce(raw.endpoints, () => ( []))) {
+    if (e && ALL_ENDPOINTS.includes(e.endpoint)) {
+      byEndpoint.set(e.endpoint, normalizeEndpointConfig(e));
+    }
+  }
+  const queues = normalizeQueueSegments(raw);
+  const config = {
+    enabled: raw.enabled === true,
+    networkBinding: raw.networkBinding === true,
+    endpoints: ALL_ENDPOINTS.map(
+      (ep) => _nullishCoalesce(byEndpoint.get(ep), () => ( defaultEndpointConfig(ep)))
+    ),
+    port: _nullishCoalesce(raw.port, () => ( base.port)),
+    userMessageQueue: queues.userMessageQueue,
+    concurrencyQueue: queues.concurrencyQueue,
+    accountHealth: normalizeAccountHealth(raw),
+    accountProbe: normalizeAccountProbe(raw),
+    audit: normalizeAudit(raw),
+    billing: normalizeBilling(raw),
+    fingerprint: normalizeFingerprint(raw),
+    voucher: normalizeVoucher(raw)
+  };
+  const proxy = normalizeProxySegment(raw.proxy);
+  if (proxy) config.proxy = proxy;
+  const webhook = normalizeWebhookSegment(raw.webhook);
+  if (webhook) config.webhook = webhook;
+  return config;
+}
+async function loadServerConfig(store) {
+  const raw = await store.get(
+    OUTBOUND_API_SERVER_CONFIG_KEY
+  );
+  return normalizeServerConfig(raw);
+}
+async function saveServerConfig(store, config) {
+  await store.set(OUTBOUND_API_SERVER_CONFIG_KEY, config);
+}
+function mergeServerConfig(current, patch) {
+  return normalizeServerConfig({
+    enabled: _nullishCoalesce(patch.enabled, () => ( current.enabled)),
+    networkBinding: _nullishCoalesce(patch.networkBinding, () => ( current.networkBinding)),
+    endpoints: _nullishCoalesce(patch.endpoints, () => ( current.endpoints)),
+    port: _nullishCoalesce(patch.port, () => ( current.port)),
+    userMessageQueue: _nullishCoalesce(patch.userMessageQueue, () => ( current.userMessageQueue)),
+    concurrencyQueue: _nullishCoalesce(patch.concurrencyQueue, () => ( current.concurrencyQueue)),
+    accountHealth: _nullishCoalesce(patch.accountHealth, () => ( current.accountHealth)),
+    accountProbe: _nullishCoalesce(patch.accountProbe, () => ( current.accountProbe)),
+    audit: _nullishCoalesce(patch.audit, () => ( current.audit)),
+    billing: _nullishCoalesce(patch.billing, () => ( current.billing)),
+    // Proxy is layer-replaced (not deep-merged): a PUT carrying `proxy` swaps the
+    // whole segment; omitting it keeps the current one. `undefined` on both ⇒ absent.
+    proxy: _nullishCoalesce(patch.proxy, () => ( current.proxy)),
+    // Webhook is layer-replaced too (a PUT carrying `webhook` swaps the whole
+    // segment; omitting it keeps the current one). `undefined` on both ⇒ absent.
+    webhook: _nullishCoalesce(patch.webhook, () => ( current.webhook)),
+    // Fingerprint is always-filled (normalizeFingerprint synthesizes a default);
+    // a PUT carrying it replaces the segment, else the current one is kept.
+    fingerprint: _nullishCoalesce(patch.fingerprint, () => ( current.fingerprint)),
+    // Voucher is always-filled (normalizeVoucher synthesizes a default); a PUT
+    // carrying it replaces the segment, else the current one is kept.
+    voucher: _nullishCoalesce(patch.voucher, () => ( current.voucher))
+  });
+}
+
+// src/outbound-api/auditCapture.ts
+
+
+// src/outbound-api/auditRedact.ts
+var AUDIT_REDACTED = "***REDACTED***";
+var RULES = [
+  // `sk-…` family (Anthropic sk-ant-, omnicross sk-omnicross-, OpenAI sk-proj-/sk-).
+  { re: /\bsk-[A-Za-z0-9_-]{6,}/g, replace: AUDIT_REDACTED },
+  // Google API keys.
+  { re: /\bAIza[A-Za-z0-9_-]{10,}/g, replace: AUDIT_REDACTED },
+  // `Bearer <token>` (auth headers echoed into a body / SSE error).
+  { re: /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/gi, replace: `Bearer ${AUDIT_REDACTED}` },
+  // Inline `x-api-key` / `api-key` / `authorization` label followed by a value.
+  {
+    re: /\b(x-api-key|api[_-]?key|authorization)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  },
+  // `x-goog-api-key` header echoed inline.
+  {
+    re: /\b(x-goog-api-key)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  }
+];
+function redactAuditText(text) {
+  if (typeof text !== "string" || text.length === 0) return _nullishCoalesce(text, () => ( ""));
+  let out = text;
+  for (const { re, replace } of RULES) {
+    out = out.replace(re, replace);
+  }
+  return out;
+}
+
+// src/outbound-api/auditCapture.ts
+function isStreamingContentType(res) {
+  const ct = res.getHeader("content-type");
+  const value = Array.isArray(ct) ? ct.join(";") : String(_nullishCoalesce(ct, () => ( "")));
+  return value.toLowerCase().includes("text/event-stream");
+}
+function resolveClientIp(req, trustForwardedFor) {
+  if (trustForwardedFor) {
+    const xff = req.headers["x-forwarded-for"];
+    const raw = Array.isArray(xff) ? xff[0] : xff;
+    if (typeof raw === "string" && raw.trim()) {
+      const first = _optionalChain([raw, 'access', _105 => _105.split, 'call', _106 => _106(","), 'access', _107 => _107[0], 'optionalAccess', _108 => _108.trim, 'call', _109 => _109()]);
+      if (first) return first;
+    }
+  }
+  return _nullishCoalesce(_optionalChain([req, 'access', _110 => _110.socket, 'optionalAccess', _111 => _111.remoteAddress]), () => ( void 0));
+}
+function truncateToBytes(text, maxBytes) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  return buf.subarray(0, maxBytes).toString("utf8");
+}
+function beginAuditCapture(req, res, now) {
+  const config = _chunkAEOZIDEBcjs.getAuditCaptureConfig.call(void 0, );
+  if (!config) return null;
+  let rawRequestBody;
+  const responseChunks = [];
+  let responseBytes = 0;
+  let streamDetected = false;
+  let finished = false;
+  const ctx = {
+    setRequestBody(raw) {
+      if (config.captureBodies) rawRequestBody = raw;
+    }
+  };
+  if (config.captureBodies) {
+    installResponseCapture(res, config.maxBodyBytes, {
+      push(chunk) {
+        responseBytes += chunk.length;
+        responseChunks.push(chunk);
+      },
+      get bytes() {
+        return responseBytes;
+      },
+      markStream() {
+        streamDetected = true;
+      },
+      get isStream() {
+        return streamDetected;
+      }
+    });
+  }
+  const finalize = () => {
+    if (finished) return;
+    finished = true;
+    try {
+      const record = {
+        id: _crypto.randomUUID.call(void 0, ),
+        ts: now,
+        method: _nullishCoalesce(req.method, () => ( "")),
+        path: _nullishCoalesce((_nullishCoalesce(req.url, () => ( ""))).split("?")[0], () => ( "")),
+        status: res.statusCode,
+        latencyMs: Math.max(0, Date.now() - now)
+      };
+      if (ctx.keyId != null) record.keyId = ctx.keyId;
+      const ip = resolveClientIp(req, config.trustForwardedFor);
+      if (ip) record.ip = ip;
+      const ua = req.headers["user-agent"];
+      if (typeof ua === "string" && ua) record.ua = ua;
+      if (ctx.model) record.model = ctx.model;
+      if (ctx.provider) record.provider = ctx.provider;
+      const usage = _chunk3QOSDDNIcjs.readAuditUsage.call(void 0, res);
+      if (usage) {
+        if (typeof usage.inputTokens === "number") record.inputTokens = usage.inputTokens;
+        if (typeof usage.outputTokens === "number") record.outputTokens = usage.outputTokens;
+        if (typeof usage.costUsd === "number") record.costUsd = usage.costUsd;
+        if (!record.model && usage.model) record.model = usage.model;
+        if (!record.provider && usage.provider) record.provider = usage.provider;
+      }
+      if (ctx.error) record.error = redactAuditText(ctx.error);
+      if (config.captureBodies) {
+        if (rawRequestBody != null && rawRequestBody.length > 0) {
+          record.requestBody = redactAuditText(truncateToBytes(rawRequestBody, config.maxBodyBytes));
+        }
+        if (!streamDetected && responseChunks.length > 0) {
+          const body = Buffer.concat(responseChunks).toString("utf8");
+          record.responseBody = redactAuditText(body);
+        }
+      }
+      _chunkAEOZIDEBcjs.recordAudit.call(void 0, record);
+    } catch (e18) {
+    }
+  };
+  res.once("close", finalize);
+  return ctx;
+}
+function installResponseCapture(res, maxBodyBytes, sink2) {
+  let contentTypeChecked = false;
+  const capture = (chunk) => {
+    if (sink2.isStream) return;
+    if (!contentTypeChecked) {
+      contentTypeChecked = true;
+      if (isStreamingContentType(res)) {
+        sink2.markStream();
+        return;
+      }
+    }
+    if (sink2.bytes >= maxBodyBytes) return;
+    let buf = null;
+    if (Buffer.isBuffer(chunk)) buf = chunk;
+    else if (typeof chunk === "string") buf = Buffer.from(chunk, "utf8");
+    if (!buf || buf.length === 0) return;
+    const remaining = maxBodyBytes - sink2.bytes;
+    sink2.push(buf.length > remaining ? buf.subarray(0, remaining) : buf);
+  };
+  const originalWrite = res.write.bind(res);
+  const originalEnd = res.end.bind(res);
+  res.write = ((chunk, ...args) => {
+    if (chunk != null) capture(chunk);
+    return originalWrite(chunk, ...args);
+  });
+  res.end = ((chunk, ...args) => {
+    if (chunk != null && typeof chunk !== "function") capture(chunk);
+    return originalEnd(chunk, ...args);
+  });
+}
+
+// src/outbound-api/billingCapture.ts
+
+var defaultDefer = (fn) => {
+  setTimeout(fn, 0);
+};
+function beginBillingCapture(_req, res, now, defer = defaultDefer) {
+  if (!_chunkL74VDN4Acjs.getBillingCaptureConfig.call(void 0, )) return null;
+  const ctx = {};
+  let finished = false;
+  const finalize = () => {
+    if (finished) return;
+    finished = true;
+    const status = res.statusCode;
+    defer(() => {
+      try {
+        const usage = _chunk3QOSDDNIcjs.readAuditUsage.call(void 0, res);
+        if (!usage) return;
+        const event = {
+          id: _crypto.randomUUID.call(void 0, ),
+          ts: now,
+          model: _nullishCoalesce(_nullishCoalesce(ctx.model, () => ( usage.model)), () => ( "")),
+          authMode: _nullishCoalesce(ctx.authMode, () => ( "byo")),
+          inputTokens: _nullishCoalesce(usage.inputTokens, () => ( 0)),
+          outputTokens: _nullishCoalesce(usage.outputTokens, () => ( 0)),
+          costUsd: _nullishCoalesce(usage.costUsd, () => ( 0)),
+          status
+        };
+        if (ctx.keyId != null) event.keyId = ctx.keyId;
+        const provider = _nullishCoalesce(ctx.provider, () => ( usage.provider));
+        if (provider) event.provider = provider;
+        _chunkL74VDN4Acjs.publishBillingEvent.call(void 0, event);
+      } catch (e19) {
+      }
+    });
+  };
+  res.once("close", finalize);
+  return ctx;
+}
+
 // src/outbound-api/outboundApiKeyAuth.ts
 
+
+// src/outbound-api/keyPolicy.ts
+var DAY_MS = 864e5;
+function computeKeyExpiry(row, now) {
+  const mode = _nullishCoalesce(row.activationMode, () => ( "fixed"));
+  if (mode === "activation") {
+    if (row.activatedAt == null) return { expired: false, needsActivation: true };
+    if (row.activationDays == null) return { expired: false };
+    const effectiveExpiresAt = row.activatedAt + row.activationDays * DAY_MS;
+    return { expired: now >= effectiveExpiresAt, effectiveExpiresAt };
+  }
+  if (row.expiresAt == null) return { expired: false };
+  return { expired: now >= row.expiresAt, effectiveExpiresAt: row.expiresAt };
+}
+function checkKeyQuota(limits, spend) {
+  if (!limits) return { allowed: true };
+  if (limits.dailyUsd != null && spend.dailyUsd >= limits.dailyUsd) {
+    return { allowed: false, scope: "daily", limitUsd: limits.dailyUsd, spentUsd: spend.dailyUsd };
+  }
+  if (limits.weeklyUsd != null && spend.weeklyUsd >= limits.weeklyUsd) {
+    return { allowed: false, scope: "weekly", limitUsd: limits.weeklyUsd, spentUsd: spend.weeklyUsd };
+  }
+  if (limits.totalUsd != null && spend.totalUsd >= limits.totalUsd) {
+    return { allowed: false, scope: "total", limitUsd: limits.totalUsd, spentUsd: spend.totalUsd };
+  }
+  return { allowed: true };
+}
+function canonicalModelId(value) {
+  const idx = value.indexOf(",");
+  const bare = idx >= 0 ? value.slice(idx + 1) : value;
+  return bare.trim().toLowerCase();
+}
+function checkModelAllowed(restriction, resolvedModelId) {
+  if (!restriction) return { allowed: true };
+  const target = canonicalModelId(resolvedModelId);
+  const listed = restriction.models.some((m) => canonicalModelId(m) === target);
+  if (restriction.mode === "allowlist") {
+    return listed ? { allowed: true } : { allowed: false, model: resolvedModelId };
+  }
+  return listed ? { allowed: false, model: resolvedModelId } : { allowed: true };
+}
+
+// src/outbound-api/outboundApiKeyAuth.ts
 var SECRET_BYTES = 32;
 var PREFIX_LEN = 14;
 var KEY_PREFIX = "sk-omnicross-";
@@ -1749,143 +2696,730 @@ async function createNamedKey(db, name) {
     plaintextOnce: secret
   };
 }
-async function verifyPresentedKey(db, presentedKey) {
-  if (!presentedKey) return null;
+function extractCostLimits(row) {
+  const limits = {};
+  if (row.dailyCostLimitUsd != null) limits.dailyUsd = row.dailyCostLimitUsd;
+  if (row.totalCostLimitUsd != null) limits.totalUsd = row.totalCostLimitUsd;
+  if (row.weeklyCostLimitUsd != null) limits.weeklyUsd = row.weeklyCostLimitUsd;
+  return limits.dailyUsd != null || limits.totalUsd != null || limits.weeklyUsd != null ? limits : void 0;
+}
+function extractRateLimit(row) {
+  if (row.rateLimitMaxRequests == null && row.rateLimitWindowMs == null) return void 0;
+  const override = {};
+  if (row.rateLimitMaxRequests != null) override.maxRequests = row.rateLimitMaxRequests;
+  if (row.rateLimitWindowMs != null) override.windowMs = row.rateLimitWindowMs;
+  return override;
+}
+function extractModelRestriction(row) {
+  if (row.enableModelRestriction !== true) return void 0;
+  return {
+    mode: _nullishCoalesce(row.restrictionMode, () => ( "blacklist")),
+    models: _nullishCoalesce(row.restrictedModels, () => ( []))
+  };
+}
+function toVerifiedKey(row) {
+  const key = { id: row.id };
+  if (row.maxConcurrency !== void 0 && row.maxConcurrency !== null) {
+    key.maxConcurrency = row.maxConcurrency;
+  }
+  const costLimits = extractCostLimits(row);
+  if (costLimits) key.costLimits = costLimits;
+  const rateLimit = extractRateLimit(row);
+  if (rateLimit) key.rateLimit = rateLimit;
+  const modelRestriction = extractModelRestriction(row);
+  if (modelRestriction) key.modelRestriction = modelRestriction;
+  return key;
+}
+async function verifyKey(db, presentedKey, now = Date.now()) {
+  if (!presentedKey) return { status: "invalid" };
   const trimmed = presentedKey.trim();
-  if (!trimmed) return null;
+  if (!trimmed) return { status: "invalid" };
   const row = await db.outboundApiKeysGetByHash(hashKey(trimmed));
-  if (!row) return null;
-  if (!row.enabled || row.revokedAt !== null) return null;
+  if (!row) return { status: "invalid" };
+  if (!row.enabled || row.revokedAt !== null) return { status: "invalid" };
+  const expiry = computeKeyExpiry(row, now);
+  if (expiry.expired) return { status: "expired" };
   void db.outboundApiKeysTouchLastUsed(row.id).catch(() => {
   });
-  return { id: row.id };
-}
-
-// src/outbound-api/roleDetection.ts
-var _canonicalmodels = require('@omnicross/contracts/canonical-models');
-var BACKGROUND_TIER_TOKENS = /* @__PURE__ */ new Set([
-  "haiku",
-  "mini",
-  "flash",
-  "small",
-  "lite",
-  "nano",
-  "8b"
-]);
-function modelTokens(normalizedId) {
-  return normalizedId.split(/[-._:/\s]+/).filter(Boolean);
-}
-function isBackgroundTierModel(rawModelId) {
-  if (!rawModelId) return false;
-  const tokens = modelTokens(_canonicalmodels.normalizeModelId.call(void 0, rawModelId));
-  return tokens.some((tok) => BACKGROUND_TIER_TOKENS.has(tok));
-}
-function extractRequestedModel(ingressFormat, body) {
-  const model = body["model"];
-  return typeof model === "string" && model ? model : void 0;
-}
-function anthropicHasVision(body) {
-  const messages = body["messages"];
-  if (!Array.isArray(messages)) return false;
-  for (const msg of messages) {
-    const content = _optionalChain([msg, 'optionalAccess', _64 => _64.content]);
-    if (!Array.isArray(content)) continue;
-    for (const part of content) {
-      if (_optionalChain([part, 'optionalAccess', _65 => _65.type]) === "image") return true;
-    }
+  if (expiry.needsActivation) {
+    void db.outboundApiKeysMarkActivated(row.id, now).catch(() => {
+    });
   }
-  return false;
+  return { status: "ok", key: toVerifiedKey(row) };
+}
+async function verifyPresentedKey(db, presentedKey) {
+  const result = await verifyKey(db, presentedKey);
+  return result.status === "ok" ? result.key : null;
+}
+
+// src/outbound-api/quotaWarn.ts
+var WEBHOOK_QUOTA_WARN_RATIO = 0.8;
+function computeQuotaWarnings(limits, spend, ratio = WEBHOOK_QUOTA_WARN_RATIO) {
+  const out = [];
+  const consider = (scope, limit, spent, windowStart) => {
+    if (limit == null || limit <= 0) return;
+    if (spent >= limit) return;
+    if (spent >= ratio * limit) out.push({ scope, limitUsd: limit, spentUsd: spent, windowStart });
+  };
+  consider("daily", limits.dailyUsd, spend.dailyUsd, spend.dailyWindowStart);
+  consider("weekly", limits.weeklyUsd, spend.weeklyUsd, spend.weeklyWindowStart);
+  consider("total", limits.totalUsd, spend.totalUsd, 0);
+  return out;
+}
+var WARN_GUARD_MAX = 1e4;
+var warned = /* @__PURE__ */ new Set();
+function markQuotaWarnedOnce(keyId, scope, windowStart) {
+  const key = `${keyId}\0${scope}\0${windowStart}`;
+  if (warned.has(key)) return false;
+  if (warned.size >= WARN_GUARD_MAX) warned.clear();
+  warned.add(key);
+  return true;
 }
-function openaiChatHasVision(body) {
-  const messages = body["messages"];
-  if (!Array.isArray(messages)) return false;
-  for (const msg of messages) {
-    const content = _optionalChain([msg, 'optionalAccess', _66 => _66.content]);
-    if (!Array.isArray(content)) continue;
-    for (const part of content) {
-      if (_optionalChain([part, 'optionalAccess', _67 => _67.type]) === "image_url") return true;
+
+// src/outbound-api/outboundConcurrencyGate.ts
+var ConcurrencyQueueFullError = (_class4 = class extends Error {
+  constructor(apiKeyId, maxQueueSize) {
+    super(`concurrency queue full (max ${maxQueueSize}) for key '${apiKeyId}'`);_class4.prototype.__init5.call(this);;
+    this.apiKeyId = apiKeyId;
+    this.maxQueueSize = maxQueueSize;
+    this.name = "ConcurrencyQueueFullError";
+  }
+  
+  
+  __init5() {this.code = "concurrency_queue_full"}
+}, _class4);
+var ConcurrencyWaitTimeoutError = (_class5 = class extends Error {
+  constructor(apiKeyId, waitTimeoutMs) {
+    super(`concurrency wait timed out after ${waitTimeoutMs}ms for key '${apiKeyId}'`);_class5.prototype.__init6.call(this);;
+    this.apiKeyId = apiKeyId;
+    this.waitTimeoutMs = waitTimeoutMs;
+    this.name = "ConcurrencyWaitTimeoutError";
+  }
+  
+  
+  __init6() {this.code = "concurrency_wait_timeout"}
+}, _class5);
+var ConcurrencyWaitCancelledError = (_class6 = class extends Error {
+  constructor(apiKeyId) {
+    super(`concurrency wait cancelled for key '${apiKeyId}'`);_class6.prototype.__init7.call(this);;
+    this.apiKeyId = apiKeyId;
+    this.name = "ConcurrencyWaitCancelledError";
+  }
+  
+  __init7() {this.code = "concurrency_wait_cancelled"}
+}, _class6);
+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()}
+  ensure(apiKeyId) {
+    let state = this.states.get(apiKeyId);
+    if (!state) {
+      state = { active: 0, waiters: [] };
+      this.states.set(apiKeyId, state);
     }
+    return state;
   }
-  return false;
-}
-function openaiResponsesHasVision(body) {
-  const input = body["input"];
-  if (!Array.isArray(input)) return false;
-  for (const item of input) {
-    const content = _optionalChain([item, 'optionalAccess', _68 => _68.content]);
-    if (Array.isArray(content)) {
-      for (const part of content) {
-        if (_optionalChain([part, 'optionalAccess', _69 => _69.type]) === "input_image") return true;
+  /** Delete a key's state once it is fully idle (no active, no waiters). */
+  gc(apiKeyId) {
+    const state = this.states.get(apiKeyId);
+    if (state && state.active === 0 && state.waiters.length === 0) {
+      this.states.delete(apiKeyId);
+    }
+  }
+  /**
+   * Acquire a concurrency slot for `apiKeyId` under `limit`. Grants immediately
+   * when `active < limit`; else enqueues FIFO while under the per-key queue cap;
+   * else rejects queue-full. `limit <= 0` = unlimited (always granted).
+   */
+  acquire(apiKeyId, limit, options) {
+    const state = this.ensure(apiKeyId);
+    const cap = limit > 0 ? limit : Infinity;
+    if (state.active < cap) {
+      state.active += 1;
+      const slot = this.makeSlot(apiKeyId);
+      return { granted: Promise.resolve(slot), cancel: slot.cancel };
+    }
+    const maxQueueSize = Math.max(
+      Number.isFinite(cap) ? cap * options.maxQueueSizeFactor : Infinity,
+      options.minQueueSize
+    );
+    if (state.waiters.length >= maxQueueSize) {
+      const err = new ConcurrencyQueueFullError(apiKeyId, maxQueueSize);
+      return { granted: Promise.reject(err), cancel: () => {
+      } };
+    }
+    let settled = false;
+    let granted = false;
+    let resolveGrant;
+    let rejectGrant;
+    const grantedPromise = new Promise((resolve, reject) => {
+      resolveGrant = resolve;
+      rejectGrant = reject;
+    });
+    const waiter = {
+      cap,
+      settled: false,
+      timeoutHandle: null,
+      grant: () => {
+        if (settled) return;
+        settled = true;
+        granted = true;
+        waiter.settled = true;
+        if (waiter.timeoutHandle) clearTimeout(waiter.timeoutHandle);
+        state.active += 1;
+        resolveGrant(this.makeSlot(apiKeyId));
+      },
+      fail: (err) => {
+        if (settled) return;
+        settled = true;
+        waiter.settled = true;
+        if (waiter.timeoutHandle) clearTimeout(waiter.timeoutHandle);
+        const idx = state.waiters.indexOf(waiter);
+        if (idx >= 0) state.waiters.splice(idx, 1);
+        rejectGrant(err);
+        this.gc(apiKeyId);
+      }
+    };
+    waiter.timeoutHandle = setTimeout(() => {
+      waiter.fail(new ConcurrencyWaitTimeoutError(apiKeyId, options.waitTimeoutMs));
+    }, options.waitTimeoutMs);
+    state.waiters.push(waiter);
+    const cancel = () => {
+      if (settled || granted) return;
+      waiter.fail(new ConcurrencyWaitCancelledError(apiKeyId));
+    };
+    return { granted: grantedPromise, cancel };
+  }
+  /** Build an idempotent granted slot (`release` decrements; `cancel` is a no-op). */
+  makeSlot(apiKeyId) {
+    let released = false;
+    const release2 = () => {
+      if (released) return;
+      released = true;
+      const state = this.states.get(apiKeyId);
+      if (!state) return;
+      state.active = Math.max(0, state.active - 1);
+      this.dispatchNext(apiKeyId);
+      this.gc(apiKeyId);
+    };
+    return { release: release2, cancel: () => {
+    } };
+  }
+  /** After a release freed a slot, grant the FIFO head if it fits under its cap. */
+  dispatchNext(apiKeyId) {
+    const state = this.states.get(apiKeyId);
+    if (!state || state.waiters.length === 0) return;
+    const head = state.waiters[0];
+    if (state.active < head.cap) {
+      state.waiters.shift();
+      head.grant();
+    }
+  }
+  /** Snapshot for observability — only keys with active slots or waiters. */
+  getStatus() {
+    const out = [];
+    for (const [apiKeyId, state] of this.states) {
+      if (state.active > 0 || state.waiters.length > 0) {
+        out.push({ apiKeyId, active: state.active, waiting: state.waiters.length });
+      }
+    }
+    return out;
+  }
+  /** Drop all state + pending timers (tests / teardown). */
+  reset() {
+    for (const state of this.states.values()) {
+      for (const w of state.waiters) {
+        if (w.timeoutHandle) clearTimeout(w.timeoutHandle);
+      }
+    }
+    this.states.clear();
+  }
+}, _class7);
+
+// src/outbound-api/outboundRateLimiter.ts
+var DEFAULT_WINDOW_MS = 6e4;
+var DEFAULT_MAX_REQUESTS = 60;
+var OutboundRateLimiter = (_class8 = class {
+  
+  
+  /** apiKeyId → ascending request timestamps within the current window. */
+  __init9() {this.hits = /* @__PURE__ */ new Map()}
+  constructor(options = {}) {;_class8.prototype.__init9.call(this);
+    this.windowMs = _nullishCoalesce(options.windowMs, () => ( DEFAULT_WINDOW_MS));
+    this.maxRequests = _nullishCoalesce(options.maxRequests, () => ( DEFAULT_MAX_REQUESTS));
+  }
+  /**
+   * Record a request for `apiKeyId` and decide whether it is allowed. Prunes
+   * timestamps older than the window first; when allowed, the request's
+   * timestamp is appended.
+   *
+   * `override` (outbound-key-policy) supplies a PER-KEY window/max for this
+   * bucket, superseding the instance defaults for THAT key. Absent ⇒ the
+   * instance default 60/60s (byte-identical to before this change). An effective
+   * `maxRequests` of `0` means UNLIMITED — the request is allowed and NOT
+   * recorded (no bucket growth).
+   */
+  check(apiKeyId, now = Date.now(), override) {
+    const maxRequests = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _112 => _112.maxRequests]), () => ( this.maxRequests));
+    const windowMs = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _113 => _113.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);
+    if (timestamps.length >= maxRequests) {
+      if (timestamps.length === 0) {
+        this.hits.delete(apiKeyId);
+        return { allowed: false, retryAfterSeconds: Math.max(1, Math.ceil(windowMs / 1e3)) };
       }
+      const oldest = timestamps[0];
+      const retryAfterMs = Math.max(0, oldest + windowMs - now);
+      this.hits.set(apiKeyId, timestamps);
+      return {
+        allowed: false,
+        retryAfterSeconds: Math.max(1, Math.ceil(retryAfterMs / 1e3))
+      };
     }
-    if (_optionalChain([item, 'optionalAccess', _70 => _70.type]) === "input_image") return true;
+    timestamps.push(now);
+    this.hits.set(apiKeyId, timestamps);
+    return { allowed: true, retryAfterSeconds: 0 };
+  }
+  /** Drop all recorded state (tests / teardown). */
+  reset() {
+    this.hits.clear();
+  }
+}, _class8);
+
+// src/outbound-api/userMessageDetection.ts
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+function asObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function last(arr) {
+  return arr.length > 0 ? arr[arr.length - 1] : void 0;
+}
+function isUserMessageAnthropic(body) {
+  const messages = asArray(body["messages"]);
+  const lastMsg = asObject(last(messages));
+  if (!lastMsg || lastMsg["role"] !== "user") return false;
+  const content = lastMsg["content"];
+  if (typeof content === "string") return true;
+  if (Array.isArray(content)) {
+    const hasToolResult = content.some(
+      (block) => _optionalChain([asObject, 'call', _114 => _114(block), 'optionalAccess', _115 => _115["type"]]) === "tool_result"
+    );
+    return !hasToolResult;
   }
   return false;
 }
-function geminiHasVision(body) {
-  const contents = body["contents"];
-  if (!Array.isArray(contents)) return false;
-  for (const content of contents) {
-    const parts = _optionalChain([content, 'optionalAccess', _71 => _71.parts]);
-    if (!Array.isArray(parts)) continue;
-    for (const part of parts) {
-      const p = part;
-      if (_optionalChain([p, 'optionalAccess', _72 => _72.inline_data]) || _optionalChain([p, 'optionalAccess', _73 => _73.inlineData]) || _optionalChain([p, 'optionalAccess', _74 => _74.file_data]) || _optionalChain([p, 'optionalAccess', _75 => _75.fileData])) return true;
-    }
+function isUserMessageResponses(body) {
+  const input = body["input"];
+  if (typeof input === "string") return input.length > 0;
+  if (Array.isArray(input)) {
+    const lastItem = asObject(last(input));
+    if (!lastItem) return false;
+    if (lastItem["type"] === "function_call_output") return false;
+    return lastItem["role"] === "user";
   }
   return false;
 }
-function hasVisionContent(ingressFormat, body) {
-  switch (ingressFormat) {
-    case "anthropic-messages":
-      return anthropicHasVision(body);
-    case "openai-chat":
-      return openaiChatHasVision(body);
-    case "openai-responses":
-      return openaiResponsesHasVision(body);
-    case "gemini-generatecontent":
-      return geminiHasVision(body);
+function isUserMessageChat(body) {
+  const messages = asArray(body["messages"]);
+  const lastMsg = asObject(last(messages));
+  if (!lastMsg) return false;
+  return lastMsg["role"] === "user";
+}
+function isUserMessageGemini(body) {
+  const contents = asArray(body["contents"]);
+  const lastContent = asObject(last(contents));
+  if (!lastContent || lastContent["role"] !== "user") return false;
+  const parts = asArray(lastContent["parts"]);
+  const hasFunctionResponse = parts.some(
+    (part) => _optionalChain([asObject, 'call', _116 => _116(part), 'optionalAccess', _117 => _117["functionResponse"]]) !== void 0
+  );
+  return !hasFunctionResponse;
+}
+function isUserMessageRequest(endpoint, parsedBody) {
+  const body = asObject(parsedBody);
+  if (!body) return false;
+  switch (endpoint) {
+    case "messages":
+      return isUserMessageAnthropic(body);
+    case "responses":
+      return isUserMessageResponses(body);
+    case "chat":
+      return isUserMessageChat(body);
+    case "gemini":
+      return isUserMessageGemini(body);
     default:
       return false;
   }
 }
-function detectRequestRole(ingressFormat, body, options) {
-  if (hasVisionContent(ingressFormat, body)) return "vision";
-  const requestedModel = extractRequestedModel(ingressFormat, body);
-  if (requestedModel) {
-    const overrides = _optionalChain([options, 'optionalAccess', _76 => _76.backgroundModelIds]);
-    if (overrides && overrides.length > 0) {
-      const reqNorm = _canonicalmodels.normalizeModelId.call(void 0, requestedModel);
-      const inOverride = overrides.some((id) => {
-        if (!id) return false;
-        const candidate = id.includes(",") ? id.slice(id.indexOf(",") + 1) : id;
-        return _canonicalmodels.normalizeModelId.call(void 0, candidate) === reqNorm || candidate === requestedModel;
-      });
-      if (inOverride) return "background";
+
+// src/outbound-api/userMessageSerialQueue.ts
+var SerialQueueTimeoutError = (_class9 = class extends Error {
+  constructor(providerId, waitTimeoutMs) {
+    super(`user-message serial queue wait timed out after ${waitTimeoutMs}ms for '${providerId}'`);_class9.prototype.__init10.call(this);;
+    this.providerId = providerId;
+    this.waitTimeoutMs = waitTimeoutMs;
+    this.name = "SerialQueueTimeoutError";
+  }
+  
+  
+  __init10() {this.code = "serial_queue_timeout"}
+}, _class9);
+function isSerialQueueTimeout(err) {
+  return err instanceof SerialQueueTimeoutError;
+}
+var UserMessageSerialQueue = (_class10 = class {constructor() { _class10.prototype.__init11.call(this); }
+  __init11() {this.states = /* @__PURE__ */ new Map()}
+  ensure(providerId) {
+    let state = this.states.get(providerId);
+    if (!state) {
+      state = { holding: false, lastReleaseTs: null, waiters: [], dispatchHandle: null };
+      this.states.set(providerId, state);
+    }
+    return state;
+  }
+  /**
+   * Acquire the serial slot for `providerId`. Resolves immediately when the slot
+   * is free, no one is queued, and the `delayMs` gap since the last release has
+   * elapsed; otherwise enqueues FIFO and resolves in order (or rejects with a
+   * {@link SerialQueueTimeoutError} after `waitTimeoutMs`).
+   */
+  acquire(providerId, options) {
+    const { waitTimeoutMs, delayMs } = options;
+    const now = _nullishCoalesce(options.now, () => ( Date.now()));
+    const state = this.ensure(providerId);
+    const spacingElapsed = state.lastReleaseTs === null || now - state.lastReleaseTs >= delayMs;
+    if (!state.holding && state.waiters.length === 0 && spacingElapsed) {
+      state.holding = true;
+      return Promise.resolve(this.makeSlot(providerId));
     }
-    if (isBackgroundTierModel(requestedModel)) return "background";
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        delayMs,
+        resolve,
+        reject,
+        timeoutHandle: null,
+        done: false
+      };
+      waiter.timeoutHandle = setTimeout(() => {
+        if (waiter.done) return;
+        waiter.done = true;
+        const idx = state.waiters.indexOf(waiter);
+        if (idx >= 0) state.waiters.splice(idx, 1);
+        reject(new SerialQueueTimeoutError(providerId, waitTimeoutMs));
+      }, waitTimeoutMs);
+      state.waiters.push(waiter);
+      this.maybeDispatch(providerId);
+    });
+  }
+  /** Build an idempotent release for a granted slot. */
+  makeSlot(providerId) {
+    let released = false;
+    return {
+      release: () => {
+        if (released) return;
+        released = true;
+        const state = this.states.get(providerId);
+        if (!state) return;
+        state.holding = false;
+        state.lastReleaseTs = Date.now();
+        this.maybeDispatch(providerId);
+      }
+    };
+  }
+  /**
+   * Grant the head waiter when the slot is free and the head's `delayMs` gap has
+   * elapsed; otherwise schedule a dispatch for the residual gap. No-op while the
+   * slot is held (release re-invokes this) or the queue is empty.
+   */
+  maybeDispatch(providerId) {
+    const state = this.states.get(providerId);
+    if (!state || state.holding || state.waiters.length === 0) return;
+    const head = state.waiters[0];
+    const now = Date.now();
+    const elapsed = state.lastReleaseTs === null ? Infinity : now - state.lastReleaseTs;
+    const residual = Math.max(0, head.delayMs - elapsed);
+    if (residual <= 0) {
+      this.grantHead(providerId);
+      return;
+    }
+    if (state.dispatchHandle !== null) return;
+    state.dispatchHandle = setTimeout(() => {
+      state.dispatchHandle = null;
+      this.grantHead(providerId);
+    }, residual);
+  }
+  /** Hand the slot to the FIFO head (if free and someone is waiting). */
+  grantHead(providerId) {
+    const state = this.states.get(providerId);
+    if (!state || state.holding || state.waiters.length === 0) return;
+    if (state.dispatchHandle !== null) {
+      clearTimeout(state.dispatchHandle);
+      state.dispatchHandle = null;
+    }
+    const head = state.waiters.shift();
+    if (!head) return;
+    if (head.timeoutHandle) clearTimeout(head.timeoutHandle);
+    head.done = true;
+    state.holding = true;
+    head.resolve(this.makeSlot(providerId));
+  }
+  /** Snapshot for observability — only keys holding a slot or with waiters. */
+  getStatus() {
+    const out = [];
+    for (const [providerId, state] of this.states) {
+      if (state.holding || state.waiters.length > 0) {
+        out.push({ providerId, holding: state.holding, waiting: state.waiters.length });
+      }
+    }
+    return out;
+  }
+  /** Drop all state + pending timers (tests / teardown). */
+  reset() {
+    for (const state of this.states.values()) {
+      if (state.dispatchHandle) clearTimeout(state.dispatchHandle);
+      for (const w of state.waiters) {
+        if (w.timeoutHandle) clearTimeout(w.timeoutHandle);
+      }
+    }
+    this.states.clear();
+  }
+}, _class10);
+
+// src/outbound-api/voucher.ts
+
+var CODE_ENTROPY_CHARS = 32;
+var CODE_PREFIX = "CC_";
+var DISPLAY_PREFIX_LEN = 8;
+var DAY_MS2 = 864e5;
+function generateVoucherCode() {
+  return CODE_PREFIX + randomBase62(CODE_ENTROPY_CHARS);
+}
+function hashVoucherCode(code) {
+  return _crypto.createHash.call(void 0, "sha256").update(code, "utf8").digest("hex");
+}
+function voucherCodePrefix(code) {
+  return code.slice(0, DISPLAY_PREFIX_LEN);
+}
+function newVoucherId() {
+  return `vch_${Date.now()}_${randomBase62(8)}`;
+}
+function computeVoucherGrant(voucher, currentKey, now) {
+  if (voucher.type === "credit") {
+    const current = _nullishCoalesce(_optionalChain([currentKey, 'optionalAccess', _118 => _118.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', _119 => _119.expiresAt]), () => ( now));
+  let granted = currentExpiry + (_nullishCoalesce(voucher.renewalDays, () => ( 0))) * DAY_MS2;
+  if (voucher.maxExpiryDays != null) {
+    granted = Math.min(granted, now + voucher.maxExpiryDays * DAY_MS2);
+  }
+  return { expiresAt: granted };
+}
+function toVoucherInfo(v) {
+  const info = {
+    id: v.id,
+    codePrefix: v.codePrefix,
+    type: v.type,
+    status: v.status,
+    createdAt: v.createdAt
+  };
+  if (v.creditUsd != null) info.creditUsd = v.creditUsd;
+  if (v.renewalDays != null) info.renewalDays = v.renewalDays;
+  if (v.maxTotalCostLimitUsd != null) info.maxTotalCostLimitUsd = v.maxTotalCostLimitUsd;
+  if (v.maxExpiryDays != null) info.maxExpiryDays = v.maxExpiryDays;
+  if (v.redeemedAt != null) info.redeemedAt = v.redeemedAt;
+  if (v.redeemedByKeyId != null) info.redeemedByKeyId = v.redeemedByKeyId;
+  if (v.grantApplied != null) info.grantApplied = v.grantApplied;
+  if (v.grantedTotalCostLimitUsd != null) info.grantedTotalCostLimitUsd = v.grantedTotalCostLimitUsd;
+  if (v.grantedExpiresAt != null) info.grantedExpiresAt = v.grantedExpiresAt;
+  if (v.revokedAt != null) info.revokedAt = v.revokedAt;
+  return info;
+}
+
+// src/outbound-api/voucherRedeem.ts
+function isRedeemRequest(method, url) {
+  if (method !== "POST" || !url) return false;
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _120 => _120.split, 'call', _121 => _121("?"), 'access', _122 => _122[0], 'optionalAccess', _123 => _123.replace, 'call', _124 => _124(/\/+$/, "")]), () => ( ""));
+  return path.endsWith("/redeem");
+}
+function writeErr(res, status, message, headers = {}) {
+  if (res.headersSent) return;
+  res.writeHead(status, { "Content-Type": "application/json", ...headers });
+  res.end(JSON.stringify({ error: { type: "voucher_error", message } }));
+}
+function writeResult(res, result) {
+  if (res.headersSent) return;
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true, ...result }));
+}
+function readBody2(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function grantToResult(type, granted) {
+  const result = { type };
+  if (granted.totalCostLimitUsd != null) result.totalCostLimitUsd = granted.totalCostLimitUsd;
+  if (granted.expiresAt != null) result.expiresAt = granted.expiresAt;
+  return result;
+}
+function currentResult(type, keyRow) {
+  const result = { type };
+  if (type === "credit") {
+    if (_optionalChain([keyRow, 'optionalAccess', _125 => _125.totalCostLimitUsd]) != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
+  } else if (_optionalChain([keyRow, 'optionalAccess', _126 => _126.expiresAt]) != null) {
+    result.expiresAt = keyRow.expiresAt;
+  }
+  return result;
+}
+function recordedAbsolute(v) {
+  const granted = {};
+  if (v.grantedTotalCostLimitUsd != null) granted.totalCostLimitUsd = v.grantedTotalCostLimitUsd;
+  if (v.grantedExpiresAt != null) granted.expiresAt = v.grantedExpiresAt;
+  return granted;
+}
+function policyFrom(granted) {
+  const policy = {};
+  if (granted.totalCostLimitUsd != null) policy.totalCostLimitUsd = granted.totalCostLimitUsd;
+  if (granted.expiresAt != null) policy.expiresAt = granted.expiresAt;
+  return policy;
+}
+var NOT_REDEEMABLE = "Invalid or non-redeemable code";
+var fallbackMutex = null;
+function getFallbackMutex() {
+  fallbackMutex ??= new KeyedMutex();
+  return fallbackMutex;
+}
+async function handleVoucherRedeem(req, res, deps, voucherEnabled, redeemLimiter, verifiedKeyId, presentedKey, now, redeemMutex) {
+  if (!voucherEnabled || !deps.voucherDb) {
+    writeErr(res, 403, "Voucher redemption is not enabled");
+    return;
+  }
+  const voucherDb = deps.voucherDb;
+  const rl = redeemLimiter.check(verifiedKeyId, now);
+  if (!rl.allowed) {
+    writeErr(res, 429, "Too many redeem attempts", { "Retry-After": String(rl.retryAfterSeconds) });
+    return;
+  }
+  const raw = await readBody2(req);
+  let code;
+  try {
+    code = raw ? JSON.parse(raw)["code"] : void 0;
+  } catch (e20) {
+    writeErr(res, 400, "Invalid JSON in request body");
+    return;
   }
-  return "default";
-}
-function endpointToIngressFormat(endpoint) {
-  switch (endpoint) {
-    case "chat":
-      return "openai-chat";
-    case "responses":
-      return "openai-responses";
-    case "messages":
-      return "anthropic-messages";
-    case "gemini":
-      return "gemini-generatecontent";
+  if (typeof code !== "string" || !code.trim()) {
+    writeErr(res, 400, "Missing redemption code");
+    return;
   }
+  const codeHash = hashVoucherCode(code.trim());
+  const keyHash = hashKey(presentedKey.trim());
+  const applyFirstPass = async (voucher, absolute) => {
+    const ok = await deps.db.outboundApiKeysSetPolicy(verifiedKeyId, policyFrom(absolute));
+    if (!ok) {
+      await voucherDb.voucherRevertRedeem(voucher.id, verifiedKeyId);
+      return { ok: false, status: 409, message: "Could not apply the grant \u2014 please retry" };
+    }
+    await voucherDb.voucherMarkGrantApplied(voucher.id);
+    return { ok: true, result: grantToResult(voucher.type, absolute) };
+  };
+  const reconcileOne = async (voucher) => {
+    const ok = await deps.db.outboundApiKeysSetPolicy(verifiedKeyId, policyFrom(recordedAbsolute(voucher)));
+    if (ok) await voucherDb.voucherMarkGrantApplied(voucher.id);
+  };
+  const reconcileStranded = async () => {
+    const all = await voucherDb.voucherList();
+    const stranded = all.filter((v) => v.status === "redeemed" && v.grantApplied !== true && v.redeemedByKeyId === verifiedKeyId).sort((a, b) => (_nullishCoalesce(a.redeemedAt, () => ( 0))) - (_nullishCoalesce(b.redeemedAt, () => ( 0))));
+    for (const v of stranded) await reconcileOne(v);
+  };
+  const runCritical = async () => {
+    await reconcileStranded();
+    const voucher = await voucherDb.voucherGetByHash(codeHash);
+    if (!voucher || voucher.status === "revoked") {
+      return { ok: false, status: 400, message: NOT_REDEEMABLE };
+    }
+    if (voucher.status === "redeemed") {
+      if (voucher.redeemedByKeyId !== verifiedKeyId) {
+        return { ok: false, status: 400, message: NOT_REDEEMABLE };
+      }
+      if (voucher.grantApplied === true) {
+        const keyRow2 = await deps.db.outboundApiKeysGetByHash(keyHash);
+        return { ok: true, result: currentResult(voucher.type, keyRow2) };
+      }
+      return await applyFirstPass(voucher, recordedAbsolute(voucher));
+    }
+    const keyRow = await deps.db.outboundApiKeysGetByHash(keyHash);
+    const absolute = computeVoucherGrant(voucher, keyRow, now);
+    const won = await voucherDb.voucherRedeemCas(voucher.id, verifiedKeyId, absolute, now);
+    if (!won) {
+      const after = await voucherDb.voucherGetByHash(codeHash);
+      if (_optionalChain([after, 'optionalAccess', _127 => _127.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" };
+    }
+    return await applyFirstPass(voucher, absolute);
+  };
+  const mutex = _nullishCoalesce(redeemMutex, () => ( getFallbackMutex()));
+  const outcome = await mutex.runExclusive(verifiedKeyId, runCritical);
+  if (outcome.ok) writeResult(res, outcome.result);
+  else writeErr(res, outcome.status, outcome.message);
 }
 
 // src/outbound-api/outboundApiRouter.ts
+var fallbackRedeemLimiter = null;
+function getFallbackRedeemLimiter() {
+  fallbackRedeemLimiter ??= new OutboundRateLimiter({ maxRequests: 10, windowMs: 6e4 });
+  return fallbackRedeemLimiter;
+}
 function writeJsonError(res, status, message, headers = {}) {
   if (res.headersSent) return;
   res.writeHead(status, { "Content-Type": "application/json", ...headers });
   res.end(JSON.stringify({ error: { type: "outbound_api_error", message } }));
 }
+function writeCostLimitError(res, scope, limitUsd, spentUsd) {
+  if (res.headersSent) return;
+  res.writeHead(402, { "Content-Type": "application/json" });
+  res.end(
+    JSON.stringify({
+      error: {
+        type: "outbound_api_error",
+        message: `Cost limit reached for this key (${scope}): $${spentUsd.toFixed(4)} of $${limitUsd.toFixed(4)}`
+      },
+      scope,
+      limitUsd,
+      spentUsd
+    })
+  );
+}
+function writeModelNotAllowedError(res, model, mode) {
+  if (res.headersSent) return;
+  res.writeHead(403, { "Content-Type": "application/json" });
+  res.end(
+    JSON.stringify({
+      error: {
+        type: "outbound_api_error",
+        message: `Model '${model}' is not permitted for this key (${mode})`
+      },
+      model,
+      mode
+    })
+  );
+}
 function extractPresentedKey(req) {
   const auth = req.headers["authorization"];
   if (typeof auth === "string" && auth.trim()) {
@@ -1894,14 +3428,14 @@ function extractPresentedKey(req) {
   }
   const xApiKey = req.headers["x-api-key"];
   const xApi = Array.isArray(xApiKey) ? xApiKey[0] : xApiKey;
-  if (_optionalChain([xApi, 'optionalAccess', _77 => _77.trim, 'call', _78 => _78()])) return xApi.trim();
+  if (_optionalChain([xApi, 'optionalAccess', _128 => _128.trim, 'call', _129 => _129()])) return xApi.trim();
   const goog = req.headers["x-goog-api-key"];
   const g = Array.isArray(goog) ? goog[0] : goog;
-  return _optionalChain([g, 'optionalAccess', _79 => _79.trim, 'call', _80 => _80()]) || void 0;
+  return _optionalChain([g, 'optionalAccess', _130 => _130.trim, 'call', _131 => _131()]) || void 0;
 }
 function selectEndpoint(method, url) {
   if (method !== "POST" || !url) return null;
-  const path = _nullishCoalesce(_optionalChain([url, 'access', _81 => _81.split, 'call', _82 => _82("?"), 'access', _83 => _83[0], 'optionalAccess', _84 => _84.replace, 'call', _85 => _85(/\/+$/, "")]), () => ( ""));
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _132 => _132.split, 'call', _133 => _133("?"), 'access', _134 => _134[0], 'optionalAccess', _135 => _135.replace, 'call', _136 => _136(/\/+$/, "")]), () => ( ""));
   if (path.endsWith("/chat/completions")) return "chat";
   if (path.endsWith("/responses")) return "responses";
   if (path.includes("/v1/messages")) return "messages";
@@ -1917,7 +3451,18 @@ function extractGeminiModelFromUrl(url) {
   const m = /\/models\/([^/:]+):(?:stream)?[gG]enerateContent$/.exec(path.replace(/\/+$/, ""));
   return m ? decodeURIComponent(m[1]) : void 0;
 }
-function readBody2(req) {
+function isModelsListRequest(url) {
+  if (!url) return false;
+  const path = _nullishCoalesce(_optionalChain([url, 'access', _137 => _137.split, 'call', _138 => _138("?"), 'access', _139 => _139[0], 'optionalAccess', _140 => _140.replace, 'call', _141 => _141(/\/+$/, "")]), () => ( ""));
+  return path.endsWith("/models");
+}
+function writeChatModelsList(res, config) {
+  const chat = config.endpoints.find((e) => e.endpoint === "chat");
+  const data = (_nullishCoalesce(_optionalChain([chat, 'optionalAccess', _142 => _142.models]), () => ( []))).map((ref) => _chunkSVXC36MUcjs.parseModelRef.call(void 0, ref)).filter((p) => p !== null).map((p) => ({ id: p.modelId, object: "model", owned_by: "omnicross" }));
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ object: "list", data }));
+}
+function readBody3(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
@@ -1930,20 +3475,48 @@ function shimAuthHeader(req, routeToken) {
   delete req.headers["x-goog-api-key"];
   delete req.headers["x-api-key"];
 }
-async function handleOutboundRequest(req, res, deps, config, rateLimiter) {
+async function handleOutboundRequest(req, res, deps, config, rateLimiter, serialQueue, concurrencyGate, redeemLimiter, redeemMutex) {
+  const now = Date.now();
+  const audit = beginAuditCapture(req, res, now);
+  const billing = beginBillingCapture(req, res, now);
   const presented = extractPresentedKey(req);
-  const verified = await verifyPresentedKey(deps.db, presented);
-  if (!verified) {
-    writeJsonError(res, 401, "Invalid or missing API key");
+  const verification = await verifyKey(deps.db, presented, now);
+  if (verification.status !== "ok") {
+    writeJsonError(
+      res,
+      401,
+      verification.status === "expired" ? "API key has expired" : "Invalid or missing API key"
+    );
+    return;
+  }
+  const verified = verification.key;
+  if (audit) audit.keyId = verified.id;
+  if (billing) billing.keyId = verified.id;
+  if (isRedeemRequest(req.method, req.url)) {
+    await handleVoucherRedeem(
+      req,
+      res,
+      deps,
+      _optionalChain([config, 'access', _143 => _143.voucher, 'optionalAccess', _144 => _144.enabled]) === true,
+      _nullishCoalesce(redeemLimiter, () => ( getFallbackRedeemLimiter())),
+      verified.id,
+      _nullishCoalesce(presented, () => ( "")),
+      now,
+      redeemMutex
+    );
     return;
   }
-  const decision = rateLimiter.check(verified.id);
+  const decision = rateLimiter.check(verified.id, now, verified.rateLimit);
   if (!decision.allowed) {
     writeJsonError(res, 429, "Rate limit exceeded", {
       "Retry-After": String(decision.retryAfterSeconds)
     });
     return;
   }
+  if (req.method === "GET" && isModelsListRequest(req.url)) {
+    writeChatModelsList(res, config);
+    return;
+  }
   const endpoint = selectEndpoint(req.method, req.url);
   if (!endpoint) {
     writeJsonError(res, 404, `Unsupported: ${req.method} ${req.url}`);
@@ -1954,53 +3527,165 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter) {
     writeJsonError(res, 503, `endpoint '${endpoint}' is not configured`);
     return;
   }
-  const ingressFormat = endpointToIngressFormat(endpoint);
-  const rawBody = await readBody2(req);
-  let parsedBody = {};
-  try {
-    parsedBody = rawBody ? JSON.parse(rawBody) : {};
-  } catch (e12) {
-    writeJsonError(res, 400, "Invalid JSON in request body");
-    return;
-  }
-  if (endpoint === "gemini" && typeof parsedBody["model"] !== "string") {
-    const urlModel = extractGeminiModelFromUrl(req.url);
-    if (urlModel) parsedBody["model"] = urlModel;
+  if (verified.costLimits && deps.keySpendTracker) {
+    const spend = await deps.keySpendTracker.getSpend(verified.id, now);
+    const quota = checkKeyQuota(verified.costLimits, spend);
+    if (!quota.allowed) {
+      emitWebhookEvent({
+        kind: "key.quotaExceeded",
+        at: now,
+        keyId: verified.id,
+        scope: quota.scope,
+        limitUsd: quota.limitUsd,
+        spentUsd: quota.spentUsd
+      });
+      writeCostLimitError(res, quota.scope, quota.limitUsd, quota.spentUsd);
+      return;
+    }
+    for (const warn of computeQuotaWarnings(verified.costLimits, spend)) {
+      if (markQuotaWarnedOnce(verified.id, warn.scope, warn.windowStart)) {
+        emitWebhookEvent({
+          kind: "key.quotaWarning",
+          at: now,
+          keyId: verified.id,
+          scope: warn.scope,
+          limitUsd: warn.limitUsd,
+          spentUsd: warn.spentUsd
+        });
+      }
+    }
   }
-  const role = detectRequestRole(ingressFormat, parsedBody, {
-    backgroundModelIds: endpointConfig.backgroundModelIds
-  });
-  const resolved = await _chunkG2FUJNA2cjs.resolveRoute.call(void 0, {
-    config: endpointConfig,
-    role,
-    ingressFormat,
-    llmConfig: deps.llmConfig,
-    // pool-seam (omnicross-daemon-parity-poolseam, design D1/D2(a)): synthesize a
-    // STABLE per-verified-key sessionId so the BYO ingress can seed a pool session
-    // binding and 429/529/401/403 failover actually fires. Synthesize ONLY when
-    // the pool is wired — pool-null embedders/tests keep `route.sessionId === null`
-    // (byte-identical to pre-seam). The `outbound:` prefix is namespace-isolated
-    // from real chat-session ids; `verified.id` is a small operator-controlled set,
-    // so `sessionBindings` stays bounded (one binding per named key, not per
-    // request — `sessionBindings` has no TTL).
-    sessionId: deps.proxyDeps.apiKeyPool ? `outbound:${verified.id}` : null
-  });
-  if (!resolved.ok) {
-    writeJsonError(res, resolved.error.status, resolved.error.message);
-    return;
+  const concurrencyLimit = verified.maxConcurrency;
+  let releaseConcurrency = null;
+  if (typeof concurrencyLimit === "number" && concurrencyLimit > 0) {
+    const cq = _nullishCoalesce(config.concurrencyQueue, () => ( DEFAULT_CONCURRENCY_QUEUE));
+    const acquisition = concurrencyGate.acquire(verified.id, concurrencyLimit, {
+      maxQueueSizeFactor: cq.maxQueueSizeFactor,
+      minQueueSize: cq.minQueueSize,
+      waitTimeoutMs: cq.waitTimeoutMs
+    });
+    const cancelOnClose = () => acquisition.cancel();
+    res.once("close", cancelOnClose);
+    let slot;
+    try {
+      slot = await acquisition.granted;
+    } catch (err) {
+      res.removeListener("close", cancelOnClose);
+      if (isConcurrencyRejection(err)) {
+        writeJsonError(res, 429, "Concurrency limit exceeded", { "Retry-After": "5" });
+        return;
+      }
+      throw err;
+    }
+    res.removeListener("close", cancelOnClose);
+    const release2 = () => slot.release();
+    releaseConcurrency = release2;
+    res.once("close", release2);
   }
-  const routeMap = deps.providerProxy.getRouteMap();
-  const token = routeMap.addRoute(resolved.route);
   try {
-    shimAuthHeader(req, token);
-    const replay = makeReplayRequest(req, rawBody);
-    await routeRequest(replay, res, routeMap, deps.proxyDeps);
-  } catch (err) {
-    const message = _chunkSVNDB62Dcjs.serializeError.call(void 0, err);
-    console.error("[OutboundApi] dispatch error:", message);
-    writeJsonError(res, 502, message);
+    const ingressFormat = _chunkSVXC36MUcjs.endpointToIngressFormat.call(void 0, endpoint);
+    const rawBody = await readBody3(req);
+    let parsedBody = {};
+    try {
+      parsedBody = rawBody ? JSON.parse(rawBody) : {};
+    } catch (e21) {
+      writeJsonError(res, 400, "Invalid JSON in request body");
+      return;
+    }
+    if (audit) audit.setRequestBody(rawBody);
+    if (endpoint === "gemini" && typeof parsedBody["model"] !== "string") {
+      const urlModel = extractGeminiModelFromUrl(req.url);
+      if (urlModel) parsedBody["model"] = urlModel;
+    }
+    const sessionId = deps.proxyDeps.apiKeyPool ? `outbound:${verified.id}` : null;
+    const resolved = _chunkSVXC36MUcjs.isKindMappedEndpoint.call(void 0, endpoint) || endpoint === "chat" ? await _chunkSVXC36MUcjs.resolveRoute.call(void 0, {
+      config: endpointConfig,
+      ingressFormat,
+      llmConfig: deps.llmConfig,
+      sessionId,
+      // Capture the ORIGINAL requested id BEFORE any downstream swap; for
+      // kind-mapped endpoints it selects the kind AND is stamped onto
+      // `route.requestedModel`; for chat it is matched against the list.
+      requestedModel: _chunkSVXC36MUcjs.extractRequestedModel.call(void 0, ingressFormat, parsedBody),
+      // Attribution: stamp the verified named-key id onto the route.
+      apiKeyId: verified.id
+    }) : await _chunkSVXC36MUcjs.resolveRoute.call(void 0, {
+      config: endpointConfig,
+      role: _chunkSVXC36MUcjs.detectRequestRole.call(void 0, ingressFormat, parsedBody, {
+        backgroundModelIds: endpointConfig.backgroundModelIds
+      }),
+      ingressFormat,
+      llmConfig: deps.llmConfig,
+      sessionId,
+      // Attribution: stamp the verified named-key id onto the route.
+      apiKeyId: verified.id
+    });
+    if (!resolved.ok) {
+      writeJsonError(res, resolved.error.status, resolved.error.message);
+      return;
+    }
+    if (audit) {
+      audit.model = resolved.route.model;
+      audit.provider = resolved.route.providerId;
+    }
+    if (billing) {
+      billing.model = resolved.route.model;
+      billing.provider = resolved.route.providerId;
+      billing.authMode = resolved.route.authMode;
+    }
+    if (verified.modelRestriction) {
+      const modelDecision = checkModelAllowed(verified.modelRestriction, resolved.route.model);
+      if (!modelDecision.allowed) {
+        writeModelNotAllowedError(res, modelDecision.model, verified.modelRestriction.mode);
+        return;
+      }
+    }
+    let releaseSerial = null;
+    const providerKey = resolved.route.providerId;
+    if (_optionalChain([config, 'access', _145 => _145.userMessageQueue, 'optionalAccess', _146 => _146.enabled]) && providerKey && isUserMessageRequest(endpoint, parsedBody)) {
+      const umq = config.userMessageQueue;
+      try {
+        const serialSlot = await serialQueue.acquire(providerKey, {
+          waitTimeoutMs: umq.waitTimeoutMs,
+          delayMs: umq.delayMs
+        });
+        releaseSerial = () => serialSlot.release();
+      } catch (err) {
+        if (isSerialQueueTimeout(err)) {
+          writeJsonError(res, 503, "User-message serial queue wait timed out");
+          return;
+        }
+        throw err;
+      }
+    }
+    if (releaseSerial) {
+      const original = res.writeHead.bind(res);
+      const releaseOnce = releaseSerial;
+      res.writeHead = ((...args) => {
+        res.writeHead = original;
+        releaseOnce();
+        return original(...args);
+      });
+    }
+    const routeMap = deps.providerProxy.getRouteMap();
+    const token = routeMap.addRoute(resolved.route);
+    try {
+      shimAuthHeader(req, token);
+      const replay = makeReplayRequest(req, rawBody);
+      await routeRequest(replay, res, routeMap, deps.proxyDeps);
+    } catch (err) {
+      const message = _chunkSVNDB62Dcjs.serializeError.call(void 0, err);
+      if (deps.logger) deps.logger.error("[OutboundApi] dispatch error:", message);
+      else console.error("[OutboundApi] dispatch error:", message);
+      emitWebhookEvent({ kind: "server.error", at: Date.now(), message });
+      if (audit) audit.error = message;
+      writeJsonError(res, 502, message);
+    } finally {
+      routeMap.removeRoute(token);
+      if (releaseSerial) releaseSerial();
+    }
   } finally {
-    routeMap.removeRoute(token);
+    if (releaseConcurrency) releaseConcurrency();
   }
 }
 function makeReplayRequest(req, rawBody) {
@@ -2014,65 +3699,50 @@ function makeReplayRequest(req, rawBody) {
   return readable;
 }
 
-// src/outbound-api/outboundRateLimiter.ts
-var DEFAULT_WINDOW_MS = 6e4;
-var DEFAULT_MAX_REQUESTS = 60;
-var OutboundRateLimiter = (_class3 = class {
-  
-  
-  /** apiKeyId → ascending request timestamps within the current window. */
-  __init4() {this.hits = /* @__PURE__ */ new Map()}
-  constructor(options = {}) {;_class3.prototype.__init4.call(this);
-    this.windowMs = _nullishCoalesce(options.windowMs, () => ( DEFAULT_WINDOW_MS));
-    this.maxRequests = _nullishCoalesce(options.maxRequests, () => ( DEFAULT_MAX_REQUESTS));
-  }
-  /**
-   * Record a request for `apiKeyId` and decide whether it is allowed. Prunes
-   * timestamps older than the window first; when allowed, the request's
-   * timestamp is appended.
-   */
-  check(apiKeyId, now = Date.now()) {
-    const cutoff = now - this.windowMs;
-    const timestamps = (_nullishCoalesce(this.hits.get(apiKeyId), () => ( []))).filter((ts) => ts > cutoff);
-    if (timestamps.length >= this.maxRequests) {
-      if (timestamps.length === 0) {
-        this.hits.delete(apiKeyId);
-        return { allowed: false, retryAfterSeconds: Math.max(1, Math.ceil(this.windowMs / 1e3)) };
-      }
-      const oldest = timestamps[0];
-      const retryAfterMs = Math.max(0, oldest + this.windowMs - now);
-      this.hits.set(apiKeyId, timestamps);
-      return {
-        allowed: false,
-        retryAfterSeconds: Math.max(1, Math.ceil(retryAfterMs / 1e3))
-      };
-    }
-    timestamps.push(now);
-    this.hits.set(apiKeyId, timestamps);
-    return { allowed: true, retryAfterSeconds: 0 };
-  }
-  /** Drop all recorded state (tests / teardown). */
-  reset() {
-    this.hits.clear();
-  }
-}, _class3);
-
 // src/outbound-api/OutboundApiServer.ts
 var DEFAULT_OUTBOUND_PORT = 8765;
 var LOOPBACK_ADDR = "127.0.0.1";
 var LAN_ADDR = "0.0.0.0";
-var OutboundApiServer = (_class4 = class {
-  constructor(deps, onPortChange) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);
+var OutboundApiConfigError = class extends Error {
+  
+  constructor(missing) {
+    super(
+      "Outbound API server cannot start: incomplete model-kind configuration \u2014 " + missing.map((m) => `${m.endpoint} missing [${m.missingKinds.join(", ")}]`).join("; ")
+    );
+    this.name = "OutboundApiConfigError";
+    this.missing = missing;
+  }
+};
+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);
     this.deps = deps;
     this.onPortChange = onPortChange;
   }
   
   
-  __init5() {this.server = null}
-  __init6() {this.boundPort = 0}
-  __init7() {this.boundAddr = LOOPBACK_ADDR}
-  __init8() {this.endpoints = []}
-  __init9() {this.rateLimiter = new OutboundRateLimiter()}
+  __init12() {this.server = null}
+  __init13() {this.boundPort = 0}
+  __init14() {this.boundAddr = LOOPBACK_ADDR}
+  __init15() {this.endpoints = []}
+  
+  
+  
+  __init16() {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).
+   */
+  __init17() {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).
+   */
+  __init18() {this.redeemMutex = new KeyedMutex()}
+  __init19() {this.serialQueue = new UserMessageSerialQueue()}
+  __init20() {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
@@ -2080,12 +3750,25 @@ var OutboundApiServer = (_class4 = class {
    */
   async applyConfig(input) {
     this.endpoints = input.endpoints;
+    this.userMessageQueue = input.userMessageQueue;
+    this.concurrencyQueue = input.concurrencyQueue;
+    this.voucherConfig = input.voucher;
     const wantAddr = input.networkBinding ? LAN_ADDR : LOOPBACK_ADDR;
     const wantPort = _nullishCoalesce(input.port, () => ( DEFAULT_OUTBOUND_PORT));
     if (!input.enabled) {
       await this.stop();
       return;
     }
+    const missing = _chunkSVXC36MUcjs.validateServerModelConfig.call(void 0, {
+      enabled: true,
+      networkBinding: input.networkBinding,
+      endpoints: input.endpoints,
+      port: input.port
+    });
+    if (missing.length > 0) {
+      await this.stop();
+      throw new OutboundApiConfigError(missing);
+    }
     const running = this.server !== null;
     const bindChanged = running && (this.boundAddr !== wantAddr || this.boundPort !== wantPort);
     if (running && !bindChanged) {
@@ -2100,8 +3783,8 @@ var OutboundApiServer = (_class4 = class {
     const actualPort = await this.listen(bindAddr, port);
     this.boundAddr = bindAddr;
     this.boundPort = actualPort;
-    if (actualPort !== port) _optionalChain([this, 'access', _86 => _86.onPortChange, 'optionalCall', _87 => _87(actualPort)]);
-    console.log(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
+    if (actualPort !== port) _optionalChain([this, 'access', _147 => _147.onPortChange, 'optionalCall', _148 => _148(actualPort)]);
+    this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
   /** Bind once; on EADDRINUSE retry with an ephemeral port (port 0). */
@@ -2123,7 +3806,7 @@ var OutboundApiServer = (_class4 = class {
         const addr = server.address();
         if (addr && typeof addr === "object") {
           server.removeListener("error", onError);
-          server.on("error", (e) => console.error("[OutboundApiServer] server error", _chunkSVNDB62Dcjs.serializeError.call(void 0, e)));
+          server.on("error", (e) => this.logError("[OutboundApiServer] server error", _chunkSVNDB62Dcjs.serializeError.call(void 0, e)));
           this.server = server;
           resolve(addr.port);
         } else {
@@ -2134,21 +3817,58 @@ var OutboundApiServer = (_class4 = class {
   }
   /** Per-request handler. Auth is enforced on EVERY request (incl. loopback). */
   onRequest(req, res) {
+    if (this.deps.healthReportProvider && this.tryServeHealth(req, res)) return;
     handleOutboundRequest(
       req,
       res,
       this.deps,
-      { endpoints: this.endpoints },
-      this.rateLimiter
+      {
+        endpoints: this.endpoints,
+        userMessageQueue: this.userMessageQueue,
+        concurrencyQueue: this.concurrencyQueue,
+        voucher: this.voucherConfig
+      },
+      this.rateLimiter,
+      this.serialQueue,
+      this.concurrencyGate,
+      this.redeemLimiter,
+      this.redeemMutex
     ).catch((err) => {
       const message = _chunkSVNDB62Dcjs.serializeError.call(void 0, err);
-      console.error("[OutboundApiServer] unhandled error:", message);
+      this.logError("[OutboundApiServer] unhandled error:", message);
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: { type: "outbound_api_error", message } }));
       }
     });
   }
+  /**
+   * Serve `GET|HEAD /health` (+ `/healthz`) from the injected provider, returning
+   * true when it handled the request. 200 when `ok`, else 503; secret-free body.
+   */
+  tryServeHealth(req, res) {
+    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', _149 => _149.split, 'call', _150 => _150("?"), 'access', _151 => _151[0], 'optionalAccess', _152 => _152.replace, 'call', _153 => _153(/\/+$/, "")]) || "/";
+    if (path !== "/health" && path !== "/healthz") return false;
+    const report = provider();
+    res.writeHead(_healthloggingtypes.healthHttpStatus.call(void 0, report.status), { "Content-Type": "application/json" });
+    res.end(req.method === "HEAD" ? void 0 : JSON.stringify(report));
+    return true;
+  }
+  /** Route an info lifecycle line through the injected logger, else `console.log`
+   *  (byte-identical legacy fallback when no logger is wired). */
+  logInfo(message) {
+    if (this.deps.logger) this.deps.logger.info(message);
+    else console.log(message);
+  }
+  /** Route an error lifecycle line through the injected logger, else `console.error`. */
+  logError(message, detail) {
+    if (this.deps.logger) this.deps.logger.error(message, detail);
+    else if (detail === void 0) console.error(message);
+    else console.error(message, detail);
+  }
   /** Stop the listener and release the port. */
   async stop() {
     const server = this.server;
@@ -2157,7 +3877,7 @@ var OutboundApiServer = (_class4 = class {
     this.boundPort = 0;
     return new Promise((resolve) => {
       server.close(() => {
-        console.log("[OutboundApiServer] Stopped");
+        this.logInfo("[OutboundApiServer] Stopped");
         resolve();
       });
     });
@@ -2189,7 +3909,18 @@ var OutboundApiServer = (_class4 = class {
       lanFormats: lanBase ? formatUrls(lanBase) : null
     };
   }
-}, _class4);
+  /**
+   * Live queue-occupancy snapshot (only active entries). This getter's name +
+   * shape are FROZEN — `omnicross-uqc-daemon` spreads it into its `/status`
+   * response; the existing {@link getStatus} shape is deliberately NOT changed.
+   */
+  getQueueStatus() {
+    return {
+      serial: this.serialQueue.getStatus(),
+      concurrency: this.concurrencyGate.getStatus()
+    };
+  }
+}, _class11);
 function formatUrls(base) {
   return {
     chat: `${base}/v1/chat/completions`,
@@ -2209,66 +3940,88 @@ function firstLanIPv4() {
   return null;
 }
 
-// src/outbound-api/apiServerConfig.ts
-var OUTBOUND_API_SERVER_CONFIG_KEY = "outboundApiServer.config";
-var ALL_ENDPOINTS = ["chat", "responses", "messages", "gemini"];
-function defaultEndpointConfig(endpoint) {
-  return {
-    endpoint,
-    defaultModel: "",
-    backgroundModel: "",
-    useSubscription: false
-  };
+// src/outbound-api/keySpendTracker.ts
+function startOfLocalDay(ts) {
+  const d = new Date(ts);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
 }
-function defaultServerConfig() {
-  return {
-    enabled: false,
-    networkBinding: false,
-    endpoints: ALL_ENDPOINTS.map(defaultEndpointConfig),
-    port: DEFAULT_OUTBOUND_PORT
-  };
+function startOfLocalWeek(ts) {
+  const d = new Date(ts);
+  const day = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  day.setDate(day.getDate() - day.getDay());
+  return day.getTime();
 }
-function normalizeServerConfig(raw) {
-  const base = defaultServerConfig();
-  if (!raw) return base;
-  const byEndpoint = /* @__PURE__ */ new Map();
-  for (const e of _nullishCoalesce(raw.endpoints, () => ( []))) {
-    if (e && ALL_ENDPOINTS.includes(e.endpoint)) {
-      byEndpoint.set(e.endpoint, {
-        endpoint: e.endpoint,
-        defaultModel: _nullishCoalesce(e.defaultModel, () => ( "")),
-        backgroundModel: _nullishCoalesce(e.backgroundModel, () => ( "")),
-        visionModel: e.visionModel,
-        useSubscription: e.useSubscription === true,
-        backgroundModelIds: e.backgroundModelIds
-      });
+var KeySpendTracker = (_class12 = class {
+  constructor(seeder) {;_class12.prototype.__init21.call(this);
+    this.seeder = seeder;
+  }
+  
+  /** apiKeyId → live accumulated spend (seeded lazily). */
+  __init21() {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.
+   */
+  async getSpend(apiKeyId, now) {
+    const existing = this.spend.get(apiKeyId);
+    if (existing) {
+      rollWindows(existing, now);
+      return existing;
     }
+    const seeded = await this.seed(apiKeyId, now);
+    const existingAfterSeed = this.spend.get(apiKeyId);
+    if (existingAfterSeed) {
+      rollWindows(existingAfterSeed, now);
+      return existingAfterSeed;
+    }
+    this.spend.set(apiKeyId, seeded);
+    return seeded;
+  }
+  /**
+   * Increment the aggregate for one recorded request. No-op when the key has not
+   * been seeded yet — a later `getSpend` will lazy-seed from the durable store,
+   * which already includes this record, so it is neither lost nor double-counted.
+   */
+  add(apiKeyId, costUsd, now) {
+    const s = this.spend.get(apiKeyId);
+    if (!s) return;
+    rollWindows(s, now);
+    s.dailyUsd += costUsd;
+    s.weeklyUsd += costUsd;
+    s.totalUsd += costUsd;
+  }
+  /** Drop all cached spend (tests / teardown). */
+  reset() {
+    this.spend.clear();
+  }
+  /**
+   * Derive a fresh spend snapshot for `apiKeyId` from the durable store in a
+   * SINGLE scan (all three windows at once). `endTs` is EXCLUSIVE, so `now + 1`
+   * includes a record stamped at exactly `now`.
+   */
+  async seed(apiKeyId, now) {
+    const dailyWindowStart = startOfLocalDay(now);
+    const weeklyWindowStart = startOfLocalWeek(now);
+    const { totalUsd, dailyUsd, weeklyUsd } = await this.seeder.getSpendByKey({
+      apiKeyId,
+      dayStartTs: dailyWindowStart,
+      weekStartTs: weeklyWindowStart,
+      endTs: now + 1
+    });
+    return { dailyUsd, dailyWindowStart, weeklyUsd, weeklyWindowStart, totalUsd };
+  }
+}, _class12);
+function rollWindows(s, now) {
+  const day = startOfLocalDay(now);
+  if (s.dailyWindowStart !== day) {
+    s.dailyUsd = 0;
+    s.dailyWindowStart = day;
+  }
+  const week = startOfLocalWeek(now);
+  if (s.weeklyWindowStart !== week) {
+    s.weeklyUsd = 0;
+    s.weeklyWindowStart = week;
   }
-  return {
-    enabled: raw.enabled === true,
-    networkBinding: raw.networkBinding === true,
-    endpoints: ALL_ENDPOINTS.map(
-      (ep) => _nullishCoalesce(byEndpoint.get(ep), () => ( defaultEndpointConfig(ep)))
-    ),
-    port: _nullishCoalesce(raw.port, () => ( base.port))
-  };
-}
-async function loadServerConfig(store) {
-  const raw = await store.get(
-    OUTBOUND_API_SERVER_CONFIG_KEY
-  );
-  return normalizeServerConfig(raw);
-}
-async function saveServerConfig(store, config) {
-  await store.set(OUTBOUND_API_SERVER_CONFIG_KEY, config);
-}
-function mergeServerConfig(current, patch) {
-  return normalizeServerConfig({
-    enabled: _nullishCoalesce(patch.enabled, () => ( current.enabled)),
-    networkBinding: _nullishCoalesce(patch.networkBinding, () => ( current.networkBinding)),
-    endpoints: _nullishCoalesce(patch.endpoints, () => ( current.endpoints)),
-    port: _nullishCoalesce(patch.port, () => ( current.port))
-  });
 }
 
 // src/outbound-api/index.ts
@@ -2304,7 +4057,7 @@ async function callOpenAICompletion(provider, apiKey, options, logger) {
     }
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   logger.info("Calling OpenAI completion API", { url: apiUrl, model: options.model });
   const response = await fetch(apiUrl, {
     method: "POST",
@@ -2350,7 +4103,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       stream: false
     };
     const apiUrl2 = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
-    const headers2 = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+    const headers2 = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
     logger.info("Calling Anthropic completion API with images", { url: apiUrl2, model: options.model });
     const response2 = await fetch(apiUrl2, {
       method: "POST",
@@ -2372,7 +4125,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       message: {
         id: `assistant-${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice2, 'access', _88 => _88.message, 'optionalAccess', _89 => _89.content]) || "",
+        content: _optionalChain([choice2, 'access', _154 => _154.message, 'optionalAccess', _155 => _155.content]) || "",
         timestamp: Date.now()
       },
       usage: openaiResponse2.usage ? {
@@ -2398,7 +4151,7 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
   };
   const anthropicRequest = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropic.call(void 0, openaiRequest, config);
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   logger.info("Calling Anthropic completion API", { url: apiUrl, model: options.model });
   const response = await fetch(apiUrl, {
     method: "POST",
@@ -2452,7 +4205,7 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
     request.systemInstruction = systemInstruction;
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   logger.info("Calling Gemini completion API", { url: apiUrl, model: options.model });
   const response = await fetch(apiUrl, {
     method: "POST",
@@ -2477,7 +4230,7 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
   const candidate = candidates[0];
   const content = candidate.content;
   let textContent = "";
-  if (_optionalChain([content, 'optionalAccess', _90 => _90.parts])) {
+  if (_optionalChain([content, 'optionalAccess', _156 => _156.parts])) {
     for (const part of content.parts) {
       if (part.text) {
         textContent += part.text;
@@ -2523,7 +4276,7 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
     }
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: false });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   logger.info("Calling OpenAI Response API", { url: apiUrl, model: options.model });
   const response = await fetch(apiUrl, {
     method: "POST",
@@ -2589,9 +4342,9 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     }
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   if (options.nativeSearchAugmentation) {
-    _chunkV5KPWNYXcjs.applyAugmentation.call(void 0, request, options.nativeSearchAugmentation);
+    _chunkJMJBSACDcjs.applyAugmentation.call(void 0, request, options.nativeSearchAugmentation);
   }
   logger.info("Streaming OpenAI completion request", {
     url: apiUrl,
@@ -2610,7 +4363,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _91 => _91.onError, 'optionalCall', _92 => _92(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _157 => _157.onError, 'optionalCall', _158 => _158(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai", {
@@ -2620,7 +4373,7 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     onVideo: callbacks.onVideo,
     onError: callbacks.onError
   });
-  _optionalChain([callbacks, 'access', _93 => _93.onDone, 'optionalCall', _94 => _94(
+  _optionalChain([callbacks, 'access', _159 => _159.onDone, 'optionalCall', _160 => _160(
     {
       id: messageId,
       role: "assistant",
@@ -2685,14 +4438,14 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
     }
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   if (options.nativeSearchAugmentation) {
-    _chunkV5KPWNYXcjs.applyAugmentation.call(void 0, anthropicRequest, options.nativeSearchAugmentation);
+    _chunkJMJBSACDcjs.applyAugmentation.call(void 0, anthropicRequest, options.nativeSearchAugmentation);
   }
   logger.info("Streaming Anthropic completion request", {
     url: apiUrl,
     model: anthropicRequest.model,
-    messagesCount: _optionalChain([anthropicRequest, 'access', _95 => _95.messages, 'optionalAccess', _96 => _96.length]),
+    messagesCount: _optionalChain([anthropicRequest, 'access', _161 => _161.messages, 'optionalAccess', _162 => _162.length]),
     max_tokens: anthropicRequest.max_tokens,
     temperature: anthropicRequest.temperature,
     stream: anthropicRequest.stream,
@@ -2709,7 +4462,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', _97 => _97.onError, 'optionalCall', _98 => _98(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _163 => _163.onError, 'optionalCall', _164 => _164(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "anthropic", {
@@ -2720,10 +4473,10 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
   });
   logger.info("Anthropic stream complete", {
     contentLength: result.content.length,
-    reasoningLength: _optionalChain([result, 'access', _99 => _99.reasoning, 'optionalAccess', _100 => _100.length]) || 0,
+    reasoningLength: _optionalChain([result, 'access', _165 => _165.reasoning, 'optionalAccess', _166 => _166.length]) || 0,
     blocksCount: result.blocks.length
   });
-  _optionalChain([callbacks, 'access', _101 => _101.onDone, 'optionalCall', _102 => _102(
+  _optionalChain([callbacks, 'access', _167 => _167.onDone, 'optionalCall', _168 => _168(
     {
       id: messageId,
       role: "assistant",
@@ -2757,9 +4510,9 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
     request.systemInstruction = systemInstruction;
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   if (options.nativeSearchAugmentation) {
-    _chunkV5KPWNYXcjs.applyAugmentation.call(void 0, request, options.nativeSearchAugmentation);
+    _chunkJMJBSACDcjs.applyAugmentation.call(void 0, request, options.nativeSearchAugmentation);
   }
   logger.info("Streaming Gemini completion request", {
     url: apiUrl,
@@ -2779,7 +4532,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', _103 => _103.onError, 'optionalCall', _104 => _104(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _169 => _169.onError, 'optionalCall', _170 => _170(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "gemini", {
@@ -2788,7 +4541,7 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
     onError: callbacks.onError
   });
   logger.info("Gemini stream complete", { contentLength: result.content.length });
-  _optionalChain([callbacks, 'access', _105 => _105.onDone, 'optionalCall', _106 => _106(
+  _optionalChain([callbacks, 'access', _171 => _171.onDone, 'optionalCall', _172 => _172(
     {
       id: messageId,
       role: "assistant",
@@ -2823,7 +4576,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
     }
   }
   const apiUrl = _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: options.model, stream: true });
-  const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+  const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
   logger.info("Streaming OpenAI Response API request", {
     url: apiUrl,
     providerId: options.providerId,
@@ -2840,7 +4593,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
   });
   if (!response.ok) {
     const errorText = await response.text();
-    _optionalChain([callbacks, 'access', _107 => _107.onError, 'optionalCall', _108 => _108(`API error (${response.status}): ${errorText}`)]);
+    _optionalChain([callbacks, 'access', _173 => _173.onError, 'optionalCall', _174 => _174(`API error (${response.status}): ${errorText}`)]);
     return;
   }
   const result = await _chunkHQP3K7PUcjs.streamSSEResponse.call(void 0, response, "openai-response", {
@@ -2849,7 +4602,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', _109 => _109.onDone, 'optionalCall', _110 => _110(
+  _optionalChain([callbacks, 'access', _175 => _175.onDone, 'optionalCall', _176 => _176(
     {
       id: messageId,
       role: "assistant",
@@ -2877,7 +4630,7 @@ async function resolveEffectiveMaxTokens(llmConfig, getProvider, logger, provide
   }
   try {
     const globalParams = await llmConfig.getGlobalModelParameters();
-    if (_optionalChain([globalParams, 'optionalAccess', _111 => _111.maxTokens, 'optionalAccess', _112 => _112.enabled]) && globalParams.maxTokens.value > 0) {
+    if (_optionalChain([globalParams, 'optionalAccess', _177 => _177.maxTokens, 'optionalAccess', _178 => _178.enabled]) && globalParams.maxTokens.value > 0) {
       logger.debug("Using global maxTokens", { maxTokens: globalParams.maxTokens.value });
       return globalParams.maxTokens.value;
     }
@@ -2887,8 +4640,8 @@ async function resolveEffectiveMaxTokens(llmConfig, getProvider, logger, provide
   const MAX_TOKENS_CAP = 131072;
   const provider = await getProvider(providerId);
   if (provider) {
-    const modelConfig = _optionalChain([provider, 'access', _113 => _113.modelConfigs, 'optionalAccess', _114 => _114.find, 'call', _115 => _115((m) => m.id === modelId)]);
-    if (_optionalChain([modelConfig, 'optionalAccess', _116 => _116.maxTokens]) && modelConfig.maxTokens > 0) {
+    const modelConfig = _optionalChain([provider, 'access', _179 => _179.modelConfigs, 'optionalAccess', _180 => _180.find, 'call', _181 => _181((m) => m.id === modelId)]);
+    if (_optionalChain([modelConfig, 'optionalAccess', _182 => _182.maxTokens]) && modelConfig.maxTokens > 0) {
       const cappedMaxTokens = Math.min(modelConfig.maxTokens, MAX_TOKENS_CAP);
       logger.debug("Using model config maxTokens", {
         maxTokens: modelConfig.maxTokens,
@@ -2898,8 +4651,8 @@ async function resolveEffectiveMaxTokens(llmConfig, getProvider, logger, provide
     }
     if (provider.modelGroups) {
       for (const group of provider.modelGroups) {
-        const model = _optionalChain([group, 'access', _117 => _117.models, 'optionalAccess', _118 => _118.find, 'call', _119 => _119((m) => m.id === modelId)]);
-        if (_optionalChain([model, 'optionalAccess', _120 => _120.maxTokens]) && model.maxTokens > 0) {
+        const model = _optionalChain([group, 'access', _183 => _183.models, 'optionalAccess', _184 => _184.find, 'call', _185 => _185((m) => m.id === modelId)]);
+        if (_optionalChain([model, 'optionalAccess', _186 => _186.maxTokens]) && model.maxTokens > 0) {
           const cappedMaxTokens = Math.min(model.maxTokens, MAX_TOKENS_CAP);
           logger.debug("Using modelGroup model maxTokens", {
             maxTokens: model.maxTokens,
@@ -2944,7 +4697,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', _121 => _121.name, 'optionalAccess', _122 => _122.toLowerCase, 'call', _123 => _123()]) || "";
+  const providerName = _optionalChain([provider, 'optionalAccess', _187 => _187.name, 'optionalAccess', _188 => _188.toLowerCase, 'call', _189 => _189()]) || "";
   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);
@@ -2981,7 +4734,7 @@ function logToolFormat(tools, logger) {
       tools: openaiTools.map((t) => t.function.name),
       firstTool: {
         name: firstTool.function.name,
-        description: _optionalChain([firstTool, 'access', _124 => _124.function, 'access', _125 => _125.description, 'optionalAccess', _126 => _126.slice, 'call', _127 => _127(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _190 => _190.function, 'access', _191 => _191.description, 'optionalAccess', _192 => _192.slice, 'call', _193 => _193(0, 100)]),
         parameters: firstTool.function.parameters
       }
     });
@@ -2992,7 +4745,7 @@ function logToolFormat(tools, logger) {
       tools: anthropicTools.map((t) => t.name),
       firstTool: {
         name: firstTool.name,
-        description: _optionalChain([firstTool, 'access', _128 => _128.description, 'optionalAccess', _129 => _129.slice, 'call', _130 => _130(0, 100)]),
+        description: _optionalChain([firstTool, 'access', _194 => _194.description, 'optionalAccess', _195 => _195.slice, 'call', _196 => _196(0, 100)]),
         input_schema: firstTool.input_schema
       }
     });
@@ -3003,9 +4756,9 @@ function logToolFormat(tools, logger) {
       count: allDeclarations.length,
       tools: allDeclarations.map((t) => t.name),
       firstTool: {
-        name: _optionalChain([allDeclarations, 'access', _131 => _131[0], 'optionalAccess', _132 => _132.name]),
-        description: _optionalChain([allDeclarations, 'access', _133 => _133[0], 'optionalAccess', _134 => _134.description, 'optionalAccess', _135 => _135.slice, 'call', _136 => _136(0, 100)]),
-        parameters: _optionalChain([allDeclarations, 'access', _137 => _137[0], 'optionalAccess', _138 => _138.parameters])
+        name: _optionalChain([allDeclarations, 'access', _197 => _197[0], 'optionalAccess', _198 => _198.name]),
+        description: _optionalChain([allDeclarations, 'access', _199 => _199[0], 'optionalAccess', _200 => _200.description, 'optionalAccess', _201 => _201.slice, 'call', _202 => _202(0, 100)]),
+        parameters: _optionalChain([allDeclarations, 'access', _203 => _203[0], 'optionalAccess', _204 => _204.parameters])
       }
     });
   }
@@ -3064,7 +4817,7 @@ function buildToolRequest(apiFormat, conversationMessages, actualModel, options,
 function extractDeltaContent(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _139 => _139.candidates, 'optionalAccess', _140 => _140[0], 'optionalAccess', _141 => _141.content, 'optionalAccess', _142 => _142.parts]) || [];
+    const parts = _optionalChain([json, 'access', _205 => _205.candidates, 'optionalAccess', _206 => _206[0], 'optionalAccess', _207 => _207.content, 'optionalAccess', _208 => _208.parts]) || [];
     let text = "";
     for (const part of parts) {
       if (part.thought === true) continue;
@@ -3072,15 +4825,15 @@ function extractDeltaContent(rawJson, apiFormat) {
     }
     return text;
   } else if (apiFormat === "anthropic") {
-    return _optionalChain([json, 'access', _143 => _143.delta, 'optionalAccess', _144 => _144.text]) || "";
+    return _optionalChain([json, 'access', _209 => _209.delta, 'optionalAccess', _210 => _210.text]) || "";
   } else {
-    return _optionalChain([json, 'access', _145 => _145.choices, 'optionalAccess', _146 => _146[0], 'optionalAccess', _147 => _147.delta, 'optionalAccess', _148 => _148.content]) || "";
+    return _optionalChain([json, 'access', _211 => _211.choices, 'optionalAccess', _212 => _212[0], 'optionalAccess', _213 => _213.delta, 'optionalAccess', _214 => _214.content]) || "";
   }
 }
 function extractDeltaReasoning(rawJson, apiFormat) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _149 => _149.candidates, 'optionalAccess', _150 => _150[0], 'optionalAccess', _151 => _151.content, 'optionalAccess', _152 => _152.parts]) || [];
+    const parts = _optionalChain([json, 'access', _215 => _215.candidates, 'optionalAccess', _216 => _216[0], 'optionalAccess', _217 => _217.content, 'optionalAccess', _218 => _218.parts]) || [];
     let reasoning = "";
     for (const part of parts) {
       if (part.thought === true && part.text) reasoning += part.text;
@@ -3089,14 +4842,14 @@ function extractDeltaReasoning(rawJson, apiFormat) {
   } else if (apiFormat === "anthropic") {
     return "";
   } else {
-    const delta = _optionalChain([json, 'access', _153 => _153.choices, 'optionalAccess', _154 => _154[0], 'optionalAccess', _155 => _155.delta]);
-    return (_optionalChain([delta, 'optionalAccess', _156 => _156.thinking, 'optionalAccess', _157 => _157.content]) || "") + (_optionalChain([delta, 'optionalAccess', _158 => _158.reasoning_content]) || "");
+    const delta = _optionalChain([json, 'access', _219 => _219.choices, 'optionalAccess', _220 => _220[0], 'optionalAccess', _221 => _221.delta]);
+    return (_optionalChain([delta, 'optionalAccess', _222 => _222.thinking, 'optionalAccess', _223 => _223.content]) || "") + (_optionalChain([delta, 'optionalAccess', _224 => _224.reasoning_content]) || "");
   }
 }
 function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pendingOpenAIToolCalls) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const parts = _optionalChain([json, 'access', _159 => _159.candidates, 'optionalAccess', _160 => _160[0], 'optionalAccess', _161 => _161.content, 'optionalAccess', _162 => _162.parts]) || [];
+    const parts = _optionalChain([json, 'access', _225 => _225.candidates, 'optionalAccess', _226 => _226[0], 'optionalAccess', _227 => _227.content, 'optionalAccess', _228 => _228.parts]) || [];
     for (const part of parts) {
       if (part.functionCall) {
         logger.info("Function call detected", { functionCall: part.functionCall });
@@ -3106,13 +4859,13 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           args: part.functionCall.args || {}
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _163 => _163.onToolCall, 'optionalCall', _164 => _164(toolCall)]);
+        _optionalChain([callbacks, 'access', _229 => _229.onToolCall, 'optionalCall', _230 => _230(toolCall)]);
         logger.info("Tool called", { toolName: toolCall.name });
       }
     }
   } else if (apiFormat !== "anthropic") {
-    const delta = _optionalChain([json, 'access', _165 => _165.choices, 'optionalAccess', _166 => _166[0], 'optionalAccess', _167 => _167.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _168 => _168.tool_calls]) && pendingOpenAIToolCalls) {
+    const delta = _optionalChain([json, 'access', _231 => _231.choices, 'optionalAccess', _232 => _232[0], 'optionalAccess', _233 => _233.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _234 => _234.tool_calls]) && pendingOpenAIToolCalls) {
       for (const tc of delta.tool_calls) {
         const index = _nullishCoalesce(tc.index, () => ( 0));
         let pending = pendingOpenAIToolCalls.get(index);
@@ -3121,8 +4874,8 @@ function extractToolCalls(rawJson, apiFormat, toolCalls, callbacks, logger, pend
           pendingOpenAIToolCalls.set(index, pending);
         }
         if (tc.id) pending.id = tc.id;
-        if (_optionalChain([tc, 'access', _169 => _169.function, 'optionalAccess', _170 => _170.name])) pending.name += tc.function.name;
-        if (_optionalChain([tc, 'access', _171 => _171.function, 'optionalAccess', _172 => _172.arguments])) pending.arguments += tc.function.arguments;
+        if (_optionalChain([tc, 'access', _235 => _235.function, 'optionalAccess', _236 => _236.name])) pending.name += tc.function.name;
+        if (_optionalChain([tc, 'access', _237 => _237.function, 'optionalAccess', _238 => _238.arguments])) pending.arguments += tc.function.arguments;
       }
     }
   }
@@ -3137,7 +4890,7 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
           args: JSON.parse(pending.arguments || "{}")
         };
         toolCalls.push(toolCall);
-        _optionalChain([callbacks, 'access', _173 => _173.onToolCall, 'optionalCall', _174 => _174(toolCall)]);
+        _optionalChain([callbacks, 'access', _239 => _239.onToolCall, 'optionalCall', _240 => _240(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, {
@@ -3151,38 +4904,38 @@ function finalizeOpenAIToolCalls(pendingOpenAIToolCalls, toolCalls, callbacks, l
 function parseStreamChunk(rawJson, apiFormat, callbacks, logger) {
   const json = rawJson;
   if (apiFormat === "google") {
-    const candidate = _optionalChain([json, 'access', _175 => _175.candidates, 'optionalAccess', _176 => _176[0]]);
+    const candidate = _optionalChain([json, 'access', _241 => _241.candidates, 'optionalAccess', _242 => _242[0]]);
     if (!candidate) {
       logger.warn("No candidate found in Gemini response");
       return;
     }
-    const parts = _optionalChain([candidate, 'access', _177 => _177.content, 'optionalAccess', _178 => _178.parts]) || [];
+    const parts = _optionalChain([candidate, 'access', _243 => _243.content, 'optionalAccess', _244 => _244.parts]) || [];
     for (const part of parts) {
       if (part.thought === true && part.text) {
-        _optionalChain([callbacks, 'access', _179 => _179.onReasoning, 'optionalCall', _180 => _180(part.text)]);
+        _optionalChain([callbacks, 'access', _245 => _245.onReasoning, 'optionalCall', _246 => _246(part.text)]);
         continue;
       } else if (part.thoughtSignature && !part.thought) {
         logger.debug("Gemini returned thoughtSignature without thought content");
       }
       if (part.text) {
-        _optionalChain([callbacks, 'access', _181 => _181.onDelta, 'optionalCall', _182 => _182(part.text)]);
+        _optionalChain([callbacks, 'access', _247 => _247.onDelta, 'optionalCall', _248 => _248(part.text)]);
       }
     }
   } else if (apiFormat === "anthropic") {
     const delta = json.delta;
-    if (_optionalChain([delta, 'optionalAccess', _183 => _183.text])) {
-      _optionalChain([callbacks, 'access', _184 => _184.onDelta, 'optionalCall', _185 => _185(delta.text)]);
+    if (_optionalChain([delta, 'optionalAccess', _249 => _249.text])) {
+      _optionalChain([callbacks, 'access', _250 => _250.onDelta, 'optionalCall', _251 => _251(delta.text)]);
     }
   } else {
-    const delta = _optionalChain([json, 'access', _186 => _186.choices, 'optionalAccess', _187 => _187[0], 'optionalAccess', _188 => _188.delta]);
-    if (_optionalChain([delta, 'optionalAccess', _189 => _189.content])) {
-      _optionalChain([callbacks, 'access', _190 => _190.onDelta, 'optionalCall', _191 => _191(delta.content)]);
+    const delta = _optionalChain([json, 'access', _252 => _252.choices, 'optionalAccess', _253 => _253[0], 'optionalAccess', _254 => _254.delta]);
+    if (_optionalChain([delta, 'optionalAccess', _255 => _255.content])) {
+      _optionalChain([callbacks, 'access', _256 => _256.onDelta, 'optionalCall', _257 => _257(delta.content)]);
     }
-    if (_optionalChain([delta, 'optionalAccess', _192 => _192.thinking, 'optionalAccess', _193 => _193.content])) {
-      _optionalChain([callbacks, 'access', _194 => _194.onReasoning, 'optionalCall', _195 => _195(delta.thinking.content)]);
+    if (_optionalChain([delta, 'optionalAccess', _258 => _258.thinking, 'optionalAccess', _259 => _259.content])) {
+      _optionalChain([callbacks, 'access', _260 => _260.onReasoning, 'optionalCall', _261 => _261(delta.thinking.content)]);
     }
-    if (_optionalChain([delta, 'optionalAccess', _196 => _196.reasoning_content])) {
-      _optionalChain([callbacks, 'access', _197 => _197.onReasoning, 'optionalCall', _198 => _198(delta.reasoning_content)]);
+    if (_optionalChain([delta, 'optionalAccess', _262 => _262.reasoning_content])) {
+      _optionalChain([callbacks, 'access', _263 => _263.onReasoning, 'optionalCall', _264 => _264(delta.reasoning_content)]);
     }
   }
 }
@@ -3195,7 +4948,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content: reasoning
     };
     blocks.push(thinkingBlock);
-    _optionalChain([callbacks, 'access', _199 => _199.onBlock, 'optionalCall', _200 => _200(thinkingBlock)]);
+    _optionalChain([callbacks, 'access', _265 => _265.onBlock, 'optionalCall', _266 => _266(thinkingBlock)]);
   }
   if (content && content.trim()) {
     const textBlock = {
@@ -3204,7 +4957,7 @@ function buildIterationBlocks(iteration, content, reasoning, blocks, callbacks)
       content
     };
     blocks.push(textBlock);
-    _optionalChain([callbacks, 'access', _201 => _201.onBlock, 'optionalCall', _202 => _202(textBlock)]);
+    _optionalChain([callbacks, 'access', _267 => _267.onBlock, 'optionalCall', _268 => _268(textBlock)]);
   }
 }
 async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbacks, logger, builtinExecutor) {
@@ -3219,7 +4972,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
       status: "running"
     };
     blocks.push(toolUseBlock);
-    _optionalChain([callbacks, 'access', _203 => _203.onBlock, 'optionalCall', _204 => _204(toolUseBlock)]);
+    _optionalChain([callbacks, 'access', _269 => _269.onBlock, 'optionalCall', _270 => _270(toolUseBlock)]);
     try {
       logger.info("Executing tool", { toolName: toolCall.name });
       const mcpTool = mcpTools.find((t) => t.id === toolCall.name);
@@ -3242,8 +4995,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', _205 => _205.onToolResult, 'optionalCall', _206 => _206(toolCall.id, result)]);
-      const resultText = _optionalChain([result, 'access', _207 => _207.content, 'optionalAccess', _208 => _208[0], 'optionalAccess', _209 => _209.text]) || JSON.stringify(result);
+      _optionalChain([callbacks, 'access', _271 => _271.onToolResult, 'optionalCall', _272 => _272(toolCall.id, result)]);
+      const resultText = _optionalChain([result, 'access', _273 => _273.content, 'optionalAccess', _274 => _274[0], 'optionalAccess', _275 => _275.text]) || JSON.stringify(result);
       const toolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -3253,11 +5006,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: result.isError
       };
       blocks.push(toolResultBlock);
-      _optionalChain([callbacks, 'access', _210 => _210.onBlock, 'optionalCall', _211 => _211(toolResultBlock)]);
+      _optionalChain([callbacks, 'access', _276 => _276.onBlock, 'optionalCall', _277 => _277(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', _212 => _212.onBlock, 'optionalCall', _213 => _213({ ...toolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _278 => _278.onBlock, 'optionalCall', _279 => _279({ ...toolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result });
     } catch (error) {
@@ -3267,7 +5020,7 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true,
         content: [{ type: "text", text: `Error: ${errorMessage}` }]
       };
-      _optionalChain([callbacks, 'access', _214 => _214.onToolResult, 'optionalCall', _215 => _215(toolCall.id, errorResult)]);
+      _optionalChain([callbacks, 'access', _280 => _280.onToolResult, 'optionalCall', _281 => _281(toolCall.id, errorResult)]);
       const errorToolResultBlock = {
         id: `${toolCall.id}_result`,
         type: "tool_result",
@@ -3277,11 +5030,11 @@ async function executeToolCalls(toolCalls, mcpTools, mcpService, blocks, callbac
         isError: true
       };
       blocks.push(errorToolResultBlock);
-      _optionalChain([callbacks, 'access', _216 => _216.onBlock, 'optionalCall', _217 => _217(errorToolResultBlock)]);
+      _optionalChain([callbacks, 'access', _282 => _282.onBlock, 'optionalCall', _283 => _283(errorToolResultBlock)]);
       const errorToolUseBlockRef = blocks.find((b) => b.id === `${toolCall.id}_use`);
       if (errorToolUseBlockRef && errorToolUseBlockRef.type === "tool_use") {
         errorToolUseBlockRef.status = "error";
-        _optionalChain([callbacks, 'access', _218 => _218.onBlock, 'optionalCall', _219 => _219({ ...errorToolUseBlockRef })]);
+        _optionalChain([callbacks, 'access', _284 => _284.onBlock, 'optionalCall', _285 => _285({ ...errorToolUseBlockRef })]);
       }
       toolResults.push({ toolCall, result: errorResult });
     }
@@ -3291,7 +5044,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', _220 => _220.properties])) {
+  if (_optionalChain([toolSchema, 'optionalAccess', _286 => _286.properties])) {
     const expectedParams = Object.keys(toolSchema.properties);
     const paramMappings = {
       "search_query": ["query", "q", "searchQuery", "search"],
@@ -3325,25 +5078,25 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _221 => _221.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _222 => _222.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _287 => _287.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _288 => _288.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _223 => _223.onError, 'optionalCall', _224 => _224(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _289 => _289.onError, 'optionalCall', _290 => _290(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _225 => _225.onError, 'optionalCall', _226 => _226(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _291 => _291.onError, 'optionalCall', _292 => _292(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _227 => _227.onError, 'optionalCall', _228 => _228("API key not configured")]);
+      _optionalChain([callbacks, 'access', _293 => _293.onError, 'optionalCall', _294 => _294("API key not configured")]);
       return;
     }
     const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    _optionalChain([callbacks, 'access', _229 => _229.onStart, 'optionalCall', _230 => _230(messageId)]);
+    _optionalChain([callbacks, 'access', _295 => _295.onStart, 'optionalCall', _296 => _296(messageId)]);
     const globalParams = await llmConfig.getGlobalModelParameters();
     const MAX_ITERATIONS = _nullishCoalesce(globalParams.toolMaxTurns, () => ( 100));
     let iteration = 0;
@@ -3375,9 +5128,9 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
         provider
       );
       if (options.nativeSearchAugmentation) {
-        _chunkV5KPWNYXcjs.applyAugmentation.call(void 0, requestBody, options.nativeSearchAugmentation);
+        _chunkJMJBSACDcjs.applyAugmentation.call(void 0, requestBody, options.nativeSearchAugmentation);
       }
-      const headers = _chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey);
+      const headers = _chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey);
       logger.info("Sending tool call request", {
         url,
         headers,
@@ -3390,12 +5143,12 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
       });
       if (!response.ok) {
         const errorText = await response.text();
-        _optionalChain([callbacks, 'access', _231 => _231.onError, 'optionalCall', _232 => _232(`API error (${response.status}): ${errorText}`)]);
+        _optionalChain([callbacks, 'access', _297 => _297.onError, 'optionalCall', _298 => _298(`API error (${response.status}): ${errorText}`)]);
         return;
       }
-      const reader = _optionalChain([response, 'access', _233 => _233.body, 'optionalAccess', _234 => _234.getReader, 'call', _235 => _235()]);
+      const reader = _optionalChain([response, 'access', _299 => _299.body, 'optionalAccess', _300 => _300.getReader, 'call', _301 => _301()]);
       if (!reader) {
-        _optionalChain([callbacks, 'access', _236 => _236.onError, 'optionalCall', _237 => _237("No response body")]);
+        _optionalChain([callbacks, 'access', _302 => _302.onError, 'optionalCall', _303 => _303("No response body")]);
         return;
       }
       const decoder = new TextDecoder();
@@ -3428,7 +5181,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', _238 => _238.onError, 'optionalCall', _239 => _239(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
+                  _optionalChain([callbacks, 'access', _304 => _304.onError, 'optionalCall', _305 => _305(`API Error: ${json.error.message || JSON.stringify(json.error)}`)]);
                   return;
                 }
                 parseStreamChunk(json, apiFormat, callbacks, logger);
@@ -3461,7 +5214,7 @@ async function streamWithTools(options, callbacks, mcpService, llmConfig, getPro
           toolCallsLength: toolCalls.length,
           executableToolCallsLength: executableToolCalls.length,
           hasMcpTools: !!options.mcpTools,
-          mcpToolsLength: _optionalChain([options, 'access', _240 => _240.mcpTools, 'optionalAccess', _241 => _241.length]),
+          mcpToolsLength: _optionalChain([options, 'access', _306 => _306.mcpTools, 'optionalAccess', _307 => _307.length]),
           hasMcpService: !!mcpService
         });
         if (executableToolCalls.length > 0 && options.mcpTools && (mcpService || builtinExecutor)) {
@@ -3482,7 +5235,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', _242 => _242.content, 'optionalAccess', _243 => _243[0], 'optionalAccess', _244 => _244.text]) || JSON.stringify(result);
+            const resultText = typeof result === "string" ? result : _optionalChain([result, 'access', _308 => _308.content, 'optionalAccess', _309 => _309[0], 'optionalAccess', _310 => _310.text]) || JSON.stringify(result);
             return `Tool ${toolCall.name} result:
 ${resultText}`;
           }).join("\n\n");
@@ -3500,12 +5253,12 @@ ${resultText}`;
         }
       } catch (streamError) {
         logger.error("Stream processing error", streamError instanceof Error ? streamError : void 0);
-        _optionalChain([callbacks, 'access', _245 => _245.onError, 'optionalCall', _246 => _246(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
+        _optionalChain([callbacks, 'access', _311 => _311.onError, 'optionalCall', _312 => _312(`Stream error: ${streamError instanceof Error ? streamError.message : "Unknown error"}`)]);
         return;
       }
     }
     logger.info("Sending final callback", { blocksCount: blocks.length });
-    _optionalChain([callbacks, 'access', _247 => _247.onDone, 'optionalCall', _248 => _248({
+    _optionalChain([callbacks, 'access', _313 => _313.onDone, 'optionalCall', _314 => _314({
       id: messageId,
       role: "assistant",
       content: finalContent,
@@ -3516,7 +5269,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', _249 => _249.onError, 'optionalCall', _250 => _250(message)]);
+    _optionalChain([callbacks, 'access', _315 => _315.onError, 'optionalCall', _316 => _316(message)]);
   }
 }
 
@@ -3555,8 +5308,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _251 => _251.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _252 => _252.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _317 => _317.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _318 => _318.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
       return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -3603,9 +5356,9 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       extendedContext: options.useExtendedContext ? { enabled: true, model: actualModel } : void 0,
       resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: actualModel, stream: false }),
       buildHeaders: (config) => ({
-        ..._chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey),
+        ..._chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey),
         ...config.headers,
-        ..._chunk6VIXXLMXcjs.isOpenRouterProvider.call(void 0, provider) ? _chunk6VIXXLMXcjs.OPENROUTER_APP_HEADERS : {}
+        ..._chunkUNEFIWXIcjs.isOpenRouterProvider.call(void 0, provider) ? _chunkUNEFIWXIcjs.OPENROUTER_APP_HEADERS : {}
       }),
       // Add OpenRouter provider routing config if applicable
       prepareBody: (requestBody) => addOpenRouterProviderToRequest(
@@ -3637,18 +5390,18 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       { endpointTransformer: void 0 }
     );
     const data = await transformedResponse.json();
-    const choice = _optionalChain([data, 'access', _253 => _253.choices, 'optionalAccess', _254 => _254[0]]);
+    const choice = _optionalChain([data, 'access', _319 => _319.choices, 'optionalAccess', _320 => _320[0]]);
     if (!choice) {
       return { success: false, error: "No choices in response" };
     }
-    const rawToolCalls = _optionalChain([choice, 'access', _255 => _255.message, 'optionalAccess', _256 => _256.tool_calls]);
-    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _257 => _257.map, 'call', _258 => _258((tc) => ({
+    const rawToolCalls = _optionalChain([choice, 'access', _321 => _321.message, 'optionalAccess', _322 => _322.tool_calls]);
+    const toolCalls = _optionalChain([rawToolCalls, 'optionalAccess', _323 => _323.map, 'call', _324 => _324((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', _259 => _259.recorder]) && tapped) {
+    if (_optionalChain([recording, 'optionalAccess', _325 => _325.recorder]) && tapped) {
       recording.recorder.record({
         messageId: _nullishCoalesce(options.messageId, () => ( null)),
         parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -3666,9 +5419,9 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       message: {
         id: `msg_${Date.now()}`,
         role: "assistant",
-        content: _optionalChain([choice, 'access', _260 => _260.message, 'optionalAccess', _261 => _261.content]) || "",
+        content: _optionalChain([choice, 'access', _326 => _326.message, 'optionalAccess', _327 => _327.content]) || "",
         timestamp: Date.now(),
-        thinking: data.reasoning_content || _optionalChain([choice, 'access', _262 => _262.message, 'optionalAccess', _263 => _263.thinking, 'optionalAccess', _264 => _264.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _265 => _265.message, 'optionalAccess', _266 => _266.thinking, 'optionalAccess', _267 => _267.content]) || "", signature: _optionalChain([choice, 'access', _268 => _268.message, 'optionalAccess', _269 => _269.thinking, 'optionalAccess', _270 => _270.signature]) } : void 0,
+        thinking: data.reasoning_content || _optionalChain([choice, 'access', _328 => _328.message, 'optionalAccess', _329 => _329.thinking, 'optionalAccess', _330 => _330.content]) ? { content: data.reasoning_content || _optionalChain([choice, 'access', _331 => _331.message, 'optionalAccess', _332 => _332.thinking, 'optionalAccess', _333 => _333.content]) || "", signature: _optionalChain([choice, 'access', _334 => _334.message, 'optionalAccess', _335 => _335.thinking, 'optionalAccess', _336 => _336.signature]) } : void 0,
         toolCalls
       },
       usage: data.usage ? {
@@ -3689,21 +5442,21 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       options.providerId,
       options.model
     );
-    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _271 => _271.actualProviderId]) || options.providerId;
-    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _272 => _272.actualModelId]) || options.model;
+    const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _337 => _337.actualProviderId]) || options.providerId;
+    const actualModel = _optionalChain([routedInfo, 'optionalAccess', _338 => _338.actualModelId]) || options.model;
     const provider = await getProvider(actualProviderId);
     if (!provider) {
-      _optionalChain([callbacks, 'access', _273 => _273.onError, 'optionalCall', _274 => _274(`Provider not found: ${actualProviderId}`)]);
+      _optionalChain([callbacks, 'access', _339 => _339.onError, 'optionalCall', _340 => _340(`Provider not found: ${actualProviderId}`)]);
       return;
     }
     if (!provider.enabled) {
-      _optionalChain([callbacks, 'access', _275 => _275.onError, 'optionalCall', _276 => _276(`Provider is disabled: ${provider.name}`)]);
+      _optionalChain([callbacks, 'access', _341 => _341.onError, 'optionalCall', _342 => _342(`Provider is disabled: ${provider.name}`)]);
       return;
     }
     const { apiKey: effectiveKey } = _chunkA2YMUCBTcjs.resolveProviderEndpoint.call(void 0, provider);
     const apiKey = resolveApiKey2(effectiveKey);
     if (!apiKey) {
-      _optionalChain([callbacks, 'access', _277 => _277.onError, 'optionalCall', _278 => _278("API key not configured")]);
+      _optionalChain([callbacks, 'access', _343 => _343.onError, 'optionalCall', _344 => _344("API key not configured")]);
       return;
     }
     const { chain, hasTransformers } = await resolveChainWithMain(
@@ -3715,7 +5468,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       return completeStreamFallback(options, callbacks);
     }
     const messageId = `msg_${Date.now()}`;
-    _optionalChain([callbacks, 'access', _279 => _279.onStart, 'optionalCall', _280 => _280(messageId)]);
+    _optionalChain([callbacks, 'access', _345 => _345.onStart, 'optionalCall', _346 => _346(messageId)]);
     const unifiedRequest = {
       model: actualModel,
       messages: options.messages.map((m) => ({
@@ -3742,9 +5495,9 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       extendedContext: options.useExtendedContext ? { enabled: true, model: actualModel } : void 0,
       resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : _chunkA2YMUCBTcjs.buildProviderApiUrl.call(void 0, provider, { model: actualModel, stream: true }),
       buildHeaders: (config) => ({
-        ..._chunkLKZJEL6Ecjs.getProviderHeaders.call(void 0, provider, apiKey),
+        ..._chunkQ27JY5RGcjs.getProviderHeaders.call(void 0, provider, apiKey),
         ...config.headers,
-        ..._chunk6VIXXLMXcjs.isOpenRouterProvider.call(void 0, provider) ? _chunk6VIXXLMXcjs.OPENROUTER_APP_HEADERS : {}
+        ..._chunkUNEFIWXIcjs.isOpenRouterProvider.call(void 0, provider) ? _chunkUNEFIWXIcjs.OPENROUTER_APP_HEADERS : {}
       }),
       // Add OpenRouter provider routing config if applicable
       prepareBody: (requestBody) => addOpenRouterProviderToRequest(
@@ -3763,7 +5516,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     });
     if (!response.ok) {
       const errorText = await response.text();
-      _optionalChain([callbacks, 'access', _281 => _281.onError, 'optionalCall', _282 => _282(`API error (${response.status}): ${errorText}`)]);
+      _optionalChain([callbacks, 'access', _347 => _347.onError, 'optionalCall', _348 => _348(`API error (${response.status}): ${errorText}`)]);
       return;
     }
     const transformedResponse = await executor.executeResponseChain(
@@ -3773,9 +5526,9 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       chain,
       { endpointTransformer: void 0 }
     );
-    const reader = _optionalChain([transformedResponse, 'access', _283 => _283.body, 'optionalAccess', _284 => _284.getReader, 'call', _285 => _285()]);
+    const reader = _optionalChain([transformedResponse, 'access', _349 => _349.body, 'optionalAccess', _350 => _350.getReader, 'call', _351 => _351()]);
     if (!reader) {
-      _optionalChain([callbacks, 'access', _286 => _286.onError, 'optionalCall', _287 => _287("No response body")]);
+      _optionalChain([callbacks, 'access', _352 => _352.onError, 'optionalCall', _353 => _353("No response body")]);
       return;
     }
     const decoder = new TextDecoder();
@@ -3793,22 +5546,22 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
             if (data === "[DONE]") continue;
             try {
               const json = JSON.parse(data);
-              const delta = _optionalChain([json, 'access', _288 => _288.choices, 'optionalAccess', _289 => _289[0], 'optionalAccess', _290 => _290.delta]);
-              if (_optionalChain([delta, 'optionalAccess', _291 => _291.content])) {
+              const delta = _optionalChain([json, 'access', _354 => _354.choices, 'optionalAccess', _355 => _355[0], 'optionalAccess', _356 => _356.delta]);
+              if (_optionalChain([delta, 'optionalAccess', _357 => _357.content])) {
                 content += delta.content;
-                _optionalChain([callbacks, 'access', _292 => _292.onDelta, 'optionalCall', _293 => _293(delta.content)]);
+                _optionalChain([callbacks, 'access', _358 => _358.onDelta, 'optionalCall', _359 => _359(delta.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _294 => _294.thinking, 'optionalAccess', _295 => _295.content])) {
+              if (_optionalChain([delta, 'optionalAccess', _360 => _360.thinking, 'optionalAccess', _361 => _361.content])) {
                 reasoning += delta.thinking.content;
-                _optionalChain([callbacks, 'access', _296 => _296.onReasoning, 'optionalCall', _297 => _297(delta.thinking.content)]);
+                _optionalChain([callbacks, 'access', _362 => _362.onReasoning, 'optionalCall', _363 => _363(delta.thinking.content)]);
               }
-              if (_optionalChain([delta, 'optionalAccess', _298 => _298.reasoning_content])) {
+              if (_optionalChain([delta, 'optionalAccess', _364 => _364.reasoning_content])) {
                 reasoning += delta.reasoning_content;
-                _optionalChain([callbacks, 'access', _299 => _299.onReasoning, 'optionalCall', _300 => _300(delta.reasoning_content)]);
+                _optionalChain([callbacks, 'access', _365 => _365.onReasoning, 'optionalCall', _366 => _366(delta.reasoning_content)]);
               }
               if (json.usage) {
                 const tapped = readUsageFromOpenAIResponse(json.usage);
-                if (_optionalChain([recording, 'optionalAccess', _301 => _301.recorder]) && tapped) {
+                if (_optionalChain([recording, 'optionalAccess', _367 => _367.recorder]) && tapped) {
                   recording.recorder.record({
                     messageId: _nullishCoalesce(options.messageId, () => ( null)),
                     parentMessageId: _nullishCoalesce(options.parentMessageId, () => ( null)),
@@ -3821,7 +5574,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
                     rawUsage: json.usage
                   });
                 }
-                _optionalChain([callbacks, 'access', _302 => _302.onDone, 'optionalCall', _303 => _303(
+                _optionalChain([callbacks, 'access', _368 => _368.onDone, 'optionalCall', _369 => _369(
                   {
                     id: messageId,
                     role: "assistant",
@@ -3842,7 +5595,7 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
           }
         }
       }
-      _optionalChain([callbacks, 'access', _304 => _304.onDone, 'optionalCall', _305 => _305({
+      _optionalChain([callbacks, 'access', _370 => _370.onDone, 'optionalCall', _371 => _371({
         id: messageId,
         role: "assistant",
         content,
@@ -3854,13 +5607,13 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    _optionalChain([callbacks, 'access', _306 => _306.onError, 'optionalCall', _307 => _307(message)]);
+    _optionalChain([callbacks, 'access', _372 => _372.onError, 'optionalCall', _373 => _373(message)]);
   }
 }
 
 // src/completion/CompletionService.ts
-var CompletionService = (_class5 = class {
-  constructor(paths, llmConfig, logger) {;_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);
+var CompletionService = (_class13 = class {
+  constructor(paths, llmConfig, logger) {;_class13.prototype.__init22.call(this);_class13.prototype.__init23.call(this);_class13.prototype.__init24.call(this);_class13.prototype.__init25.call(this);
     this.paths = paths;
     this.llmConfig = llmConfig;
     this.logger = logger;
@@ -3868,10 +5621,10 @@ var CompletionService = (_class5 = class {
   
   
   
-  __init10() {this.apiKeyPool = null}
-  __init11() {this.usageRecorder = null}
-  __init12() {this.usageEventSink = null}
-  __init13() {this.visionFallbackProvider = null}
+  __init22() {this.apiKeyPool = null}
+  __init23() {this.usageRecorder = null}
+  __init24() {this.usageEventSink = null}
+  __init25() {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.
@@ -3893,8 +5646,8 @@ var CompletionService = (_class5 = class {
    * emission is unconditional in production. Optional — when unset (unit-test
    * constructors), the emit calls no-op, identical to `usageRecorder`.
    */
-  setUsageEventSink(sink) {
-    this.usageEventSink = sink;
+  setUsageEventSink(sink2) {
+    this.usageEventSink = sink2;
   }
   /**
    * Set the vision-fallback provider used by `applyVisionFallback` to describe
@@ -3921,8 +5674,8 @@ var CompletionService = (_class5 = class {
         options.providerId,
         options.model
       );
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _308 => _308.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _309 => _309.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _374 => _374.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _375 => _375.actualModelId]) || options.model;
       const provider = await this.getProvider(actualProviderId);
       if (!provider) {
         return { success: false, error: `Provider not found: ${actualProviderId}` };
@@ -3955,7 +5708,7 @@ var CompletionService = (_class5 = class {
         this.apiKeyPool.reportSuccess(options.sessionId);
       }
       if (result.success && result.usage && options.sessionId) {
-        _optionalChain([this, 'access', _310 => _310.usageEventSink, 'optionalAccess', _311 => _311.emit, 'call', _312 => _312({
+        _optionalChain([this, 'access', _376 => _376.usageEventSink, 'optionalAccess', _377 => _377.emit, 'call', _378 => _378({
           sessionId: options.sessionId,
           modelId: actualModel,
           usage: result.usage,
@@ -3984,8 +5737,8 @@ var CompletionService = (_class5 = class {
         options.model
       );
       this.logger.debug("Resolved routed model", { routedInfo });
-      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _313 => _313.actualProviderId]) || options.providerId;
-      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _314 => _314.actualModelId]) || options.model;
+      const actualProviderId = _optionalChain([routedInfo, 'optionalAccess', _379 => _379.actualProviderId]) || options.providerId;
+      const actualModel = _optionalChain([routedInfo, 'optionalAccess', _380 => _380.actualModelId]) || options.model;
       this.logger.debug("Resolved provider and model", { actualProviderId, actualModel });
       const provider = await this.getProvider(actualProviderId);
       this.logger.debug("Retrieved provider", provider ? {
@@ -3997,22 +5750,22 @@ var CompletionService = (_class5 = class {
         enabled: provider.enabled
       } : { error: "Provider not found" });
       if (!provider) {
-        _optionalChain([callbacks, 'access', _315 => _315.onError, 'optionalCall', _316 => _316(`Provider not found: ${actualProviderId}`)]);
+        _optionalChain([callbacks, 'access', _381 => _381.onError, 'optionalCall', _382 => _382(`Provider not found: ${actualProviderId}`)]);
         return;
       }
       if (!provider.enabled) {
-        _optionalChain([callbacks, 'access', _317 => _317.onError, 'optionalCall', _318 => _318(`Provider is disabled: ${provider.name}`)]);
+        _optionalChain([callbacks, 'access', _383 => _383.onError, 'optionalCall', _384 => _384(`Provider is disabled: ${provider.name}`)]);
         return;
       }
       const apiKey = await this.resolveApiKeyForRequest(provider, actualProviderId, options.sessionId);
       if (!apiKey) {
-        _optionalChain([callbacks, 'access', _319 => _319.onError, 'optionalCall', _320 => _320("API key not configured")]);
+        _optionalChain([callbacks, 'access', _385 => _385.onError, 'optionalCall', _386 => _386("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', _321 => _321.onStart, 'optionalCall', _322 => _322(messageId)]);
+      _optionalChain([callbacks, 'access', _387 => _387.onStart, 'optionalCall', _388 => _388(messageId)]);
       const resolvedOptions = { ...options, model: actualModel };
       if (options.sessionId) {
         const sid = options.sessionId;
@@ -4021,14 +5774,14 @@ var CompletionService = (_class5 = class {
           ...callbacks,
           onDone: (message, usage, metrics) => {
             if (usage) {
-              _optionalChain([this, 'access', _323 => _323.usageEventSink, 'optionalAccess', _324 => _324.emit, 'call', _325 => _325({
+              _optionalChain([this, 'access', _389 => _389.usageEventSink, 'optionalAccess', _390 => _390.emit, 'call', _391 => _391({
                 sessionId: sid,
                 modelId: actualModel,
                 usage,
                 engineOrigin: "completion"
               })]);
             }
-            _optionalChain([userOnDone, 'optionalCall', _326 => _326(message, usage, metrics)]);
+            _optionalChain([userOnDone, 'optionalCall', _392 => _392(message, usage, metrics)]);
           }
         };
       }
@@ -4044,11 +5797,11 @@ var CompletionService = (_class5 = class {
               retryState.error = { status, message: error };
               return;
             }
-            _optionalChain([callbacks, 'access', _327 => _327.onError, 'optionalCall', _328 => _328(error)]);
+            _optionalChain([callbacks, 'access', _393 => _393.onError, 'optionalCall', _394 => _394(error)]);
           },
           onDone: (message, usage, metrics) => {
             this.apiKeyPool.reportSuccess(options.sessionId);
-            _optionalChain([callbacks, 'access', _329 => _329.onDone, 'optionalCall', _330 => _330(message, usage, metrics)]);
+            _optionalChain([callbacks, 'access', _395 => _395.onDone, 'optionalCall', _396 => _396(message, usage, metrics)]);
           }
         };
         await this.callStreamHandler(apiFormat, provider, apiKey, resolvedOptions, messageId, interceptCallbacks);
@@ -4069,7 +5822,7 @@ var CompletionService = (_class5 = class {
               // don't fire onStart again
             });
           } else {
-            _optionalChain([callbacks, 'access', _331 => _331.onError, 'optionalCall', _332 => _332(retryState.error.message)]);
+            _optionalChain([callbacks, 'access', _397 => _397.onError, 'optionalCall', _398 => _398(retryState.error.message)]);
           }
         }
       } else {
@@ -4082,7 +5835,7 @@ var CompletionService = (_class5 = 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', _333 => _333.onError, 'optionalCall', _334 => _334(message)]);
+      _optionalChain([callbacks, 'access', _399 => _399.onError, 'optionalCall', _400 => _400(message)]);
     }
   }
   /**
@@ -4122,7 +5875,7 @@ var CompletionService = (_class5 = class {
         return {
           success: true,
           message: "Connection successful",
-          response: _optionalChain([result, 'access', _335 => _335.message, 'optionalAccess', _336 => _336.content]) || "",
+          response: _optionalChain([result, 'access', _401 => _401.message, 'optionalAccess', _402 => _402.content]) || "",
           model: modelId,
           durationMs
         };
@@ -4187,7 +5940,7 @@ ${description}`;
    * 3. Legacy single key from provider config
    */
   async resolveApiKeyForRequest(provider, providerId, sessionId) {
-    if (_optionalChain([provider, 'access', _337 => _337.codingPlan, 'optionalAccess', _338 => _338.enabled]) && provider.codingPlan.apiKey) {
+    if (_optionalChain([provider, 'access', _403 => _403.codingPlan, 'optionalAccess', _404 => _404.enabled]) && provider.codingPlan.apiKey) {
       return this.resolveApiKey(provider.codingPlan.apiKey);
     }
     if (this.apiKeyPool) {
@@ -4352,7 +6105,50 @@ ${description}`;
       builtinExecutor
     );
   }
-}, _class5);
+}, _class13);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -4397,4 +6193,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.writeError = writeError; exports.resolvePoolBoundKey = resolvePoolBoundKey; exports.extractRouteToken = extractRouteToken; exports.isLoopbackAddress = isLoopbackAddress; exports.ProviderProxy = ProviderProxy; exports.getProviderProxy = getProviderProxy; exports.__resetProviderProxyForTests = __resetProviderProxyForTests; exports.hashKey = hashKey; exports.createNamedKey = createNamedKey; exports.verifyPresentedKey = verifyPresentedKey; exports.detectRequestRole = detectRequestRole; exports.endpointToIngressFormat = endpointToIngressFormat; exports.OutboundRateLimiter = OutboundRateLimiter; exports.DEFAULT_OUTBOUND_PORT = DEFAULT_OUTBOUND_PORT; exports.OutboundApiServer = OutboundApiServer; exports.formatUrls = formatUrls; exports.OUTBOUND_API_SERVER_CONFIG_KEY = OUTBOUND_API_SERVER_CONFIG_KEY; exports.defaultServerConfig = defaultServerConfig; exports.normalizeServerConfig = normalizeServerConfig; exports.loadServerConfig = loadServerConfig; exports.saveServerConfig = saveServerConfig; exports.mergeServerConfig = mergeServerConfig; 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.writeError = writeError; 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.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.defaultServerConfig = defaultServerConfig; exports.normalizeServerConfig = normalizeServerConfig; exports.loadServerConfig = loadServerConfig; exports.saveServerConfig = saveServerConfig; exports.mergeServerConfig = mergeServerConfig; exports.AUDIT_REDACTED = AUDIT_REDACTED; exports.redactAuditText = redactAuditText; exports.beginAuditCapture = beginAuditCapture; exports.beginBillingCapture = beginBillingCapture; exports.computeKeyExpiry = computeKeyExpiry; exports.checkKeyQuota = checkKeyQuota; exports.randomBase62 = randomBase62; exports.hashKey = hashKey; exports.createNamedKey = createNamedKey; 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.OutboundApiConfigError = OutboundApiConfigError; exports.OutboundApiServer = OutboundApiServer; exports.formatUrls = formatUrls; exports.startOfLocalDay = startOfLocalDay; exports.startOfLocalWeek = startOfLocalWeek; exports.KeySpendTracker = KeySpendTracker; exports.getOutboundApiServer = getOutboundApiServer; exports.__resetOutboundApiServerForTests = __resetOutboundApiServerForTests;