@omnicross/core 0.1.2 → 0.1.4

package/dist/{chunk-2FEVTJWG.js → chunk-QYTT6GE3.js}

@@ -1,9 +1,15 @@
-import {
-  collectMatchText
-} from "./chunk-QOCNX236.js";
 import {
   streamSSEResponse
 } from "./chunk-VVEHS2LI.js";
+import {
+  AnthropicTransformer
+} from "./chunk-FTQ7IQUC.js";
+import {
+  GeminiTransformer
+} from "./chunk-C7PSERMH.js";
+import {
+  OpenAIResponseTransformer
+} from "./chunk-TIER4SUC.js";
 import {
   TransformerChainExecutor
 } from "./chunk-G2UTNSGU.js";
@@ -11,58 +17,87 @@ import {
   injectExtendedContextBeta
 } from "./chunk-MZNPGW5Q.js";
 import {
-  GeminiTransformer
-} from "./chunk-C7PSERMH.js";
+  getSharedIdentityStore
+} from "./chunk-XTEI64OU.js";
 import {
-  OpenAIResponseTransformer
-} from "./chunk-5HTVET6E.js";
+  applyFingerprint,
+  captureCallerIdentity
+} from "./chunk-XX6NQJMA.js";
 import {
-  AnthropicTransformer
-} from "./chunk-FTQ7IQUC.js";
+  collectMatchText,
+  deriveSubscriptionSessionKey
+} from "./chunk-IAXWICZU.js";
+import {
+  emitWebhookEvent
+} from "./chunk-OE6TDIWW.js";
 import {
   getGeminiCodeAssistResolver
 } from "./chunk-DRWHTIIZ.js";
 import {
   executeProviderCall
-} from "./chunk-JO5NLTLY.js";
+} from "./chunk-IK3KE3AU.js";
 import {
   LlmConfigProviderAuth,
   getProviderHeaders
-} from "./chunk-PXUJF5HS.js";
+} from "./chunk-ZY6KU6P3.js";
 import {
   resolveProviderChain
 } from "./chunk-JWC6APFQ.js";
 import {
   resolveSubscriptionChain
 } from "./chunk-5ERIZW3D.js";
+import {
+  getSharedAccountHealth,
+  resolveResetSeconds
+} from "./chunk-5ENKBSWO.js";
 import {
   SubscriptionAuthSource
-} from "./chunk-74TMJA7Z.js";
+} from "./chunk-HRRYG2AX.js";
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
+import {
+  beginBillingCapture
+} from "./chunk-WLYIIEAF.js";
+import {
+  computeQuotaWarnings,
+  markQuotaWarnedOnce
+} from "./chunk-3QFXFCHG.js";
+import {
+  detectRequestRole,
+  endpointToIngressFormat,
+  extractRequestedModel,
+  isKindMappedEndpoint,
+  modelKindsForEndpoint,
+  parseModelRef,
+  resolveRoute,
+  validateServerModelConfig
+} from "./chunk-UHGVBFU3.js";
 import {
   buildProviderApiUrl,
   resolveApiFormat,
   resolveProviderEndpoint
 } from "./chunk-H5JUT3KV.js";
 import {
-  resolveRoute
-} from "./chunk-3MEACFK3.js";
+  beginAuditCapture
+} from "./chunk-7Y47UCF2.js";
 import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
 } from "./chunk-5ZQBEOMD.js";
 import {
-  applyAugmentation
-} from "./chunk-745DV5FL.js";
+  fetchUpstream
+} from "./chunk-XK5CIRMQ.js";
 import {
-  OPENROUTER_APP_HEADERS,
-  isOpenRouterProvider
-} from "./chunk-E3WHL7CO.js";
+  applyAugmentation
+} from "./chunk-Y7FO65VT.js";
 import {
   NATIVE_SEARCH_TOOL_NAMES
 } from "./chunk-FMOBD2OQ.js";
+import {
+  OPENROUTER_APP_HEADERS,
+  isOpenRouterProvider
+} from "./chunk-HUZZZ3JL.js";
 
 // src/completion/StreamEventBuffer.ts
 var TERMINAL_TYPES = /* @__PURE__ */ new Set(["done", "error", "abort"]);
@@ -462,10 +497,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 {
   }
@@ -502,7 +538,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 {
+    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 {
+    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 = providerResponse.headers.get("Content-Type") ?? "";
   const status = providerResponse.status && providerResponse.status >= 100 ? providerResponse.status : 200;
   if (isStream || contentType.includes("text/event-stream")) {
@@ -515,6 +628,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 +646,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,14 +686,15 @@ 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 = deriveSubscriptionSessionKey(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 = profile.resolveUpstreamUrl?.(resolvedModel, route.subscriptionConfig);
   if (!upstreamUrl) return null;
   const auth = route.auth ?? new SubscriptionAuthSource(profile);
@@ -598,6 +717,7 @@ function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isS
   };
   return {
     auth,
+    preferredAccountId: route.preferredAccountId,
     chain,
     transformerProvider,
     resolvedModel,
@@ -622,7 +742,8 @@ function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isS
     upstreamUrl,
     sameFormat,
     isSubscription: true,
-    scenario
+    scenario,
+    sessionKey
   };
 }
 function usesResponsesChain(names) {
@@ -657,12 +778,25 @@ 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,
+    preferredAccountId: plan.preferredAccountId,
+    reportSelection: (accountId, isActive) => {
+      proxyAccountId = accountId;
+      reportSelection?.(accountId, isActive);
+    }
+  });
   let rawStatus = null;
   const { response } = await executeProviderCall({
     executor,
@@ -682,7 +816,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 fetchUpstream(
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: proxyProviderId(plan), accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -691,29 +829,96 @@ 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,
+    preferredAccountId: plan.preferredAccountId,
+    reportSelection: (accountId, isActive, remapped) => {
+      proxyAccountId = accountId;
+      remappedModel = remapped;
+      reportSelection?.(accountId, isActive, remapped);
+    }
   });
+  if (plan.isSubscription && plan.transformerProvider.name === "claude") {
+    applyFingerprint(
+      getSharedIdentityStore(),
+      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 fetchUpstream(
+    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 {
+    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 plan.auth.onUnauthorized?.();
-  if (!refreshed) {
-    console.warn("[ProviderProxy:anthropic] 401 not recoverable (onUnauthorized returned false)");
-    return first;
+  let result = first;
+  if (first.rawStatus === 401) {
+    const refreshed = await plan.auth.onUnauthorized?.(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)");
+    }
+  }
+  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 {
+    return void 0;
   }
-  console.info("[ProviderProxy:anthropic] 401 \u2192 token refreshed; retrying once");
-  return runOnce();
+}
+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 } = resolveResetSeconds(providerId, result.response.headers);
+  const bodyText = status === 403 ? await readBoundedBody(result.response) : void 0;
+  getSharedAccountHealth().recordUpstreamOutcome(providerId, selectedAccountId, {
+    status,
+    resetHeaderSeconds,
+    retryAfterSeconds,
+    bodyText
+  });
 }
 function isFallbackEligibleStatus(rawStatus) {
   return rawStatus === null || rawStatus >= 500 || rawStatus === 429;
@@ -728,9 +933,9 @@ function recordBreakerOutcome(profile, modelId, rawStatus) {
   if (outcome === "neutral") return;
   profile?.recordModelOutcome?.(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 +947,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 (!profile?.nextFallback || scenario === void 0) {
-    const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan);
+    const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan, options);
     recordBreakerOutcome(profile, initialPlan.resolvedModel, outcomeStatus(loneOutcome));
     return settleOutcome(loneOutcome);
   }
@@ -757,7 +962,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 +977,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 +990,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 +1002,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);
@@ -819,13 +1025,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: route.providerId ?? "anthropic",
-        model: plan.resolvedModel
+        model: plan.resolvedModel,
+        apiKeyId: route.apiKeyId ?? null,
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -881,7 +1090,7 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     extendedContextEnabled: route.anthropicSdkHints?.extendedContext?.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");
@@ -902,11 +1111,26 @@ async function runSameFormatFetch(rawBody, plan, options, keyOverride) {
   injectExtendedContextBeta(headers, resolvedModel, extendedContextEnabled ?? false);
   const url = buildProviderApiUrl(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 fetchUpstream(
+    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 {
+    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 plan.auth.onResult?.(first.rawStatus);
   if (outcome?.rebound) {
@@ -930,7 +1154,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 = captureCallerIdentity(getSharedIdentityStore(), req.headers);
+    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta, callerIdentity });
     return;
   }
   const hints = route.anthropicSdkHints;
@@ -992,7 +1217,8 @@ 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
@@ -1042,7 +1268,10 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
       recordGeminiNonStreamUsage(deps.usageRecorder, bodyText, {
         sessionId: route.sessionId,
         providerId: route.providerId ?? "gemini",
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: route.apiKeyId ?? null,
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1117,7 +1346,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 fetchUpstream(
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: "byo" }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1169,7 +1402,8 @@ 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
@@ -1184,6 +1418,8 @@ function isOpenAIChatRequest(method, url) {
   const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
   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 {
@@ -1192,23 +1428,22 @@ async function handleOpenAIChatRequest(res, rawBody, route, deps) {
     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: route.providerId ?? "openai",
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: route.apiKeyId ?? null,
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1255,14 +1490,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 = profile.resolveUpstreamUrl?.(resolvedModel);
+  if (!upstreamUrl) {
+    writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
+    return null;
+  }
+  const auth = route.auth ?? new SubscriptionAuthSource(profile);
+  const chain = resolveSubscriptionChain(
+    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 executeProviderCall({
     executor,
@@ -1281,7 +1569,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 fetchUpstream(
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1303,6 +1595,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 plan.auth.onUnauthorized?.();
+  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,7 +1636,8 @@ 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
@@ -1360,15 +1664,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: route.providerId ?? "codex",
-        model: resolvedModel
+        model: resolvedModel,
+        apiKeyId: route.apiKeyId ?? null,
+        // request-audit-log: correlate this request's tokens/cost to its audit record.
+        auditResponse: res
       });
     }
   } catch (err) {
@@ -1415,10 +1722,11 @@ 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");
@@ -1451,6 +1759,7 @@ async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream)
   }
   return {
     auth,
+    preferredAccountId: route.preferredAccountId,
     chain,
     transformerProvider,
     resolvedModel,
@@ -1459,7 +1768,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 +1786,16 @@ 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,
+    preferredAccountId: plan.preferredAccountId,
+    reportSelection: (accountId) => {
+      proxyAccountId = accountId;
+    }
+  });
   let rawStatus = null;
   const { response } = await executeProviderCall({
     executor,
@@ -1497,7 +1815,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 fetchUpstream(
+        url,
+        { method: "POST", headers, body: JSON.stringify(body) },
+        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+      ).then((r) => {
         rawStatus = r.status;
         return r;
       });
@@ -1519,7 +1841,7 @@ 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 plan.auth.onUnauthorized?.();
@@ -1696,12 +2018,439 @@ function __resetProviderProxyForTests() {
 // src/outbound-api/OutboundApiServer.ts
 import http2 from "http";
 import { networkInterfaces } from "os";
+import { healthHttpStatus } from "@omnicross/contracts/health-logging-types";
+
+// src/outbound-api/keyedMutex.ts
+var KeyedMutex = class {
+  /** key → the tail of the pending-op chain (resolves when the last op frees). */
+  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 = 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);
+    }
+  }
+};
 
 // src/outbound-api/outboundApiRouter.ts
 import { Readable } from "stream";
 
+// src/outbound-api/apiServerConfig.ts
+import { DEFAULT_AUDIT_CONFIG } from "@omnicross/contracts/audit-types";
+import { DEFAULT_BILLING_CONFIG } from "@omnicross/contracts/billing-types";
+import {
+  WEBHOOK_DESTINATION_TYPES,
+  WEBHOOK_EVENT_KINDS
+} from "@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 = raw?.accountHealth;
+  return {
+    overloadCooldownEnabled: ah?.overloadCooldownEnabled !== false,
+    overloadCooldownMs: clampNumber(
+      ah?.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 = raw?.accountProbe;
+  return {
+    enabled: ap?.enabled === true,
+    intervalMs: clampNumber(ap?.intervalMs, 6e4, 864e5, DEFAULT_ACCOUNT_PROBE.intervalMs),
+    onlyMultiAccount: ap?.onlyMultiAccount !== false,
+    timeoutMs: clampNumber(ap?.timeoutMs, 1e3, 6e4, DEFAULT_ACCOUNT_PROBE.timeoutMs),
+    historySize: Math.trunc(
+      clampNumber(ap?.historySize, 1, 200, DEFAULT_ACCOUNT_PROBE.historySize)
+    ),
+    staggerMs: clampNumber(ap?.staggerMs, 0, 6e4, DEFAULT_ACCOUNT_PROBE.staggerMs)
+  };
+}
+function normalizeAudit(raw) {
+  const a = raw?.audit;
+  return {
+    enabled: a?.enabled === true,
+    captureBodies: a?.captureBodies === true,
+    maxBodyBytes: Math.trunc(
+      clampNumber(a?.maxBodyBytes, 256, 1048576, DEFAULT_AUDIT_CONFIG.maxBodyBytes)
+    ),
+    retentionDays: Math.trunc(
+      clampNumber(a?.retentionDays, 1, 365, DEFAULT_AUDIT_CONFIG.retentionDays)
+    ),
+    trustForwardedFor: a?.trustForwardedFor === true
+  };
+}
+function normalizeBilling(raw) {
+  const b = raw?.billing;
+  const config = {
+    enabled: b?.enabled === true,
+    maxRetryAgeMs: Math.trunc(
+      clampNumber(b?.maxRetryAgeMs, 6e4, 2592e6, DEFAULT_BILLING_CONFIG.maxRetryAgeMs)
+    )
+  };
+  if (typeof b?.endpoint === "string" && b.endpoint.trim()) config.endpoint = b.endpoint.trim();
+  if (typeof b?.secret === "string" && b.secret.length > 0) config.secret = b.secret;
+  return config;
+}
+var DEFAULT_FINGERPRINT = { enabled: false };
+function normalizeFingerprint(raw) {
+  const f = raw?.fingerprint;
+  const out = { enabled: f?.enabled === true };
+  if (typeof f?.ua === "string" && f.ua.trim().length > 0) out.ua = f.ua.trim();
+  return out;
+}
+function normalizeVoucher(raw) {
+  return { enabled: raw?.voucher?.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" || !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" && 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 = raw?.userMessageQueue;
+  const cq = raw?.concurrencyQueue;
+  return {
+    userMessageQueue: {
+      enabled: umq?.enabled === true,
+      delayMs: clampNumber(umq?.delayMs, 0, 1e4, DEFAULT_USER_MESSAGE_QUEUE.delayMs),
+      waitTimeoutMs: clampNumber(
+        umq?.waitTimeoutMs,
+        1e3,
+        3e5,
+        DEFAULT_USER_MESSAGE_QUEUE.waitTimeoutMs
+      )
+    },
+    concurrencyQueue: {
+      maxQueueSizeFactor: clampNumber(
+        cq?.maxQueueSizeFactor,
+        1,
+        10,
+        DEFAULT_CONCURRENCY_QUEUE.maxQueueSizeFactor
+      ),
+      minQueueSize: clampNumber(cq?.minQueueSize, 1, 100, DEFAULT_CONCURRENCY_QUEUE.minQueueSize),
+      waitTimeoutMs: clampNumber(
+        cq?.waitTimeoutMs,
+        1e3,
+        3e5,
+        DEFAULT_CONCURRENCY_QUEUE.waitTimeoutMs
+      )
+    }
+  };
+}
+var ALL_ENDPOINTS = ["chat", "responses", "messages", "gemini"];
+function blankModelMap(endpoint) {
+  const modelMap = {};
+  for (const kind of modelKindsForEndpoint(endpoint)) modelMap[kind] = "";
+  return modelMap;
+}
+function defaultEndpointConfig(endpoint) {
+  if (isKindMappedEndpoint(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;
+  const boundAccountId = typeof e.boundAccountId === "string" && e.boundAccountId.trim() !== "" ? e.boundAccountId : void 0;
+  const boundKeyId = typeof e.boundKeyId === "string" && e.boundKeyId.trim() !== "" ? e.boundKeyId : void 0;
+  let config;
+  if (isKindMappedEndpoint(endpoint)) {
+    const rawMap = e.modelMap && typeof e.modelMap === "object" ? e.modelMap : {};
+    const modelMap = {};
+    for (const kind of modelKindsForEndpoint(endpoint)) {
+      const v = rawMap[kind];
+      modelMap[kind] = typeof v === "string" ? v : "";
+    }
+    config = { endpoint, modelMap, useSubscription };
+  } else if (endpoint === "chat") {
+    const models = Array.isArray(e.models) ? e.models.filter((m) => typeof m === "string" && m.trim() !== "") : [];
+    config = { endpoint, models, useSubscription };
+    if (e.dispatchMode === "prefix") {
+      config.dispatchMode = "prefix";
+      const targets = normalizePrefixTargets(e.prefixTargets);
+      if (targets) config.prefixTargets = targets;
+    }
+  } else {
+    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;
+    }
+  }
+  if (boundAccountId) config.boundAccountId = boundAccountId;
+  if (boundKeyId) config.boundKeyId = boundKeyId;
+  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 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) => byEndpoint.get(ep) ?? defaultEndpointConfig(ep)
+    ),
+    port: 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: patch.enabled ?? current.enabled,
+    networkBinding: patch.networkBinding ?? current.networkBinding,
+    endpoints: patch.endpoints ?? current.endpoints,
+    port: patch.port ?? current.port,
+    userMessageQueue: patch.userMessageQueue ?? current.userMessageQueue,
+    concurrencyQueue: patch.concurrencyQueue ?? current.concurrencyQueue,
+    accountHealth: patch.accountHealth ?? current.accountHealth,
+    accountProbe: patch.accountProbe ?? current.accountProbe,
+    audit: patch.audit ?? current.audit,
+    billing: 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: 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: 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: 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: patch.voucher ?? current.voucher
+  });
+}
+
 // src/outbound-api/outboundApiKeyAuth.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
+
+// src/outbound-api/keyPolicy.ts
+var DAY_MS = 864e5;
+function computeKeyExpiry(row, now) {
+  const mode = 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 +2498,706 @@ 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: row.restrictionMode ?? "blacklist",
+    models: 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 };
+  if (expiry.needsActivation) {
+    void db.outboundApiKeysMarkActivated(row.id, now).catch(() => {
+    });
+  }
+  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/roleDetection.ts
-import { normalizeModelId } from "@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(normalizeModelId(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 = msg?.content;
-    if (!Array.isArray(content)) continue;
-    for (const part of content) {
-      if (part?.type === "image") return true;
+// src/outbound-api/outboundConcurrencyGate.ts
+var ConcurrencyQueueFullError = class extends Error {
+  constructor(apiKeyId, maxQueueSize) {
+    super(`concurrency queue full (max ${maxQueueSize}) for key '${apiKeyId}'`);
+    this.apiKeyId = apiKeyId;
+    this.maxQueueSize = maxQueueSize;
+    this.name = "ConcurrencyQueueFullError";
+  }
+  apiKeyId;
+  maxQueueSize;
+  code = "concurrency_queue_full";
+};
+var ConcurrencyWaitTimeoutError = class extends Error {
+  constructor(apiKeyId, waitTimeoutMs) {
+    super(`concurrency wait timed out after ${waitTimeoutMs}ms for key '${apiKeyId}'`);
+    this.apiKeyId = apiKeyId;
+    this.waitTimeoutMs = waitTimeoutMs;
+    this.name = "ConcurrencyWaitTimeoutError";
+  }
+  apiKeyId;
+  waitTimeoutMs;
+  code = "concurrency_wait_timeout";
+};
+var ConcurrencyWaitCancelledError = class extends Error {
+  constructor(apiKeyId) {
+    super(`concurrency wait cancelled for key '${apiKeyId}'`);
+    this.apiKeyId = apiKeyId;
+    this.name = "ConcurrencyWaitCancelledError";
+  }
+  apiKeyId;
+  code = "concurrency_wait_cancelled";
+};
+function isConcurrencyRejection(err) {
+  return err instanceof ConcurrencyQueueFullError || err instanceof ConcurrencyWaitTimeoutError || err instanceof ConcurrencyWaitCancelledError;
+}
+var OutboundConcurrencyGate = class {
+  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;
+  }
+  /** 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();
+  }
+};
+
+// src/outbound-api/outboundRateLimiter.ts
+var DEFAULT_WINDOW_MS = 6e4;
+var DEFAULT_MAX_REQUESTS = 60;
+var OutboundRateLimiter = class {
+  windowMs;
+  maxRequests;
+  /** apiKeyId → ascending request timestamps within the current window. */
+  hits = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+    this.maxRequests = 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 = override?.maxRequests ?? this.maxRequests;
+    const windowMs = override?.windowMs ?? this.windowMs;
+    if (maxRequests === 0) return { allowed: true, retryAfterSeconds: 0 };
+    const cutoff = now - windowMs;
+    const timestamps = (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))
+      };
+    }
+    timestamps.push(now);
+    this.hits.set(apiKeyId, timestamps);
+    return { allowed: true, retryAfterSeconds: 0 };
+  }
+  /** Drop all recorded state (tests / teardown). */
+  reset() {
+    this.hits.clear();
+  }
+};
+
+// 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) => asObject(block)?.["type"] === "tool_result"
+    );
+    return !hasToolResult;
+  }
+  return false;
+}
+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 openaiChatHasVision(body) {
-  const messages = body["messages"];
-  if (!Array.isArray(messages)) return false;
-  for (const msg of messages) {
-    const content = msg?.content;
-    if (!Array.isArray(content)) continue;
-    for (const part of content) {
-      if (part?.type === "image_url") return true;
-    }
-  }
-  return false;
+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) => asObject(part)?.["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;
+  }
+}
+
+// src/outbound-api/userMessageSerialQueue.ts
+var SerialQueueTimeoutError = class extends Error {
+  constructor(providerId, waitTimeoutMs) {
+    super(`user-message serial queue wait timed out after ${waitTimeoutMs}ms for '${providerId}'`);
+    this.providerId = providerId;
+    this.waitTimeoutMs = waitTimeoutMs;
+    this.name = "SerialQueueTimeoutError";
+  }
+  providerId;
+  waitTimeoutMs;
+  code = "serial_queue_timeout";
+};
+function isSerialQueueTimeout(err) {
+  return err instanceof SerialQueueTimeoutError;
+}
+var UserMessageSerialQueue = class {
+  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 = 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));
+    }
+    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();
+  }
+};
+
+// src/outbound-api/voucher.ts
+import { createHash as createHash2 } from "crypto";
+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 createHash2("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 = currentKey?.totalCostLimitUsd ?? 0;
+    let granted2 = current + (voucher.creditUsd ?? 0);
+    if (voucher.maxTotalCostLimitUsd != null) {
+      granted2 = Math.min(granted2, voucher.maxTotalCostLimitUsd);
+    }
+    return { totalCostLimitUsd: granted2 };
+  }
+  const currentExpiry = currentKey?.expiresAt ?? now;
+  let granted = currentExpiry + (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 = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
+  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 openaiResponsesHasVision(body) {
-  const input = body["input"];
-  if (!Array.isArray(input)) return false;
-  for (const item of input) {
-    const content = item?.content;
-    if (Array.isArray(content)) {
-      for (const part of content) {
-        if (part?.type === "input_image") return true;
-      }
-    }
-    if (item?.type === "input_image") return true;
-  }
-  return false;
+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 geminiHasVision(body) {
-  const contents = body["contents"];
-  if (!Array.isArray(contents)) return false;
-  for (const content of contents) {
-    const parts = content?.parts;
-    if (!Array.isArray(parts)) continue;
-    for (const part of parts) {
-      const p = part;
-      if (p?.inline_data || p?.inlineData || p?.file_data || p?.fileData) return true;
-    }
+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 (keyRow?.totalCostLimitUsd != null) result.totalCostLimitUsd = keyRow.totalCostLimitUsd;
+  } else if (keyRow?.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;
   }
-  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);
-    default:
-      return false;
+  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;
   }
-}
-function detectRequestRole(ingressFormat, body, options) {
-  if (hasVisionContent(ingressFormat, body)) return "vision";
-  const requestedModel = extractRequestedModel(ingressFormat, body);
-  if (requestedModel) {
-    const overrides = options?.backgroundModelIds;
-    if (overrides && overrides.length > 0) {
-      const reqNorm = normalizeModelId(requestedModel);
-      const inOverride = overrides.some((id) => {
-        if (!id) return false;
-        const candidate = id.includes(",") ? id.slice(id.indexOf(",") + 1) : id;
-        return normalizeModelId(candidate) === reqNorm || candidate === requestedModel;
-      });
-      if (inOverride) return "background";
-    }
-    if (isBackgroundTierModel(requestedModel)) return "background";
+  const raw = await readBody2(req);
+  let code;
+  try {
+    code = raw ? JSON.parse(raw)["code"] : void 0;
+  } catch {
+    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) => (a.redeemedAt ?? 0) - (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 (after?.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 = 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()) {
@@ -1917,7 +3229,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 = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
+  return path.endsWith("/models");
+}
+function writeChatModelsList(res, config) {
+  const chat = config.endpoints.find((e) => e.endpoint === "chat");
+  const data = (chat?.models ?? []).map((ref) => parseModelRef(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 +3253,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,
+      config.voucher?.enabled === true,
+      redeemLimiter ?? getFallbackRedeemLimiter(),
+      verified.id,
+      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 +3305,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 {
-    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 resolveRoute({
-    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 = 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 = serializeError(err);
-    console.error("[OutboundApi] dispatch error:", message);
-    writeJsonError(res, 502, message);
+    const ingressFormat = endpointToIngressFormat(endpoint);
+    const rawBody = await readBody3(req);
+    let parsedBody = {};
+    try {
+      parsedBody = rawBody ? JSON.parse(rawBody) : {};
+    } catch {
+      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 = isKindMappedEndpoint(endpoint) || endpoint === "chat" ? await resolveRoute({
+      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: extractRequestedModel(ingressFormat, parsedBody),
+      // Attribution: stamp the verified named-key id onto the route.
+      apiKeyId: verified.id
+    }) : await resolveRoute({
+      config: endpointConfig,
+      role: detectRequestRole(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 (config.userMessageQueue?.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 = serializeError(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,53 +3477,20 @@ function makeReplayRequest(req, rawBody) {
   return readable;
 }
 
-// src/outbound-api/outboundRateLimiter.ts
-var DEFAULT_WINDOW_MS = 6e4;
-var DEFAULT_MAX_REQUESTS = 60;
-var OutboundRateLimiter = class {
-  windowMs;
-  maxRequests;
-  /** apiKeyId → ascending request timestamps within the current window. */
-  hits = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
-    this.maxRequests = 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 = (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();
-  }
-};
-
 // 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 OutboundApiConfigError = class extends Error {
+  missing;
+  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 = class {
   constructor(deps, onPortChange) {
     this.deps = deps;
@@ -2072,7 +3502,25 @@ var OutboundApiServer = class {
   boundPort = 0;
   boundAddr = LOOPBACK_ADDR;
   endpoints = [];
+  userMessageQueue;
+  concurrencyQueue;
+  voucherConfig;
   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).
+   */
+  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).
+   */
+  redeemMutex = new KeyedMutex();
+  serialQueue = new UserMessageSerialQueue();
+  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 +3528,25 @@ var OutboundApiServer = 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 = input.port ?? DEFAULT_OUTBOUND_PORT;
     if (!input.enabled) {
       await this.stop();
       return;
     }
+    const missing = validateServerModelConfig({
+      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) {
@@ -2101,7 +3562,7 @@ var OutboundApiServer = class {
     this.boundAddr = bindAddr;
     this.boundPort = actualPort;
     if (actualPort !== port) this.onPortChange?.(actualPort);
-    console.log(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
+    this.logInfo(`[OutboundApiServer] Listening on ${bindAddr}:${actualPort}`);
     return actualPort;
   }
   /** Bind once; on EADDRINUSE retry with an ephemeral port (port 0). */
@@ -2123,7 +3584,7 @@ var OutboundApiServer = class {
         const addr = server.address();
         if (addr && typeof addr === "object") {
           server.removeListener("error", onError);
-          server.on("error", (e) => console.error("[OutboundApiServer] server error", serializeError(e)));
+          server.on("error", (e) => this.logError("[OutboundApiServer] server error", serializeError(e)));
           this.server = server;
           resolve(addr.port);
         } else {
@@ -2134,21 +3595,58 @@ var OutboundApiServer = 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 = serializeError(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 = (req.url ?? "/").split("?")[0]?.replace(/\/+$/, "") || "/";
+    if (path !== "/health" && path !== "/healthz") return false;
+    const report = provider();
+    res.writeHead(healthHttpStatus(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 +3655,7 @@ var OutboundApiServer = class {
     this.boundPort = 0;
     return new Promise((resolve) => {
       server.close(() => {
-        console.log("[OutboundApiServer] Stopped");
+        this.logInfo("[OutboundApiServer] Stopped");
         resolve();
       });
     });
@@ -2189,6 +3687,17 @@ var OutboundApiServer = class {
       lanFormats: lanBase ? formatUrls(lanBase) : null
     };
   }
+  /**
+   * 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()
+    };
+  }
 };
 function formatUrls(base) {
   return {
@@ -2209,66 +3718,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
-  };
-}
-function defaultServerConfig() {
-  return {
-    enabled: false,
-    networkBinding: false,
-    endpoints: ALL_ENDPOINTS.map(defaultEndpointConfig),
-    port: DEFAULT_OUTBOUND_PORT
-  };
-}
-function normalizeServerConfig(raw) {
-  const base = defaultServerConfig();
-  if (!raw) return base;
-  const byEndpoint = /* @__PURE__ */ new Map();
-  for (const e of raw.endpoints ?? []) {
-    if (e && ALL_ENDPOINTS.includes(e.endpoint)) {
-      byEndpoint.set(e.endpoint, {
-        endpoint: e.endpoint,
-        defaultModel: e.defaultModel ?? "",
-        backgroundModel: e.backgroundModel ?? "",
-        visionModel: e.visionModel,
-        useSubscription: e.useSubscription === true,
-        backgroundModelIds: e.backgroundModelIds
-      });
+// src/outbound-api/keySpendTracker.ts
+function startOfLocalDay(ts) {
+  const d = new Date(ts);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+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();
+}
+var KeySpendTracker = class {
+  constructor(seeder) {
+    this.seeder = seeder;
+  }
+  seeder;
+  /** apiKeyId → live accumulated spend (seeded lazily). */
+  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 };
+  }
+};
+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) => byEndpoint.get(ep) ?? defaultEndpointConfig(ep)
-    ),
-    port: 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: patch.enabled ?? current.enabled,
-    networkBinding: patch.networkBinding ?? current.networkBinding,
-    endpoints: patch.endpoints ?? current.endpoints,
-    port: patch.port ?? current.port
-  });
 }
 
 // src/outbound-api/index.ts
@@ -4380,21 +5911,60 @@ export {
   ProviderProxy,
   getProviderProxy,
   __resetProviderProxyForTests,
+  KeyedMutex,
+  OUTBOUND_API_SERVER_CONFIG_KEY,
+  DEFAULT_USER_MESSAGE_QUEUE,
+  DEFAULT_CONCURRENCY_QUEUE,
+  DEFAULT_ACCOUNT_PROBE,
+  normalizeAccountProbe,
+  normalizeAudit,
+  normalizeBilling,
+  DEFAULT_FINGERPRINT,
+  normalizeFingerprint,
+  normalizeVoucher,
+  normalizeProxyConfig,
+  normalizeProxySegment,
+  normalizeWebhookDestination,
+  normalizeWebhookSegment,
+  normalizeQueueSegments,
+  normalizePrefixTargets,
+  defaultServerConfig,
+  normalizeServerConfig,
+  loadServerConfig,
+  saveServerConfig,
+  mergeServerConfig,
+  computeKeyExpiry,
+  checkKeyQuota,
+  randomBase62,
   hashKey,
   createNamedKey,
+  verifyKey,
   verifyPresentedKey,
-  detectRequestRole,
-  endpointToIngressFormat,
+  ConcurrencyQueueFullError,
+  ConcurrencyWaitTimeoutError,
+  ConcurrencyWaitCancelledError,
+  isConcurrencyRejection,
+  OutboundConcurrencyGate,
   OutboundRateLimiter,
+  isUserMessageRequest,
+  SerialQueueTimeoutError,
+  isSerialQueueTimeout,
+  UserMessageSerialQueue,
+  generateVoucherCode,
+  hashVoucherCode,
+  voucherCodePrefix,
+  newVoucherId,
+  computeVoucherGrant,
+  toVoucherInfo,
+  isRedeemRequest,
+  handleVoucherRedeem,
   DEFAULT_OUTBOUND_PORT,
+  OutboundApiConfigError,
   OutboundApiServer,
   formatUrls,
-  OUTBOUND_API_SERVER_CONFIG_KEY,
-  defaultServerConfig,
-  normalizeServerConfig,
-  loadServerConfig,
-  saveServerConfig,
-  mergeServerConfig,
+  startOfLocalDay,
+  startOfLocalWeek,
+  KeySpendTracker,
   getOutboundApiServer,
   __resetOutboundApiServerForTests
 };