@omnicross/core 0.1.6 → 0.1.8

package/dist/{chunk-UDCC7EMR.js → chunk-QYC54PMG.js}

@@ -1,30 +1,30 @@
-import {
-  collectMatchText,
-  deriveGatewaySessionKey,
-  deriveSubscriptionSessionKey
-} from "./chunk-WB6PH56J.js";
 import {
   streamSSEResponse
 } from "./chunk-VVEHS2LI.js";
 import {
-  TransformerChainExecutor
-} from "./chunk-WNKWAEUR.js";
-import {
-  injectExtendedContextBeta
-} from "./chunk-MZNPGW5Q.js";
+  AnthropicTransformer,
+  resolveAnthropicMaxTokens
+} from "./chunk-PEGTIPB3.js";
 import {
   GeminiTransformer
 } from "./chunk-LVUCAWMK.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-OEWZUX4G.js";
+} from "./chunk-32O35CIF.js";
 import {
-  AnthropicTransformer,
-  resolveAnthropicMaxTokens
-} from "./chunk-6CL5HTPQ.js";
+  TransformerChainExecutor
+} from "./chunk-WNKWAEUR.js";
 import {
-  getGeminiCodeAssistResolver
-} from "./chunk-DRWHTIIZ.js";
+  injectExtendedContextBeta
+} from "./chunk-MZNPGW5Q.js";
+import {
+  DEFAULT_CODEX_CLI_HEADERS,
+  NEVER_FORWARD_HEADERS,
+  codexAcceptHeader,
+  extractCodexClientHeaders,
+  fillMissingHeaders,
+  flattenHeaderValue
+} from "./chunk-XXFYLL7R.js";
 import {
   getSharedIdentityStore
 } from "./chunk-XTEI64OU.js";
@@ -32,22 +32,36 @@ import {
   applyFingerprint,
   captureCallerIdentity
 } from "./chunk-XX6NQJMA.js";
+import {
+  collectMatchText,
+  deriveGatewaySessionKey,
+  deriveSubscriptionSessionKey
+} from "./chunk-GFIZ6LQI.js";
+import {
+  emitWebhookEvent
+} from "./chunk-OE6TDIWW.js";
+import {
+  getGeminiCodeAssistResolver
+} from "./chunk-DRWHTIIZ.js";
+import {
+  resolveProviderChain
+} from "./chunk-JWC6APFQ.js";
 import {
   resolveSubscriptionChain
 } from "./chunk-5ERIZW3D.js";
+import {
+  getSharedOverloadCounter
+} from "./chunk-PO3XB56Z.js";
 import {
   getSharedAccountHealth,
   resolveResetSeconds
-} from "./chunk-YJVHCHQX.js";
+} from "./chunk-N7OOJI5V.js";
 import {
   SubscriptionAuthSource
 } from "./chunk-23S5OPIO.js";
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
-import {
-  emitWebhookEvent
-} from "./chunk-OE6TDIWW.js";
 import {
   isAccountAllowanceExhaustedError
 } from "./chunk-OPRS4IQZ.js";
@@ -62,9 +76,6 @@ import {
   LlmConfigProviderAuth,
   getProviderHeaders
 } from "./chunk-ZY6KU6P3.js";
-import {
-  resolveProviderChain
-} from "./chunk-JWC6APFQ.js";
 import {
   beginBillingCapture
 } from "./chunk-WLYIIEAF.js";
@@ -83,6 +94,9 @@ import {
   resolvePrefixTarget,
   resolveRoute
 } from "./chunk-EBLFCNPY.js";
+import {
+  getSubscriptionRegistryForOutbound
+} from "./chunk-AQ5TNQB7.js";
 import {
   buildProviderApiUrl,
   resolveApiFormat,
@@ -90,14 +104,20 @@ import {
 } from "./chunk-H5JUT3KV.js";
 import {
   beginAuditCapture
-} from "./chunk-IFXJ2BG7.js";
+} from "./chunk-7C7DET6S.js";
 import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
-} from "./chunk-AT7B7SOZ.js";
+} from "./chunk-5NJLQ6T6.js";
 import {
   fetchUpstream
-} from "./chunk-SIZQQD6T.js";
+} from "./chunk-RJ5ZGNI3.js";
+import {
+  getSharedAccountAllowanceStore
+} from "./chunk-MKF46GNZ.js";
+import {
+  getSharedAccountRouteActivity
+} from "./chunk-GL6XM527.js";
 import {
   applyAugmentation
 } from "./chunk-Y7FO65VT.js";
@@ -415,12 +435,16 @@ var ProviderProxyRouteMap = class {
    * (`ANTHROPIC_AUTH_TOKEN` / `OPENAI_API_KEY`). Optionally override the idle
    * timeout (tests use a short one).
    */
-  addRoute(context, idleMs) {
+  addRoute(context, idleMsOrOptions) {
+    const options = typeof idleMsOrOptions === "number" ? { idleMs: idleMsOrOptions } : idleMsOrOptions ?? {};
     const token = randomBytes(TOKEN_BYTES).toString("hex");
     const entry = {
       context,
       idleTimer: null,
-      idleMs: idleMs ?? this.defaultIdleMs
+      idleMs: options.idleMs ?? this.defaultIdleMs,
+      onActivity: options.onActivity,
+      onEvicted: options.onEvicted,
+      evicted: false
     };
     this.routes.set(token, entry);
     this.armIdleTimer(token, entry);
@@ -435,6 +459,10 @@ var ProviderProxyRouteMap = class {
     if (!token) return void 0;
     const entry = this.routes.get(token);
     if (!entry) return void 0;
+    try {
+      entry.onActivity?.(Date.now());
+    } catch {
+    }
     this.armIdleTimer(token, entry);
     return entry.context;
   }
@@ -442,8 +470,16 @@ var ProviderProxyRouteMap = class {
   removeRoute(token) {
     const entry = this.routes.get(token);
     if (!entry) return false;
-    this.clearIdleTimer(entry);
     this.routes.delete(token);
+    this.evict(entry, "removed");
+    return true;
+  }
+  /** Re-arm one existing route without rotating its token. */
+  renewRoute(token, idleMs) {
+    const entry = this.routes.get(token);
+    if (!entry) return false;
+    if (idleMs !== void 0) entry.idleMs = idleMs;
+    this.armIdleTimer(token, entry);
     return true;
   }
   /** Current live-route count (tests / diagnostics). */
@@ -456,10 +492,11 @@ var ProviderProxyRouteMap = class {
   }
   /** Tear down every route (proxy stop / app teardown). */
   clear() {
-    for (const entry of this.routes.values()) {
-      this.clearIdleTimer(entry);
-    }
+    const entries2 = [...this.routes.values()];
     this.routes.clear();
+    for (const entry of entries2) {
+      this.evict(entry, "cleared");
+    }
   }
   // ---------------------------------------------------------------------------
   // Idle reaping (modeled on AcpSessionManager.armIdleTimer / clearIdleTimer)
@@ -467,7 +504,8 @@ var ProviderProxyRouteMap = class {
   armIdleTimer(token, entry) {
     this.clearIdleTimer(entry);
     entry.idleTimer = setTimeout(() => {
-      this.routes.delete(token);
+      if (!this.routes.delete(token)) return;
+      this.evict(entry, "idle");
     }, entry.idleMs);
     entry.idleTimer.unref?.();
   }
@@ -477,8 +515,77 @@ var ProviderProxyRouteMap = class {
       entry.idleTimer = null;
     }
   }
+  evict(entry, reason) {
+    if (entry.evicted) return;
+    entry.evicted = true;
+    this.clearIdleTimer(entry);
+    try {
+      entry.onEvicted?.(reason);
+    } catch {
+    }
+  }
 };
 
+// src/provider-proxy/identity/claudeCodeHeaders.ts
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+var OAUTH_BETA = "oauth-2025-04-20";
+var CLAUDE_CODE_BETA = "claude-code-20250219";
+var INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+var TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+var DEFAULT_CLAUDE_CODE_HEADERS = Object.freeze({
+  "user-agent": "claude-cli/1.0.119 (external, cli)",
+  "x-app": "cli",
+  accept: "application/json",
+  "accept-language": "*",
+  "sec-fetch-mode": "cors",
+  "anthropic-dangerous-direct-browser-access": "true",
+  "x-stainless-lang": "js",
+  "x-stainless-package-version": "0.55.1",
+  "x-stainless-os": "Windows",
+  "x-stainless-arch": "x64",
+  "x-stainless-runtime": "node",
+  "x-stainless-runtime-version": "v20.19.2",
+  "x-stainless-retry-count": "0",
+  "x-stainless-timeout": "60"
+});
+var FORCED_ACCEPT_ENCODING = "identity";
+var CLAUDE_FORWARD_ALLOWLIST = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-language",
+  "sec-fetch-mode",
+  "user-agent",
+  "x-app",
+  "anthropic-dangerous-direct-browser-access",
+  "anthropic-version"
+]);
+var STAINLESS_PREFIX = "x-stainless-";
+function extractClaudeClientHeaders(reqHeaders) {
+  const out = {};
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    const key = rawKey.toLowerCase();
+    if (NEVER_FORWARD_HEADERS.has(key)) continue;
+    if (!CLAUDE_FORWARD_ALLOWLIST.has(key) && !key.startsWith(STAINLESS_PREFIX)) continue;
+    const value = flattenHeaderValue(rawVal);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function buildAnthropicBeta(model, callerBeta) {
+  const isHaiku = typeof model === "string" && model.toLowerCase().includes("haiku");
+  const baseline = isHaiku ? [OAUTH_BETA, INTERLEAVED_THINKING_BETA] : [CLAUDE_CODE_BETA, OAUTH_BETA, INTERLEAVED_THINKING_BETA, TOOL_STREAMING_BETA];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (flag) => {
+    const trimmed = flag.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    out.push(trimmed);
+  };
+  baseline.forEach(add);
+  if (callerBeta) callerBeta.split(",").forEach(add);
+  return out.join(",");
+}
+
 // src/provider-proxy/usage/recordAnthropicUsage.ts
 function readAnthropicUsage(usage) {
   if (!usage) return null;
@@ -506,6 +613,10 @@ function emitAnthropicUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: attribution.routeLease?.runId ?? null,
+    routeLeaseId: attribution.routeLease?.leaseId ?? null,
+    routeLeaseConsumer: attribution.routeLease?.consumer ?? null,
+    routeLeaseStageId: attribution.routeLease?.stageId ?? null,
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -653,7 +764,7 @@ async function relaySseBody(res, body, options) {
     res.end();
   }
 }
-async function relayResponse(res, providerResponse, isStream, rewriteModel, usageTap) {
+async function relayResponse(res, providerResponse, isStream, rewriteModel, usageTap, onSseEvent) {
   const contentType = providerResponse.headers.get("Content-Type") ?? "";
   const status = providerResponse.status && providerResponse.status >= 100 ? providerResponse.status : 200;
   const upstreamIsSse = contentType.includes("text/event-stream");
@@ -667,13 +778,16 @@ async function relayResponse(res, providerResponse, isStream, rewriteModel, usag
       res.end();
       return null;
     }
-    if (rewriteModel || usageTap) {
+    if (rewriteModel || usageTap || onSseEvent) {
       let capturedUsage = null;
       await relaySseBody(res, providerResponse.body, {
         rewriteModel,
-        onSseEvent: usageTap ? (event) => {
-          const raw = usageTap.extractUsage(event);
-          if (raw) capturedUsage = raw;
+        onSseEvent: onSseEvent || usageTap ? (event) => {
+          onSseEvent?.(event);
+          if (usageTap) {
+            const raw = usageTap.extractUsage(event);
+            if (raw) capturedUsage = raw;
+          }
         } : void 0
       });
       if (capturedUsage) usageTap.onUsage(capturedUsage);
@@ -985,7 +1099,16 @@ async function runPipeline(anthropicBody, plan, reportSelection) {
       return fetchUpstream(
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
-        { providerId: proxyProviderId(plan), accountId: proxyAccountId }
+        {
+          providerId: proxyProviderId(plan),
+          accountId: proxyAccountId,
+          routeActivity: plan.isSubscription ? {
+            endpoint: "messages",
+            sessionKey: plan.sessionKey,
+            sessionSource: plan.sessionKey ? "content-fingerprint" : "none",
+            model: resolvedModel
+          } : void 0
+        }
       ).then((r) => {
         rawStatus = r.status;
         return r;
@@ -1012,7 +1135,8 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
       reportSelection?.(accountId, isActive, remapped);
     }
   });
-  if (plan.isSubscription && plan.transformerProvider.name === "claude") {
+  const isClaudeSubscription = plan.isSubscription && plan.transformerProvider.name === "claude";
+  if (isClaudeSubscription) {
     applyFingerprint(
       getSharedIdentityStore(),
       headers,
@@ -1021,18 +1145,38 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
       options.callerIdentity
     );
   }
+  if (isClaudeSubscription) {
+    fillMissingHeaders(headers, options.callerClientHeaders ?? {});
+    fillMissingHeaders(headers, DEFAULT_CLAUDE_CODE_HEADERS);
+  }
+  fillMissingHeaders(headers, { "anthropic-version": DEFAULT_ANTHROPIC_VERSION });
+  headers["accept-encoding"] = FORCED_ACCEPT_ENCODING;
   const applyRemap = remappedModel !== void 0 && outboundRemapApplies(plan);
   const outboundBody = applyRemap ? rewriteBodyModel(rawBody, remappedModel) : rawBody;
   const outboundModel = applyRemap ? remappedModel : plan.resolvedModel;
+  if (isClaudeSubscription) {
+    headers["anthropic-beta"] = buildAnthropicBeta(outboundModel, options.callerAnthropicBeta);
+  } else if (options.callerAnthropicBeta) {
+    fillMissingHeaders(headers, { "anthropic-beta": options.callerAnthropicBeta });
+  }
   console.info(
     `[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 }
+    {
+      providerId: proxyProviderId(plan),
+      accountId: proxyAccountId,
+      routeActivity: plan.isSubscription ? {
+        endpoint: "messages",
+        sessionKey: plan.sessionKey,
+        sessionSource: plan.sessionKey ? "content-fingerprint" : "none",
+        model: outboundModel
+      } : void 0
+    }
   );
-  return { response, rawStatus: response.status };
+  return { response, rawStatus: response.status, actualModel: outboundModel };
 }
 function outboundRemapApplies(plan) {
   return plan.isSubscription && plan.transformerProvider.name === "claude";
@@ -1198,11 +1342,13 @@ async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {
     const upstreamSse = (upstreamResponse.headers.get("content-type") ?? "").includes(
       "text/event-stream"
     );
+    const actualModel = "actualModel" in providerResponse && typeof providerResponse.actualModel === "string" ? providerResponse.actualModel : void 0;
     const usageAttribution = {
       sessionId: route.sessionId,
       providerId: route.providerId ?? "anthropic",
-      model: plan.resolvedModel,
+      model: actualModel ?? plan.resolvedModel,
       apiKeyId: route.apiKeyId ?? null,
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1370,7 +1516,12 @@ async function handleAnthropicMessagesRequest(req, res, route, deps) {
     const callerBetaRaw = req.headers["anthropic-beta"];
     const callerAnthropicBeta = Array.isArray(callerBetaRaw) ? callerBetaRaw.join(",") : callerBetaRaw;
     const callerIdentity = captureCallerIdentity(getSharedIdentityStore(), req.headers);
-    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta, callerIdentity });
+    const callerClientHeaders = extractClaudeClientHeaders(req.headers);
+    await handleAnthropicMessagesByo(res, rawBody, route, deps, {
+      callerAnthropicBeta,
+      callerIdentity,
+      callerClientHeaders
+    });
     return;
   }
   const hints = route.anthropicSdkHints;
@@ -1456,6 +1607,10 @@ function emitGeminiUsageRecord(recorder, rawUsageMetadata, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: attribution.routeLease?.runId ?? null,
+    routeLeaseId: attribution.routeLease?.leaseId ?? null,
+    routeLeaseConsumer: attribution.routeLease?.consumer ?? null,
+    routeLeaseStageId: attribution.routeLease?.stageId ?? null,
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1521,6 +1676,7 @@ async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps
       providerId: route.providerId ?? "gemini",
       model: resolvedModel,
       apiKeyId: route.apiKeyId ?? null,
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1677,6 +1833,10 @@ function emitChatCompletionsUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: attribution.routeLease?.runId ?? null,
+    routeLeaseId: attribution.routeLease?.leaseId ?? null,
+    routeLeaseConsumer: attribution.routeLease?.consumer ?? null,
+    routeLeaseStageId: attribution.routeLease?.stageId ?? null,
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1729,6 +1889,7 @@ async function handleOpenAIChatRequest(res, rawBody, route, deps) {
       providerId: route.providerId ?? "openai",
       model: resolvedModel,
       apiKeyId: route.apiKeyId ?? null,
+      routeLease: route.routeLease,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -1957,6 +2118,12 @@ function emitResponsesUsageRecord(recorder, rawUsage, attribution) {
     providerId: attribution.providerId,
     model: attribution.model,
     apiKeyId: attribution.apiKeyId,
+    runId: attribution.routeLease?.runId ?? null,
+    routeLeaseId: attribution.routeLease?.leaseId ?? null,
+    routeLeaseConsumer: attribution.routeLease?.consumer ?? null,
+    routeLeaseStageId: attribution.routeLease?.stageId ?? null,
+    cacheKeySource: attribution.cacheKeySource,
+    cacheKeyInjected: attribution.cacheKeyInjected,
     auditResponse: attribution.auditResponse,
     engineOrigin: "codex-ingress",
     usage: tapped,
@@ -1981,12 +2148,72 @@ function recordResponsesStreamUsage(recorder, rawUsage, attribution) {
   }
 }
 
+// src/provider-proxy/ingress/codexUsageLimitDetection.ts
+var PROVIDER_ID = "codex";
+var DEFAULT_QUOTA_COOLDOWN_MS = 5 * 6e4;
+var QUOTA_EXHAUSTED_PERCENT = 90;
+function parseTryAgainDeadline(bodyText) {
+  const match = bodyText.match(/try again (?:at|on)\s+(.+?)(?:[.\n]|$)/i);
+  if (!match) return void 0;
+  const cleaned = match[1].replace(/(\d+)(st|nd|rd|th)/giu, "$1").trim();
+  const ms = Date.parse(cleaned);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+function deadlineFromAllowanceSnapshot(accountId, now) {
+  const snapshot = getSharedAccountAllowanceStore().get(PROVIDER_ID, accountId, now);
+  if (!snapshot) return void 0;
+  const candidates = snapshot.windows.filter(
+    (w) => typeof w.usedPercent === "number" && w.usedPercent >= QUOTA_EXHAUSTED_PERCENT && typeof w.resetsAt === "string"
+  ).map((w) => ({ ms: Date.parse(w.resetsAt), usedPercent: w.usedPercent })).filter((x) => Number.isFinite(x.ms) && x.ms > now).sort((a, b) => b.usedPercent - a.usedPercent);
+  return candidates[0]?.ms;
+}
+function resolveCodexQuotaDeadline(accountId, bodyText, now = Date.now()) {
+  const parsed = parseTryAgainDeadline(bodyText);
+  const parsedDeadline = parsed !== void 0 && parsed > now ? parsed : void 0;
+  return deadlineFromAllowanceSnapshot(accountId, now) ?? parsedDeadline ?? now + DEFAULT_QUOTA_COOLDOWN_MS;
+}
+function markCodexUsageLimitExhaustion(accountId, bodyText, now = Date.now()) {
+  if (!accountId) return;
+  const deadline = resolveCodexQuotaDeadline(accountId, bodyText, now);
+  getSharedAccountHealth().markQuotaExhausted(PROVIDER_ID, accountId, deadline, now);
+}
+
 // src/provider-proxy/ingress/openaiResponsesIngress.ts
+var SERVER_OVERLOADED_CODES = /* @__PURE__ */ new Set(["server_is_overloaded", "slow_down"]);
+function isCodexServerOverloadEvent(event) {
+  if (event["type"] !== "response.failed") return false;
+  const error = event["response"]?.["error"];
+  const code = error?.["code"];
+  return typeof code === "string" && SERVER_OVERLOADED_CODES.has(code);
+}
 function isOpenAIResponsesRequest(method, url) {
   if (method !== "POST" || !url) return false;
   const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
   return path.endsWith("/responses");
 }
+var SAFE_INJECTED_CACHE_KEY_SOURCES = /* @__PURE__ */ new Set([
+  "session-header",
+  "thread-header",
+  "body-session-id",
+  "body-thread-id",
+  "content-fingerprint"
+]);
+function isSafeInjectedCacheKeySource(source) {
+  return SAFE_INJECTED_CACHE_KEY_SOURCES.has(source);
+}
+function ensureCodexPromptCacheKey(body, proxyProviderId2, derivedSession) {
+  if (typeof body.prompt_cache_key === "string" && body.prompt_cache_key.trim()) {
+    return { cacheKeySource: "client", cacheKeyInjected: false };
+  }
+  if (proxyProviderId2 !== "codex" || !isSafeInjectedCacheKeySource(derivedSession.source)) {
+    return { cacheKeySource: "none", cacheKeyInjected: false };
+  }
+  body.prompt_cache_key = `omnicross:${derivedSession.source}:${derivedSession.key}`;
+  return {
+    cacheKeySource: derivedSession.source,
+    cacheKeyInjected: true
+  };
+}
 async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHeaders = {}) {
   let responsesBody;
   try {
@@ -2007,14 +2234,32 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHe
   const resolvedModel = route.model;
   responsesBody.model = resolvedModel;
   try {
-    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan3(
+      res,
+      route,
+      deps,
+      resolvedModel,
+      isStream,
+      sessionKey,
+      derivedSession.source,
+      requestHeaders
+    ) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
     if (!plan) return;
-    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry3(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    const cacheKeyAttribution = ensureCodexPromptCacheKey(
+      responsesBody,
+      plan.proxyProviderId,
+      derivedSession
+    );
+    let providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry3(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    providerResponse = await retryAroundCodexUsageLimit(responsesBody, plan, providerResponse);
     const usageAttribution = {
       sessionId: route.sessionId,
       providerId: route.providerId ?? "codex",
-      model: resolvedModel,
+      model: providerResponse.actualModel ?? resolvedModel,
       apiKeyId: route.apiKeyId ?? null,
+      routeLease: route.routeLease,
+      cacheKeySource: cacheKeyAttribution.cacheKeySource,
+      cacheKeyInjected: cacheKeyAttribution.cacheKeyInjected,
       // request-audit-log: correlate this request's tokens/cost to its audit record.
       auditResponse: res
     };
@@ -2030,12 +2275,33 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHe
         recordResponsesStreamUsage(usageRecorder, rawUsage, usageAttribution);
       }
     } : void 0;
+    const overloadActivityId = providerResponse.activityRecordId;
+    const overloadAccountId = providerResponse.accountId;
+    const overloadProviderId = plan.proxyProviderId;
+    let overloadRecorded = false;
+    const overloadDetector = (event) => {
+      if (overloadRecorded || !isCodexServerOverloadEvent(event)) return;
+      overloadRecorded = true;
+      if (overloadActivityId) {
+        getSharedAccountRouteActivity().amend(overloadActivityId, {
+          streamError: "server_overloaded"
+        });
+      }
+      if (overloadAccountId) {
+        getSharedOverloadCounter().recordOverload({
+          providerId: overloadProviderId,
+          accountId: overloadAccountId,
+          endpoint: "responses"
+        });
+      }
+    };
     const bodyText = await relayResponse(
       res,
       providerResponse.response,
       isStream,
       route.requestedModel,
-      usageTap
+      usageTap,
+      overloadDetector
     );
     if (bodyText && deps.usageRecorder) {
       recordResponsesNonStreamUsage(deps.usageRecorder, bodyText, usageAttribution);
@@ -2099,7 +2365,7 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     proxyProviderId: "byo"
   };
 }
-async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey) {
+async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream, sessionKey, sessionSource, requestHeaders) {
   const profile = route.subscriptionProfile;
   if (!profile) {
     writeError(res, 502, "Subscription mode requires a codex subscription profile");
@@ -2142,6 +2408,7 @@ async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream,
   return {
     auth,
     sessionKey,
+    sessionSource,
     preferredAccountId: route.preferredAccountId,
     preferredAccountGroup: route.preferredAccountGroup,
     boundAccountFallbackPolicy: route.boundAccountFallbackPolicy,
@@ -2154,7 +2421,10 @@ async function buildSubscriptionPlan3(res, route, deps, resolvedModel, isStream,
     // profile's `resolveUpstreamUrl` for non-Code-Assist subscriptions.
     resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : typeof config.url === "string" ? config.url : upstreamUrl,
     upstreamUrl,
-    proxyProviderId: profile.authStrategy.providerId
+    proxyProviderId: profile.authStrategy.providerId,
+    // Only the codex backend understands these; other subscription providers
+    // (gemini Code Assist) share this relay and must not receive them.
+    callerClientHeaders: profile.authStrategy.providerId === "codex" ? extractCodexClientHeaders(requestHeaders) : void 0
   };
 }
 async function resolveGeminiCodeAssistProject(profile, hints) {
@@ -2172,6 +2442,8 @@ async function runPipeline4(responsesBody, plan) {
   const endpointTransformer = getResponsesEndpointTransformer();
   const { auth, sessionKey, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
   let proxyAccountId;
+  let actualModel = resolvedModel;
+  let activityRecordId;
   const authHeaders = {};
   await auth.applyHeaders(authHeaders, {
     upstreamUrl,
@@ -2180,10 +2452,13 @@ async function runPipeline4(responsesBody, plan) {
     preferredAccountId: plan.preferredAccountId,
     preferredAccountGroup: plan.preferredAccountGroup,
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
-    reportSelection: (accountId) => {
+    reportSelection: (accountId, _isActive, remappedModel) => {
       proxyAccountId = accountId;
+      if (remappedModel) actualModel = remappedModel;
     }
   });
+  responsesBody.model = actualModel;
+  transformerProvider.models = [actualModel];
   let rawStatus = null;
   const { response } = await executeProviderCall({
     executor,
@@ -2199,14 +2474,31 @@ async function runPipeline4(responsesBody, plan) {
           if (value !== void 0 && !(key in headers)) headers[key] = value;
         }
       }
+      if (plan.proxyProviderId === "codex") {
+        fillMissingHeaders(headers, plan.callerClientHeaders ?? {});
+        fillMissingHeaders(headers, DEFAULT_CODEX_CLI_HEADERS);
+        fillMissingHeaders(headers, { accept: codexAcceptHeader(isStream) });
+      }
       return headers;
     },
     fetchFn: (url, headers, body) => {
-      console.log(`[ProviderProxy:responses] -> ${url} model=${resolvedModel} stream=${isStream}`);
+      console.log(`[ProviderProxy:responses] -> ${url} model=${actualModel} stream=${isStream}`);
       return fetchUpstream(
         url,
         { method: "POST", headers, body: JSON.stringify(body) },
-        { providerId: plan.proxyProviderId, accountId: proxyAccountId }
+        {
+          providerId: plan.proxyProviderId,
+          accountId: proxyAccountId,
+          routeActivity: plan.proxyProviderId === "byo" ? void 0 : {
+            endpoint: "responses",
+            sessionKey,
+            sessionSource: plan.sessionSource ?? "none",
+            model: actualModel,
+            onRecorded: (record) => {
+              activityRecordId = record.id;
+            }
+          }
+        }
       ).then((r) => {
         rawStatus = r.status;
         return r;
@@ -2214,7 +2506,7 @@ async function runPipeline4(responsesBody, plan) {
     },
     runResponseChain: true
   });
-  return { response, rawStatus };
+  return { response, rawStatus, accountId: proxyAccountId, actualModel, activityRecordId };
 }
 async function runPipelineWithPoolReporting4(responsesBody, plan) {
   const first = await runPipeline4(responsesBody, plan);
@@ -2240,6 +2532,22 @@ async function runPipelineWithSubscriptionRetry3(responsesBody, plan) {
   console.log("[ProviderProxy:responses] 401 \u2192 token refreshed; retrying once");
   return runPipeline4(responsesBody, plan);
 }
+var MAX_QUOTA_RETRIES = 3;
+function isCodexAccountQuota429(plan, result) {
+  return plan.proxyProviderId === "codex" && !!result.accountId && result.rawStatus === 429;
+}
+async function retryAroundCodexUsageLimit(responsesBody, plan, first, runAttempt = runPipelineWithSubscriptionRetry3) {
+  if (!isCodexAccountQuota429(plan, first)) return first;
+  let current = first;
+  for (let attempt = 0; attempt < MAX_QUOTA_RETRIES; attempt++) {
+    const errorBody = await current.response.text().catch(() => "");
+    markCodexUsageLimitExhaustion(current.accountId, errorBody);
+    const next = await runAttempt(responsesBody, plan);
+    if (!isCodexAccountQuota429(plan, next)) return next;
+    current = next;
+  }
+  return current;
+}
 
 // src/provider-proxy/providerProxyRouter.ts
 function extractRouteToken(authHeader) {
@@ -2302,6 +2610,7 @@ var ProviderProxy = class {
   server = null;
   port = 0;
   routes;
+  beforeStop = /* @__PURE__ */ new Set();
   /**
    * Start the resident listener on a stable port on 127.0.0.1. Idempotent —
    * a second `start()` returns the already-bound port.
@@ -2342,6 +2651,12 @@ var ProviderProxy = class {
   }
   /** Stop the listener, clear all routes, and release the port. */
   async stop() {
+    for (const cleanup of [...this.beforeStop]) {
+      try {
+        await cleanup();
+      } catch {
+      }
+    }
     this.routes.clear();
     const server = this.server;
     if (!server) return;
@@ -2358,6 +2673,15 @@ var ProviderProxy = class {
   getBaseUrl() {
     return `http://127.0.0.1:${this.port}`;
   }
+  /** Register daemon-owned cleanup that must run before route-map teardown. */
+  registerBeforeStop(cleanup) {
+    this.beforeStop.add(cleanup);
+    return () => this.beforeStop.delete(cleanup);
+  }
+  /** Whether the resident listener has completed binding. */
+  isReady() {
+    return this.server !== null && this.port > 0;
+  }
   /**
    * The SHARED route map. Exposed so the outbound API server
    * (`outbound-api-server`) can mint per-request routes on the SAME map and
@@ -2367,24 +2691,824 @@ var ProviderProxy = class {
   getRouteMap() {
     return this.routes;
   }
-  /**
-   * The app-session deps the proxy services all routes with. Exposed so the
-   * outbound server can pass them verbatim into `routeRequest()`.
-   */
-  getDeps() {
-    return this.deps;
+  /**
+   * The app-session deps the proxy services all routes with. Exposed so the
+   * outbound server can pass them verbatim into `routeRequest()`.
+   */
+  getDeps() {
+    return this.deps;
+  }
+  /** Register a route for one run; returns the crypto route token (task 2.2). */
+  addRoute(context, idleMsOrOptions) {
+    return this.routes.addRoute(context, idleMsOrOptions);
+  }
+  /** Re-arm one route while retaining the exact same bearer token. */
+  renewRoute(token, idleMs) {
+    return this.routes.renewRoute(token, idleMs);
+  }
+  /** Remove a route at run end. Returns true if an entry existed. */
+  removeRoute(token) {
+    return this.routes.removeRoute(token);
+  }
+  /** Live-route count (diagnostics / tests). */
+  routeCount() {
+    return this.routes.size();
+  }
+};
+
+// src/provider-proxy/RouteLeaseManager.ts
+import { randomBytes as randomBytes3, randomUUID } from "crypto";
+
+// src/provider-proxy/routeLeaseSchema.ts
+import { createHash, createHmac, randomBytes as randomBytes2 } from "crypto";
+var ROUTE_LEASE_REQUEST_SCHEMA = "omnicross.route-lease.request/1";
+var ROUTE_LEASE_RESULT_SCHEMA = "omnicross.route-lease/1";
+var ROUTE_LEASE_CAPABILITIES_SCHEMA = "omnicross.route-lease.capabilities/1";
+var ROUTE_LEASE_API_VERSION = 1;
+var ROUTE_LEASE_DEFAULT_TTL_SECONDS = 600;
+var ROUTE_LEASE_MAX_TTL_SECONDS = 3600;
+var ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES = 256;
+var ROUTE_LEASE_MAX_CONSUMER_BYTES = 64;
+var ROUTE_LEASE_MAX_EXECUTION_ID_BYTES = 128;
+var ROUTE_LEASE_MAX_SESSION_ID_BYTES = 512;
+var ROUTE_LEASE_MAX_MODEL_BYTES = 256;
+var ROUTE_LEASE_SESSION_HASH_DOMAIN = "omnicross.route-lease.session/v1";
+var ROUTE_LEASE_CODEX_TOKEN_ENV = "OMNICROSS_CODEX_ROUTE_TOKEN";
+var ROUTE_LEASE_RUNTIMES = ["claude", "codex"];
+var ROUTE_LEASE_CAPABILITIES = Object.freeze({
+  schemaVersion: ROUTE_LEASE_CAPABILITIES_SCHEMA,
+  runtimes: Object.freeze(["claude", "codex"]),
+  upstreamKinds: Object.freeze(["provider", "account", "account-group", "account-pool"]),
+  leaseApiVersion: ROUTE_LEASE_API_VERSION,
+  codexAuthMode: "env_key",
+  maxTtlSeconds: ROUTE_LEASE_MAX_TTL_SECONDS
+});
+var ROUTE_LEASE_RUNTIME_TABLE = Object.freeze({
+  claude: Object.freeze({ endpoint: "messages", ingressFormat: "anthropic-messages", wirePath: "/v1/messages" }),
+  codex: Object.freeze({ endpoint: "responses", ingressFormat: "openai-responses", wirePath: "/openai/responses" })
+});
+var ERROR_DEFAULTS = {
+  invalid_request: { status: 400, retryable: false },
+  runtime_unsupported: { status: 400, retryable: false },
+  model_not_configured: { status: 400, retryable: false },
+  format_unsupported: { status: 400, retryable: false },
+  control_unauthorized: { status: 403, retryable: false },
+  upstream_not_found: { status: 404, retryable: false },
+  lease_not_found: { status: 404, retryable: false },
+  idempotency_conflict: { status: 409, retryable: false },
+  upstream_unavailable: { status: 409, retryable: true },
+  lease_expired: { status: 410, retryable: false },
+  upstream_exhausted: { status: 429, retryable: true },
+  daemon_not_ready: { status: 503, retryable: true }
+};
+var RouteLeaseError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.code = code;
+    this.name = "RouteLeaseError";
+    const defaults = ERROR_DEFAULTS[code];
+    this.status = options.status ?? defaults.status;
+    this.retryable = options.retryable ?? defaults.retryable;
+    if (options.retryAfterSeconds !== void 0) {
+      this.retryAfterSeconds = Math.max(1, Math.min(3600, Math.floor(options.retryAfterSeconds)));
+    }
+  }
+  code;
+  type = "route_lease_error";
+  status;
+  retryable;
+  retryAfterSeconds;
+  toResponse() {
+    return { error: { type: this.type, code: this.code, message: this.message, retryable: this.retryable } };
+  }
+};
+var IDEMPOTENCY_RE = /^[A-Za-z0-9._:-]+$/u;
+var CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/u;
+var PROCESS_SESSION_HMAC_KEY = randomBytes2(32);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function normalizedString(value, field, maxBytes, options = {}) {
+  if (typeof value !== "string") throw invalid(`${field} must be a string`);
+  const normalized = value.trim();
+  if (!normalized || byteLength(normalized) > maxBytes || CONTROL_RE.test(normalized)) {
+    throw invalid(`${field} is invalid`);
+  }
+  if (options.asciiPattern && !options.asciiPattern.test(normalized)) {
+    throw invalid(`${field} is invalid`);
+  }
+  return normalized;
+}
+function optionalExecutionId(value, field) {
+  return value === void 0 ? void 0 : normalizedString(value, field, ROUTE_LEASE_MAX_EXECUTION_ID_BYTES);
+}
+function invalid(message) {
+  return new RouteLeaseError("invalid_request", message);
+}
+function normalizeRouteLeaseIdempotencyKey(value) {
+  return normalizedString(value, "Idempotency-Key", ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES, {
+    asciiPattern: IDEMPOTENCY_RE
+  });
+}
+function normalizeRouteLeaseTtl(value) {
+  if (value === void 0) return ROUTE_LEASE_DEFAULT_TTL_SECONDS;
+  if (!Number.isInteger(value) || value < 1 || value > ROUTE_LEASE_MAX_TTL_SECONDS) {
+    throw invalid(`ttlSeconds must be an integer from 1 to ${ROUTE_LEASE_MAX_TTL_SECONDS}`);
+  }
+  return value;
+}
+function normalizeUpstream(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") throw invalid("upstream is invalid");
+  const providerId = normalizedString(value.providerId, "upstream.providerId", 128);
+  switch (value.kind) {
+    case "provider": {
+      const keyId = value.keyId === void 0 ? void 0 : normalizedString(value.keyId, "upstream.keyId", 128);
+      return keyId ? { kind: "provider", providerId, keyId } : { kind: "provider", providerId };
+    }
+    case "account":
+      return {
+        kind: "account",
+        providerId,
+        accountId: normalizedString(value.accountId, "upstream.accountId", 128)
+      };
+    case "account-group":
+      return {
+        kind: "account-group",
+        providerId,
+        group: normalizedString(value.group, "upstream.group", 128)
+      };
+    case "account-pool":
+      return { kind: "account-pool", providerId };
+    default:
+      throw invalid("upstream kind is unsupported");
+  }
+}
+function hashRouteLeaseSessionId(sessionId, hmacKey = PROCESS_SESSION_HMAC_KEY) {
+  return createHmac("sha256", hmacKey).update(ROUTE_LEASE_SESSION_HASH_DOMAIN, "utf8").update("\0", "utf8").update(sessionId, "utf8").digest("hex");
+}
+function canonicalizeRouteLeasePayload(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalizeRouteLeasePayload(entry)).join(",")}]`;
+  }
+  const record = value;
+  const fields = Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalizeRouteLeasePayload(record[key])}`);
+  return `{${fields.join(",")}}`;
+}
+function hashRouteLeasePayload(value) {
+  return createHash("sha256").update(canonicalizeRouteLeasePayload(value), "utf8").digest("hex");
+}
+function parseRouteLeaseCreate(raw, idempotencyHeader, hmacKey = PROCESS_SESSION_HMAC_KEY) {
+  if (!isRecord(raw)) throw invalid("request body must be a JSON object");
+  if (raw.schemaVersion !== ROUTE_LEASE_REQUEST_SCHEMA) {
+    throw invalid(`schemaVersion must be ${ROUTE_LEASE_REQUEST_SCHEMA}`);
+  }
+  const consumer = normalizedString(raw.consumer, "consumer", ROUTE_LEASE_MAX_CONSUMER_BYTES);
+  const runtime = raw.runtime;
+  if (runtime !== "claude" && runtime !== "codex") {
+    throw new RouteLeaseError("runtime_unsupported", "runtime is unsupported");
+  }
+  const upstream = normalizeUpstream(raw.upstream);
+  if (typeof raw.model !== "string" || raw.model.trim().length === 0) {
+    throw new RouteLeaseError("model_not_configured", "model is not configured");
+  }
+  const model = normalizedString(raw.model, "model", ROUTE_LEASE_MAX_MODEL_BYTES);
+  const ttlSeconds = normalizeRouteLeaseTtl(raw.ttlSeconds);
+  const idempotencyKey = normalizeRouteLeaseIdempotencyKey(idempotencyHeader);
+  let execution;
+  let semanticExecution;
+  if (raw.execution !== void 0) {
+    if (!isRecord(raw.execution)) throw invalid("execution must be a JSON object");
+    const runId = optionalExecutionId(raw.execution.runId, "execution.runId");
+    const stageId = optionalExecutionId(raw.execution.stageId, "execution.stageId");
+    let attempt;
+    if (raw.execution.attempt !== void 0) {
+      if (!Number.isSafeInteger(raw.execution.attempt) || raw.execution.attempt < 1) {
+        throw invalid("execution.attempt must be a positive integer");
+      }
+      attempt = raw.execution.attempt;
+    }
+    let sessionId;
+    let sessionIdHash;
+    if (raw.execution.sessionId !== void 0) {
+      sessionId = normalizedString(raw.execution.sessionId, "execution.sessionId", ROUTE_LEASE_MAX_SESSION_ID_BYTES);
+      sessionIdHash = hashRouteLeaseSessionId(sessionId, hmacKey);
+    }
+    if (runId !== void 0 || stageId !== void 0 || attempt !== void 0 || sessionIdHash !== void 0) {
+      execution = { runId, stageId, attempt, sessionIdHash };
+      semanticExecution = { runId, stageId, attempt, sessionId };
+    }
+  }
+  const request = {
+    schemaVersion: ROUTE_LEASE_REQUEST_SCHEMA,
+    consumer,
+    runtime,
+    upstream,
+    model,
+    ...execution ? { execution } : {},
+    ttlSeconds
+  };
+  const semanticPayload = {
+    schemaVersion: request.schemaVersion,
+    consumer,
+    runtime,
+    upstream,
+    model,
+    ...semanticExecution ? { execution: semanticExecution } : {},
+    ttlSeconds
+  };
+  return { request, idempotencyKey, payloadHash: hashRouteLeasePayload(semanticPayload) };
+}
+function routeLeaseRuntime(runtime) {
+  switch (runtime) {
+    case "claude":
+      return ROUTE_LEASE_RUNTIME_TABLE.claude;
+    case "codex":
+      return ROUTE_LEASE_RUNTIME_TABLE.codex;
+    default: {
+      const exhaustive = runtime;
+      throw new RouteLeaseError("runtime_unsupported", `runtime is unsupported: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/provider-proxy/RouteLeaseManager.ts
+var SYSTEM_ROUTE_LEASE_CLOCK = {
+  now: () => Date.now(),
+  setTimeout(callback, delayMs) {
+    const timer = setTimeout(callback, delayMs);
+    timer.unref?.();
+    return timer;
+  },
+  clearTimeout(handle) {
+    clearTimeout(handle);
+  }
+};
+function cloneUpstream(upstream) {
+  return { ...upstream };
+}
+function metadataCopy(metadata) {
+  return {
+    ...metadata,
+    upstream: cloneUpstream(metadata.upstream),
+    ...metadata.execution ? { execution: { ...metadata.execution } } : {}
+  };
+}
+var RouteLeaseManager = class {
+  constructor(routePort, targetResolver, descriptors, options = {}) {
+    this.routePort = routePort;
+    this.targetResolver = targetResolver;
+    this.descriptors = descriptors;
+    this.clock = options.clock ?? SYSTEM_ROUTE_LEASE_CLOCK;
+    this.hmacKey = options.hmacKey ?? randomBytes3(32);
+    this.tombstoneMaxCount = Math.max(1, options.tombstoneMaxCount ?? 512);
+    this.tombstoneMaxAgeMs = Math.max(1, options.tombstoneMaxAgeMs ?? 60 * 60 * 1e3);
+    this.logger = options.logger;
+    this.afterPublish = options.afterPublish;
+  }
+  routePort;
+  targetResolver;
+  descriptors;
+  active = /* @__PURE__ */ new Map();
+  idempotency = /* @__PURE__ */ new Map();
+  pendingCreates = /* @__PURE__ */ new Map();
+  tombstones = /* @__PURE__ */ new Map();
+  clock;
+  hmacKey;
+  tombstoneMaxCount;
+  tombstoneMaxAgeMs;
+  logger;
+  afterPublish;
+  closed = false;
+  parse(raw, idempotencyKey) {
+    return parseRouteLeaseCreate(raw, idempotencyKey, this.hmacKey);
+  }
+  async createFromRequest(raw, idempotencyKey) {
+    return this.create(this.parse(raw, idempotencyKey));
+  }
+  async create(input) {
+    if (this.closed) throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+    const request = input.request;
+    const scope = `${request.consumer}\0${input.idempotencyKey}`;
+    const existing = this.idempotency.get(scope);
+    if (existing) {
+      const lease = this.active.get(existing.leaseId);
+      if (!lease) {
+        this.idempotency.delete(scope);
+      } else if (existing.payloadHash !== input.payloadHash) {
+        throw new RouteLeaseError("idempotency_conflict", "idempotency key is already used for a different live request");
+      } else {
+        return { created: false, result: lease.result };
+      }
+    }
+    const pending = this.pendingCreates.get(scope);
+    if (pending) {
+      if (pending.payloadHash !== input.payloadHash) {
+        throw new RouteLeaseError("idempotency_conflict", "idempotency key is already used for a different live request");
+      }
+      const outcome2 = await pending.outcome;
+      return { created: false, result: outcome2.result };
+    }
+    const outcome = this.createNew(input, scope);
+    const pendingCreate = { payloadHash: input.payloadHash, outcome };
+    this.pendingCreates.set(scope, pendingCreate);
+    try {
+      return await outcome;
+    } finally {
+      if (this.pendingCreates.get(scope) === pendingCreate) this.pendingCreates.delete(scope);
+    }
+  }
+  async createNew(input, scope) {
+    const request = input.request;
+    if (!this.routePort.isReady()) {
+      throw new RouteLeaseError("daemon_not_ready", "resident provider proxy is not ready");
+    }
+    if (!this.descriptors.has(request.runtime)) {
+      throw new RouteLeaseError("runtime_unsupported", "runtime launch adapter is unavailable");
+    }
+    const leaseId = randomUUID();
+    const resolved = await this.targetResolver.resolve(request);
+    this.assertOpen();
+    const route = {
+      ...resolved,
+      sessionId: request.execution?.sessionIdHash ?? null,
+      routeLease: {
+        leaseId,
+        consumer: request.consumer,
+        ...request.execution?.runId ? { runId: request.execution.runId } : {},
+        ...request.execution?.stageId ? { stageId: request.execution.stageId } : {}
+      }
+    };
+    const now = this.clock.now();
+    const ttlMs = request.ttlSeconds * 1e3;
+    const expiresAtMs = now + ttlMs;
+    let routeToken;
+    let published = false;
+    let activeLease;
+    try {
+      routeToken = this.routePort.addRoute(route, {
+        idleMs: ttlMs,
+        onActivity: (at) => this.noteActivity(leaseId, at),
+        onEvicted: () => this.onRouteEvicted(leaseId)
+      });
+      const launch = this.descriptors.build(request.runtime, {
+        proxyBaseUrl: this.routePort.getBaseUrl(),
+        model: request.model,
+        routeToken
+      });
+      this.assertOpen();
+      const metadata = {
+        leaseId,
+        consumer: request.consumer,
+        runtime: request.runtime,
+        upstream: cloneUpstream(request.upstream),
+        model: request.model,
+        createdAt: new Date(now).toISOString(),
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        status: "active",
+        ...request.execution ? { execution: { ...request.execution } } : {}
+      };
+      const result = {
+        schemaVersion: ROUTE_LEASE_RESULT_SCHEMA,
+        ...metadata,
+        status: "active",
+        launch: { env: { ...launch.env }, extraArgs: [...launch.extraArgs] }
+      };
+      const timer = this.clock.setTimeout(() => this.expire(leaseId), ttlMs);
+      activeLease = {
+        leaseId,
+        routeToken,
+        idempotencyScope: scope,
+        payloadHash: input.payloadHash,
+        request,
+        route,
+        result,
+        metadata,
+        expiresAtMs,
+        timer
+      };
+      this.assertOpen();
+      this.active.set(leaseId, activeLease);
+      this.idempotency.set(scope, { leaseId, payloadHash: input.payloadHash });
+      published = true;
+      this.afterPublish?.();
+      if (this.closed) {
+        this.finalize(activeLease, "released");
+        throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+      }
+      return { created: true, result };
+    } catch (error) {
+      if (published && activeLease) {
+        this.active.delete(leaseId);
+        this.idempotency.delete(scope);
+        this.clock.clearTimeout(activeLease.timer);
+      }
+      if (routeToken) this.safeRemoveRoute(routeToken, leaseId);
+      if (error instanceof RouteLeaseError) throw error;
+      throw new RouteLeaseError("upstream_unavailable", "route lease creation failed safely", { cause: error });
+    }
+  }
+  list() {
+    this.pruneTombstones();
+    return [
+      ...[...this.active.values()].map((lease) => metadataCopy(lease.metadata)),
+      ...[...this.tombstones.values()].map((entry) => metadataCopy(entry.metadata))
+    ].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+  get(leaseId) {
+    const active = this.active.get(leaseId);
+    if (active) return metadataCopy(active.metadata);
+    this.pruneTombstones();
+    const tombstone = this.tombstones.get(leaseId);
+    if (tombstone) return metadataCopy(tombstone.metadata);
+    throw new RouteLeaseError("lease_not_found", "route lease was not found");
+  }
+  renew(leaseId, ttlSeconds) {
+    const lease = this.active.get(leaseId);
+    if (!lease) {
+      this.pruneTombstones();
+      const known = this.tombstones.get(leaseId);
+      if (known?.metadata.status === "expired") {
+        throw new RouteLeaseError("lease_expired", "route lease has expired");
+      }
+      throw new RouteLeaseError("lease_not_found", "route lease was not found");
+    }
+    const now = this.clock.now();
+    if (now >= lease.expiresAtMs) {
+      this.finalize(lease, "expired");
+      throw new RouteLeaseError("lease_expired", "route lease has expired");
+    }
+    const ttlMs = ttlSeconds * 1e3;
+    const expiresAtMs = now + ttlMs;
+    const nextTimer = this.clock.setTimeout(() => this.expire(leaseId), ttlMs);
+    const previousTimer = lease.timer;
+    lease.timer = nextTimer;
+    lease.expiresAtMs = expiresAtMs;
+    lease.metadata = { ...lease.metadata, expiresAt: new Date(expiresAtMs).toISOString() };
+    this.clock.clearTimeout(previousTimer);
+    if (!this.routePort.renewRoute(lease.routeToken, ttlMs)) {
+      this.finalize(lease, "expired", true);
+      throw new RouteLeaseError("lease_expired", "route lease route has expired");
+    }
+    return { leaseId, expiresAt: lease.metadata.expiresAt, status: "active" };
+  }
+  release(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (!lease) return { leaseId, released: false };
+    this.finalize(lease, "released");
+    return { leaseId, released: true };
+  }
+  shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const lease of [...this.active.values()]) {
+      try {
+        this.finalize(lease, "released");
+      } catch (error) {
+        this.logger?.warn("route lease cleanup failed during shutdown", { leaseId: lease.leaseId, error: safeErrorName(error) });
+      }
+    }
+  }
+  activeCount() {
+    return this.active.size;
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new RouteLeaseError("daemon_not_ready", "route lease manager is shutting down");
+    }
+  }
+  noteActivity(leaseId, at) {
+    const lease = this.active.get(leaseId);
+    if (!lease || at >= lease.expiresAtMs) return;
+    lease.metadata = { ...lease.metadata, lastActivityAt: new Date(at).toISOString() };
+  }
+  onRouteEvicted(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (lease) this.finalize(lease, "expired", true);
+  }
+  expire(leaseId) {
+    const lease = this.active.get(leaseId);
+    if (!lease) return;
+    const remaining = lease.expiresAtMs - this.clock.now();
+    if (remaining > 0) {
+      lease.timer = this.clock.setTimeout(() => this.expire(leaseId), remaining);
+      return;
+    }
+    this.finalize(lease, "expired");
+  }
+  finalize(lease, status, routeAlreadyGone = false) {
+    if (this.active.get(lease.leaseId) !== lease) return;
+    this.active.delete(lease.leaseId);
+    this.idempotency.delete(lease.idempotencyScope);
+    this.clock.clearTimeout(lease.timer);
+    if (!routeAlreadyGone) this.safeRemoveRoute(lease.routeToken, lease.leaseId);
+    const metadata = { ...lease.metadata, status };
+    this.tombstones.delete(lease.leaseId);
+    this.tombstones.set(lease.leaseId, { metadata, terminalAtMs: this.clock.now() });
+    this.pruneTombstones();
+  }
+  safeRemoveRoute(routeToken, leaseId) {
+    try {
+      this.routePort.removeRoute(routeToken);
+    } catch (error) {
+      this.logger?.warn("route lease route cleanup failed", { leaseId, error: safeErrorName(error) });
+    }
+  }
+  pruneTombstones() {
+    const cutoff = this.clock.now() - this.tombstoneMaxAgeMs;
+    for (const [leaseId, tombstone] of this.tombstones) {
+      if (tombstone.terminalAtMs < cutoff) this.tombstones.delete(leaseId);
+    }
+    while (this.tombstones.size > this.tombstoneMaxCount) {
+      const oldest = this.tombstones.keys().next().value;
+      if (!oldest) break;
+      this.tombstones.delete(oldest);
+    }
+  }
+};
+function safeErrorName(error) {
+  return error instanceof Error ? error.name : "unknown";
+}
+
+// src/outbound-api/gatewayBindingResolver.ts
+var MESSAGE_FALLBACK_KINDS = ["sonnet", "opus", "haiku", "fable"];
+function nonBlank(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function gatewayBindingAllowsKey(binding, apiKeyId) {
+  const scope = binding.keyScope ?? (binding.apiKeyIds?.length ? "selected" : "all");
+  return scope === "all" || Boolean(binding.apiKeyIds?.includes(apiKeyId));
+}
+function wildcardMatches(pattern, value) {
+  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join(".*");
+  return new RegExp(`^${escaped}$`, "iu").test(value);
+}
+function resolveGatewayModelMapping(mappings, requestedModel) {
+  if (!nonBlank(requestedModel)) return void 0;
+  const wanted = requestedModel.trim();
+  const exact = (mappings ?? []).find(
+    (mapping) => nonBlank(mapping.source) && !mapping.source.includes("*") && mapping.source.trim().toLocaleLowerCase() === wanted.toLocaleLowerCase()
+  );
+  if (exact && nonBlank(exact.target)) return exact.target.trim();
+  const wildcard = (mappings ?? []).find(
+    (mapping) => nonBlank(mapping.source) && mapping.source.includes("*") && wildcardMatches(mapping.source.trim(), wanted)
+  );
+  return wildcard && nonBlank(wildcard.target) ? wildcard.target.trim() : void 0;
+}
+function routeCanServe(binding, requestedModel, role) {
+  if (binding.modelMode === "passthrough") return nonBlank(requestedModel);
+  if (binding.modelMappings?.length) {
+    return nonBlank(resolveGatewayModelMapping(binding.modelMappings, requestedModel));
+  }
+  if (isKindMappedEndpoint(binding.endpoint)) {
+    const map = binding.modelMap ?? {};
+    const kind = detectModelKind(binding.endpoint, requestedModel);
+    if (kind && nonBlank(map[kind])) return true;
+    if (binding.endpoint === "messages") {
+      return MESSAGE_FALLBACK_KINDS.some((candidate) => nonBlank(map[candidate]));
+    }
+    return nonBlank(map.codex);
+  }
+  if (binding.endpoint === "chat" && binding.dispatchMode === "prefix") {
+    return resolvePrefixTarget(binding.prefixTargets, requestedModel) !== null;
+  }
+  if (binding.endpoint === "chat") {
+    if (!requestedModel) return false;
+    const wanted = requestedModel.trim().toLowerCase();
+    return (binding.models ?? []).some((ref) => modelIdOf(ref)?.toLowerCase() === wanted);
+  }
+  return role === "background" ? nonBlank(binding.backgroundModel) : nonBlank(binding.defaultModel);
+}
+function modelIdOf(ref) {
+  if (!nonBlank(ref)) return void 0;
+  const trimmed = ref.trim();
+  const comma = trimmed.indexOf(",");
+  const modelId = comma >= 0 ? trimmed.slice(comma + 1).trim() : trimmed;
+  return modelId || void 0;
+}
+function targetProviderId(target) {
+  return target.providerId.trim();
+}
+function targetRef(target, ref) {
+  const modelId = modelIdOf(ref) ?? "";
+  return modelId ? `${targetProviderId(target)},${modelId}` : "";
+}
+function targetRefs(target, refs) {
+  return (refs ?? []).map((ref) => targetRef(target, ref)).filter(nonBlank);
+}
+function targetPrefixRefs(target, refs) {
+  if (!refs) return void 0;
+  const mapped = {};
+  for (const kind of ["claude", "gpt", "gemini"]) {
+    const ref = targetRef(target, refs[kind]);
+    if (ref) mapped[kind] = ref;
+  }
+  return mapped.claude || mapped.gpt || mapped.gemini ? mapped : void 0;
+}
+function applySingleModel(config, binding, targetModel) {
+  const ref = targetRef(binding.target, targetModel);
+  if (!ref) return;
+  if (isKindMappedEndpoint(binding.endpoint)) {
+    config.modelMap = Object.fromEntries(
+      modelKindsForEndpoint(binding.endpoint).map((kind) => [kind, ref])
+    );
+  } else if (binding.endpoint === "chat") {
+    config.models = [ref];
+    config.dispatchMode = "list";
+  } else {
+    config.defaultModel = ref;
+    config.backgroundModel = ref;
+  }
+}
+function gatewayBindingToEndpointConfig(binding, requestedModel) {
+  const target = binding.target;
+  const config = {
+    endpoint: binding.endpoint,
+    useSubscription: target.kind !== "provider"
+  };
+  const usesGenericModelHandling = binding.modelMode === "passthrough" || Boolean(binding.modelMappings?.length);
+  const dynamicModel = binding.modelMode === "passthrough" ? requestedModel : resolveGatewayModelMapping(binding.modelMappings, requestedModel);
+  if (usesGenericModelHandling) {
+    if (nonBlank(dynamicModel)) applySingleModel(config, binding, dynamicModel);
+  } else if (isKindMappedEndpoint(binding.endpoint)) {
+    config.modelMap = Object.fromEntries(
+      Object.entries(binding.modelMap ?? {}).map(([kind, ref]) => [kind, targetRef(target, ref)])
+    );
+  } else if (binding.endpoint === "chat") {
+    config.models = targetRefs(target, binding.models);
+    if (binding.dispatchMode === "prefix") {
+      config.dispatchMode = "prefix";
+      config.prefixTargets = targetPrefixRefs(target, binding.prefixTargets);
+    }
+  } else {
+    config.defaultModel = targetRef(target, binding.defaultModel);
+    config.backgroundModel = targetRef(target, binding.backgroundModel);
+    if (binding.backgroundModelIds) config.backgroundModelIds = [...binding.backgroundModelIds];
+  }
+  if (target.kind === "account") {
+    config.boundAccountId = target.accountId;
+    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  } else if (target.kind === "account-group") {
+    config.boundAccountGroup = target.group;
+    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  } else if (target.kind === "provider" && target.keyId) {
+    config.boundKeyId = target.keyId;
+    config.boundKeyFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
+  }
+  return config;
+}
+function candidateGatewayBindings(bindings, apiKeyId, endpoint) {
+  const candidates = (bindings ?? []).filter(
+    (binding) => binding.enabled && binding.endpoint === endpoint && gatewayBindingAllowsKey(binding, apiKeyId)
+  );
+  const scopeOf = (binding) => binding.keyScope ?? (binding.apiKeyIds?.length ? "selected" : "all");
+  const scoped = candidates.filter((binding) => scopeOf(binding) === "selected");
+  const pool = scoped.length > 0 ? scoped : candidates.filter((binding) => scopeOf(binding) === "all");
+  return pool.sort(
+    (left, right) => (left.priority ?? 100) - (right.priority ?? 100) || left.id.localeCompare(right.id)
+  );
+}
+function candidateBackgroundModelIds(bindings, apiKeyId, endpoint) {
+  const ids = [
+    ...new Set(
+      candidateGatewayBindings(bindings, apiKeyId, endpoint).flatMap(
+        (binding) => binding.backgroundModelIds ?? []
+      )
+    )
+  ];
+  return ids.length > 0 ? ids : void 0;
+}
+function resolveGatewayBinding(input) {
+  const candidates = candidateGatewayBindings(input.bindings, input.apiKeyId, input.endpoint);
+  const binding = candidates.find(
+    (candidate) => candidate.fallback === "fail" || routeCanServe(candidate, input.requestedModel, input.role)
+  ) ?? candidates[0];
+  if (!binding) return { source: "none" };
+  return {
+    source: "binding",
+    binding,
+    config: gatewayBindingToEndpointConfig(binding, input.requestedModel)
+  };
+}
+
+// src/provider-proxy/RouteLeaseTargetResolver.ts
+function resolveEnvKey(raw) {
+  if (!raw) return "";
+  return raw.startsWith("$") ? process.env[raw.slice(1)] ?? "" : raw;
+}
+function providerSupportsModel(provider, model) {
+  const flat = provider.models ?? [];
+  const configured = provider.modelConfigs ?? [];
+  if (flat.length === 0 && configured.length === 0) return false;
+  return flat.includes(model) || configured.some((entry) => entry.id === model && entry.enabled !== false);
+}
+function syntheticBinding(request) {
+  const runtime = routeLeaseRuntime(request.runtime);
+  return {
+    id: "route-lease-ephemeral",
+    name: "Route Lease ephemeral target",
+    enabled: true,
+    endpoint: runtime.endpoint,
+    target: request.upstream,
+    fallback: "fail",
+    modelMode: "passthrough"
+  };
+}
+function transformerRegistered(llmConfig, name) {
+  return Boolean(llmConfig.getTransformerService()?.getTransformer(name));
+}
+var RouteLeaseTargetResolver = class {
+  constructor(llmConfig, options = {}) {
+    this.llmConfig = llmConfig;
+    this.options = options;
   }
-  /** Register a route for one run; returns the crypto route token (task 2.2). */
-  addRoute(context, idleMs) {
-    return this.routes.addRoute(context, idleMs);
+  llmConfig;
+  options;
+  async resolve(request) {
+    const runtime = routeLeaseRuntime(request.runtime);
+    await this.preflightTarget(request);
+    const binding = syntheticBinding(request);
+    const config = gatewayBindingToEndpointConfig(binding, request.model);
+    const result = await resolveRoute({
+      config,
+      ingressFormat: runtime.ingressFormat,
+      llmConfig: this.llmConfig,
+      requestedModel: request.model,
+      sessionId: request.execution?.sessionIdHash ?? null
+    });
+    if (!result.ok) {
+      throw new RouteLeaseError(
+        result.error.status === 404 ? "upstream_not_found" : "upstream_unavailable",
+        "the selected upstream could not be resolved"
+      );
+    }
+    return { ...result.route, requestedModel: void 0 };
   }
-  /** Remove a route at run end. Returns true if an entry existed. */
-  removeRoute(token) {
-    return this.routes.removeRoute(token);
+  async preflightTarget(request) {
+    const target = request.upstream;
+    if (target.kind !== "provider") {
+      await this.preflightSubscription(target, request.model);
+      return;
+    }
+    const provider = await this.llmConfig.getProvider(target.providerId);
+    if (!provider) throw new RouteLeaseError("upstream_not_found", "provider was not found");
+    if (provider.enabled === false) throw new RouteLeaseError("upstream_unavailable", "provider is disabled");
+    if (!providerSupportsModel(provider, request.model)) {
+      throw new RouteLeaseError("model_not_configured", "model is not configured for the provider");
+    }
+    if (target.keyId) {
+      const availability = await this.options.providerKeys?.getKeyAvailability?.(
+        target.providerId,
+        target.keyId
+      );
+      if (availability === "not-found") {
+        throw new RouteLeaseError("upstream_not_found", "the selected provider key was not found");
+      }
+      const usable = availability === "usable" || availability === void 0 && Boolean(this.options.providerKeys) && await this.options.providerKeys.hasUsableKey(target.providerId, target.keyId);
+      if (!usable) {
+        throw new RouteLeaseError("upstream_unavailable", "the selected provider key is unavailable");
+      }
+    } else {
+      const directKey = resolveEnvKey(provider.api_key);
+      const poolAvailability = await this.options.providerKeys?.getPoolAvailability?.(target.providerId);
+      const poolReady = poolAvailability ? poolAvailability.outcome === "usable" : this.options.providerKeys ? await this.options.providerKeys.hasUsableKeys(target.providerId) : false;
+      if (!directKey && poolAvailability?.outcome === "exhausted") {
+        throw new RouteLeaseError("upstream_exhausted", "provider key pool is temporarily exhausted", {
+          retryAfterSeconds: poolAvailability.retryAfterSeconds
+        });
+      }
+      if (!directKey && !poolReady) {
+        throw new RouteLeaseError("upstream_unavailable", "provider has no usable credential");
+      }
+    }
+    const sameFormat = request.runtime === "claude" && provider.apiFormat === "anthropic" || request.runtime === "codex" && provider.apiFormat === "openai-response";
+    if (!sameFormat) {
+      try {
+        const chain = await resolveProviderChain(this.llmConfig, provider.id, request.model);
+        if (!chain.hasTransformers) {
+          throw new RouteLeaseError("format_unsupported", "no transformer chain supports this runtime and upstream");
+        }
+      } catch (error) {
+        if (error instanceof RouteLeaseError) throw error;
+        throw new RouteLeaseError("format_unsupported", "the transformer chain could not be resolved", { cause: error });
+      }
+    }
   }
-  /** Live-route count (diagnostics / tests). */
-  routeCount() {
-    return this.routes.size();
+  async preflightSubscription(target, model) {
+    const registry = getSubscriptionRegistryForOutbound();
+    const profile = registry?.getProfile(target.providerId) ?? null;
+    if (!profile) throw new RouteLeaseError("upstream_not_found", "subscription provider was not found");
+    await this.options.subscriptions?.assertAvailable(target, model);
+    const names = profile.resolveProviderTransformerNames?.(model) ?? profile.providerTransformerNames ?? [];
+    if (names.some((name) => !transformerRegistered(this.llmConfig, name))) {
+      throw new RouteLeaseError("format_unsupported", "a required transformer is unavailable");
+    }
+    if (profile.modelTransformerNames?.some((name) => !transformerRegistered(this.llmConfig, name))) {
+      throw new RouteLeaseError("format_unsupported", "a required model transformer is unavailable");
+    }
   }
 };
 
@@ -2531,15 +3655,20 @@ function normalizeAudit(raw) {
   return {
     enabled: a?.enabled === true,
     captureBodies: a?.captureBodies === true,
-    maxBodyBytes: Math.trunc(
-      clampNumber(a?.maxBodyBytes, 256, 1048576, DEFAULT_AUDIT_CONFIG.maxBodyBytes)
-    ),
+    maxBodyBytes: normalizeMaxBodyBytes(a?.maxBodyBytes),
     retentionDays: Math.trunc(
       clampNumber(a?.retentionDays, 1, 365, DEFAULT_AUDIT_CONFIG.retentionDays)
     ),
     trustForwardedFor: a?.trustForwardedFor === true
   };
 }
+function normalizeMaxBodyBytes(value) {
+  if (value === -1) return -1;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return DEFAULT_AUDIT_CONFIG.maxBodyBytes;
+  }
+  return Math.trunc(Math.min(1048576, value));
+}
 function normalizeBilling(raw) {
   const b = raw?.billing;
   const config = {
@@ -2997,169 +4126,8 @@ function mergeServerConfig(current, patch) {
   });
 }
 
-// src/outbound-api/gatewayBindingResolver.ts
-var MESSAGE_FALLBACK_KINDS = ["sonnet", "opus", "haiku", "fable"];
-function nonBlank(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function gatewayBindingAllowsKey(binding, apiKeyId) {
-  const scope = binding.keyScope ?? (binding.apiKeyIds?.length ? "selected" : "all");
-  return scope === "all" || Boolean(binding.apiKeyIds?.includes(apiKeyId));
-}
-function wildcardMatches(pattern, value) {
-  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join(".*");
-  return new RegExp(`^${escaped}$`, "iu").test(value);
-}
-function resolveGatewayModelMapping(mappings, requestedModel) {
-  if (!nonBlank(requestedModel)) return void 0;
-  const wanted = requestedModel.trim();
-  const exact = (mappings ?? []).find(
-    (mapping) => nonBlank(mapping.source) && !mapping.source.includes("*") && mapping.source.trim().toLocaleLowerCase() === wanted.toLocaleLowerCase()
-  );
-  if (exact && nonBlank(exact.target)) return exact.target.trim();
-  const wildcard = (mappings ?? []).find(
-    (mapping) => nonBlank(mapping.source) && mapping.source.includes("*") && wildcardMatches(mapping.source.trim(), wanted)
-  );
-  return wildcard && nonBlank(wildcard.target) ? wildcard.target.trim() : void 0;
-}
-function routeCanServe(binding, requestedModel, role) {
-  if (binding.modelMode === "passthrough") return nonBlank(requestedModel);
-  if (binding.modelMappings?.length) {
-    return nonBlank(resolveGatewayModelMapping(binding.modelMappings, requestedModel));
-  }
-  if (isKindMappedEndpoint(binding.endpoint)) {
-    const map = binding.modelMap ?? {};
-    const kind = detectModelKind(binding.endpoint, requestedModel);
-    if (kind && nonBlank(map[kind])) return true;
-    if (binding.endpoint === "messages") {
-      return MESSAGE_FALLBACK_KINDS.some((candidate) => nonBlank(map[candidate]));
-    }
-    return nonBlank(map.codex);
-  }
-  if (binding.endpoint === "chat" && binding.dispatchMode === "prefix") {
-    return resolvePrefixTarget(binding.prefixTargets, requestedModel) !== null;
-  }
-  if (binding.endpoint === "chat") {
-    if (!requestedModel) return false;
-    const wanted = requestedModel.trim().toLowerCase();
-    return (binding.models ?? []).some((ref) => modelIdOf(ref)?.toLowerCase() === wanted);
-  }
-  return role === "background" ? nonBlank(binding.backgroundModel) : nonBlank(binding.defaultModel);
-}
-function modelIdOf(ref) {
-  if (!nonBlank(ref)) return void 0;
-  const trimmed = ref.trim();
-  const comma = trimmed.indexOf(",");
-  const modelId = comma >= 0 ? trimmed.slice(comma + 1).trim() : trimmed;
-  return modelId || void 0;
-}
-function targetProviderId(target) {
-  return target.providerId.trim();
-}
-function targetRef(target, ref) {
-  const modelId = modelIdOf(ref) ?? "";
-  return modelId ? `${targetProviderId(target)},${modelId}` : "";
-}
-function targetRefs(target, refs) {
-  return (refs ?? []).map((ref) => targetRef(target, ref)).filter(nonBlank);
-}
-function targetPrefixRefs(target, refs) {
-  if (!refs) return void 0;
-  const mapped = {};
-  for (const kind of ["claude", "gpt", "gemini"]) {
-    const ref = targetRef(target, refs[kind]);
-    if (ref) mapped[kind] = ref;
-  }
-  return mapped.claude || mapped.gpt || mapped.gemini ? mapped : void 0;
-}
-function applySingleModel(config, binding, targetModel) {
-  const ref = targetRef(binding.target, targetModel);
-  if (!ref) return;
-  if (isKindMappedEndpoint(binding.endpoint)) {
-    config.modelMap = Object.fromEntries(
-      modelKindsForEndpoint(binding.endpoint).map((kind) => [kind, ref])
-    );
-  } else if (binding.endpoint === "chat") {
-    config.models = [ref];
-    config.dispatchMode = "list";
-  } else {
-    config.defaultModel = ref;
-    config.backgroundModel = ref;
-  }
-}
-function gatewayBindingToEndpointConfig(binding, requestedModel) {
-  const target = binding.target;
-  const config = {
-    endpoint: binding.endpoint,
-    useSubscription: target.kind !== "provider"
-  };
-  const usesGenericModelHandling = binding.modelMode === "passthrough" || Boolean(binding.modelMappings?.length);
-  const dynamicModel = binding.modelMode === "passthrough" ? requestedModel : resolveGatewayModelMapping(binding.modelMappings, requestedModel);
-  if (usesGenericModelHandling) {
-    if (nonBlank(dynamicModel)) applySingleModel(config, binding, dynamicModel);
-  } else if (isKindMappedEndpoint(binding.endpoint)) {
-    config.modelMap = Object.fromEntries(
-      Object.entries(binding.modelMap ?? {}).map(([kind, ref]) => [kind, targetRef(target, ref)])
-    );
-  } else if (binding.endpoint === "chat") {
-    config.models = targetRefs(target, binding.models);
-    if (binding.dispatchMode === "prefix") {
-      config.dispatchMode = "prefix";
-      config.prefixTargets = targetPrefixRefs(target, binding.prefixTargets);
-    }
-  } else {
-    config.defaultModel = targetRef(target, binding.defaultModel);
-    config.backgroundModel = targetRef(target, binding.backgroundModel);
-    if (binding.backgroundModelIds) config.backgroundModelIds = [...binding.backgroundModelIds];
-  }
-  if (target.kind === "account") {
-    config.boundAccountId = target.accountId;
-    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  } else if (target.kind === "account-group") {
-    config.boundAccountGroup = target.group;
-    config.boundAccountFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  } else if (target.kind === "provider" && target.keyId) {
-    config.boundKeyId = target.keyId;
-    config.boundKeyFallbackPolicy = binding.fallback === "next" ? "pool" : "strict";
-  }
-  return config;
-}
-function candidateGatewayBindings(bindings, apiKeyId, endpoint) {
-  const candidates = (bindings ?? []).filter(
-    (binding) => binding.enabled && binding.endpoint === endpoint && gatewayBindingAllowsKey(binding, apiKeyId)
-  );
-  const scopeOf = (binding) => binding.keyScope ?? (binding.apiKeyIds?.length ? "selected" : "all");
-  const scoped = candidates.filter((binding) => scopeOf(binding) === "selected");
-  const pool = scoped.length > 0 ? scoped : candidates.filter((binding) => scopeOf(binding) === "all");
-  return pool.sort(
-    (left, right) => (left.priority ?? 100) - (right.priority ?? 100) || left.id.localeCompare(right.id)
-  );
-}
-function candidateBackgroundModelIds(bindings, apiKeyId, endpoint) {
-  const ids = [
-    ...new Set(
-      candidateGatewayBindings(bindings, apiKeyId, endpoint).flatMap(
-        (binding) => binding.backgroundModelIds ?? []
-      )
-    )
-  ];
-  return ids.length > 0 ? ids : void 0;
-}
-function resolveGatewayBinding(input) {
-  const candidates = candidateGatewayBindings(input.bindings, input.apiKeyId, input.endpoint);
-  const binding = candidates.find(
-    (candidate) => candidate.fallback === "fail" || routeCanServe(candidate, input.requestedModel, input.role)
-  ) ?? candidates[0];
-  if (!binding) return { source: "none" };
-  return {
-    source: "binding",
-    binding,
-    config: gatewayBindingToEndpointConfig(binding, input.requestedModel)
-  };
-}
-
 // src/outbound-api/outboundApiKeyAuth.ts
-import { createHash, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes4 } from "crypto";
 
 // src/outbound-api/keyPolicy.ts
 var DAY_MS = 864e5;
@@ -3211,7 +4179,7 @@ var BASE62_REJECT_THRESHOLD = 248;
 function randomBase62(count) {
   let out = "";
   while (out.length < count) {
-    const buf = randomBytes2(count - out.length + 8);
+    const buf = randomBytes4(count - out.length + 8);
     for (const byte of buf) {
       if (out.length >= count) break;
       if (byte >= BASE62_REJECT_THRESHOLD) continue;
@@ -3224,13 +4192,13 @@ function generateSecret() {
   return KEY_PREFIX + randomBase62(SECRET_BYTES);
 }
 function hashKey(secret) {
-  return createHash("sha256").update(secret, "utf8").digest("hex");
+  return createHash2("sha256").update(secret, "utf8").digest("hex");
 }
 function keyPrefix(secret) {
   return secret.slice(0, PREFIX_LEN);
 }
 function newKeyId() {
-  return `oak_${Date.now()}_${randomBytes2(6).toString("hex")}`;
+  return `oak_${Date.now()}_${randomBytes4(6).toString("hex")}`;
 }
 async function createNamedKey(db, name) {
   const secret = generateSecret();
@@ -3240,7 +4208,8 @@ async function createNamedKey(db, name) {
     id,
     name,
     keyHash: hashKey(secret),
-    keyPrefix: prefix
+    keyPrefix: prefix,
+    plaintext: secret
   });
   return {
     id: row.id,
@@ -3261,7 +4230,8 @@ async function createIntegrationKey(db, name, allowedEndpoints = ["responses", "
     keyPrefix: prefix,
     kind: "integration",
     allowedEndpoints: [...new Set(allowedEndpoints)],
-    loopbackOnly: true
+    loopbackOnly: true,
+    plaintext: secret
   });
   return {
     id: row.id,
@@ -3748,7 +4718,7 @@ var UserMessageSerialQueue = class {
 };
 
 // src/outbound-api/voucher.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var CODE_ENTROPY_CHARS = 32;
 var CODE_PREFIX = "CC_";
 var DISPLAY_PREFIX_LEN = 8;
@@ -3757,7 +4727,7 @@ function generateVoucherCode() {
   return CODE_PREFIX + randomBase62(CODE_ENTROPY_CHARS);
 }
 function hashVoucherCode(code) {
-  return createHash2("sha256").update(code, "utf8").digest("hex");
+  return createHash3("sha256").update(code, "utf8").digest("hex");
 }
 function voucherCodePrefix(code) {
   return code.slice(0, DISPLAY_PREFIX_LEN);
@@ -6725,6 +7695,37 @@ export {
   extractRouteToken,
   isLoopbackAddress,
   ProviderProxy,
+  ROUTE_LEASE_REQUEST_SCHEMA,
+  ROUTE_LEASE_RESULT_SCHEMA,
+  ROUTE_LEASE_CAPABILITIES_SCHEMA,
+  ROUTE_LEASE_API_VERSION,
+  ROUTE_LEASE_DEFAULT_TTL_SECONDS,
+  ROUTE_LEASE_MAX_TTL_SECONDS,
+  ROUTE_LEASE_MAX_IDEMPOTENCY_BYTES,
+  ROUTE_LEASE_MAX_CONSUMER_BYTES,
+  ROUTE_LEASE_MAX_EXECUTION_ID_BYTES,
+  ROUTE_LEASE_MAX_SESSION_ID_BYTES,
+  ROUTE_LEASE_MAX_MODEL_BYTES,
+  ROUTE_LEASE_SESSION_HASH_DOMAIN,
+  ROUTE_LEASE_CODEX_TOKEN_ENV,
+  ROUTE_LEASE_RUNTIMES,
+  ROUTE_LEASE_CAPABILITIES,
+  ROUTE_LEASE_RUNTIME_TABLE,
+  RouteLeaseError,
+  normalizeRouteLeaseIdempotencyKey,
+  normalizeRouteLeaseTtl,
+  hashRouteLeaseSessionId,
+  canonicalizeRouteLeasePayload,
+  hashRouteLeasePayload,
+  parseRouteLeaseCreate,
+  routeLeaseRuntime,
+  SYSTEM_ROUTE_LEASE_CLOCK,
+  RouteLeaseManager,
+  gatewayBindingToEndpointConfig,
+  candidateGatewayBindings,
+  candidateBackgroundModelIds,
+  resolveGatewayBinding,
+  RouteLeaseTargetResolver,
   getProviderProxy,
   __resetProviderProxyForTests,
   KeyedMutex,
@@ -6753,10 +7754,6 @@ export {
   loadServerConfig,
   saveServerConfig,
   mergeServerConfig,
-  gatewayBindingToEndpointConfig,
-  candidateGatewayBindings,
-  candidateBackgroundModelIds,
-  resolveGatewayBinding,
   computeKeyExpiry,
   checkKeyQuota,
   randomBase62,