@omnicross/core 0.1.7 → 0.1.9

package/dist/{chunk-E3COOKUP.js → chunk-CQIJCPMF.js}

@@ -4,13 +4,13 @@ import {
 import {
   AnthropicTransformer,
   resolveAnthropicMaxTokens
-} from "./chunk-PEGTIPB3.js";
+} from "./chunk-HKB656B4.js";
 import {
   GeminiTransformer
-} from "./chunk-LVUCAWMK.js";
+} from "./chunk-55FMGZ3L.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-32O35CIF.js";
+} from "./chunk-45FHEOKW.js";
 import {
   TransformerChainExecutor
 } from "./chunk-WNKWAEUR.js";
@@ -94,6 +94,9 @@ import {
   resolvePrefixTarget,
   resolveRoute
 } from "./chunk-EBLFCNPY.js";
+import {
+  getSubscriptionRegistryForOutbound
+} from "./chunk-AQ5TNQB7.js";
 import {
   buildProviderApiUrl,
   resolveApiFormat,
@@ -106,6 +109,9 @@ import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
 } from "./chunk-5NJLQ6T6.js";
+import {
+  resolveReasoningPlan
+} from "./chunk-N2EIM2XJ.js";
 import {
   fetchUpstream
 } from "./chunk-RJ5ZGNI3.js";
@@ -410,9 +416,6 @@ function addOpenRouterProviderToRequest(requestBody, provider, modelId) {
   };
 }
 
-// src/completion/DirectApiHandler.ts
-import { getOpenAIReasoningEffort } from "@omnicross/contracts/thinking-config";
-
 // src/provider-proxy/ProviderProxy.ts
 import http from "http";
 
@@ -432,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);
@@ -452,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;
   }
@@ -459,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). */
@@ -473,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)
@@ -484,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?.();
   }
@@ -494,6 +515,15 @@ 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
@@ -583,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,
@@ -1142,7 +1176,7 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
       } : void 0
     }
   );
-  return { response, rawStatus: response.status };
+  return { response, rawStatus: response.status, actualModel: outboundModel };
 }
 function outboundRemapApplies(plan) {
   return plan.isSubscription && plan.transformerProvider.name === "claude";
@@ -1308,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
     };
@@ -1396,7 +1432,8 @@ async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   const sameFormat = route.targetProviderFormat === "anthropic" || resolveApiFormat(provider) === "anthropic";
@@ -1571,6 +1608,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,
@@ -1636,6 +1677,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
     };
@@ -1699,7 +1741,8 @@ async function buildByoPlan2(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -1792,6 +1835,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,
@@ -1844,6 +1891,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
     };
@@ -1911,7 +1959,8 @@ async function buildByoPlan3(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -2072,6 +2121,10 @@ 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,
@@ -2205,8 +2258,9 @@ async function handleOpenAIResponsesRequest(res, rawBody, route, deps, requestHe
     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.
@@ -2300,7 +2354,8 @@ async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
     name: provider.name,
     baseUrl: provider.api_base_url,
     apiKey,
-    models: provider.models || []
+    models: provider.models || [],
+    modelConfigs: provider.modelConfigs
   };
   const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
   return {
@@ -2391,6 +2446,7 @@ 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, {
@@ -2400,10 +2456,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,
@@ -2427,7 +2486,7 @@ async function runPipeline4(responsesBody, plan) {
       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) },
@@ -2438,7 +2497,7 @@ async function runPipeline4(responsesBody, plan) {
             endpoint: "responses",
             sessionKey,
             sessionSource: plan.sessionSource ?? "none",
-            model: resolvedModel,
+            model: actualModel,
             onRecorded: (record) => {
               activityRecordId = record.id;
             }
@@ -2451,7 +2510,7 @@ async function runPipeline4(responsesBody, plan) {
     },
     runResponseChain: true
   });
-  return { response, rawStatus, accountId: proxyAccountId, activityRecordId };
+  return { response, rawStatus, accountId: proxyAccountId, actualModel, activityRecordId };
 }
 async function runPipelineWithPoolReporting4(responsesBody, plan) {
   const first = await runPipeline4(responsesBody, plan);
@@ -2555,6 +2614,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.
@@ -2595,6 +2655,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;
@@ -2611,6 +2677,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
@@ -2627,17 +2702,817 @@ var ProviderProxy = class {
   getDeps() {
     return this.deps;
   }
-  /** Register a route for one run; returns the crypto route token (task 2.2). */
-  addRoute(context, idleMs) {
-    return this.routes.addRoute(context, idleMs);
+  /** Register a route for one run; returns the crypto route token (task 2.2). */
+  addRoute(context, idleMsOrOptions) {
+    return this.routes.addRoute(context, idleMsOrOptions);
+  }
+  /** Re-arm one route while retaining the exact same bearer token. */
+  renewRoute(token, idleMs) {
+    return this.routes.renewRoute(token, idleMs);
+  }
+  /** Remove a route at run end. Returns true if an entry existed. */
+  removeRoute(token) {
+    return this.routes.removeRoute(token);
+  }
+  /** Live-route count (diagnostics / tests). */
+  routeCount() {
+    return this.routes.size();
+  }
+};
+
+// 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;
+  }
+  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");
+    }
   }
 };
 
@@ -2691,6 +3566,7 @@ var KeyedMutex = class {
 
 // src/outbound-api/outboundApiRouter.ts
 import { Readable } from "stream";
+import { SUBSCRIPTION_MODEL_CATALOG } from "@omnicross/contracts/subscription-model-catalog";
 
 // src/outbound-api/apiServerConfig.ts
 import { DEFAULT_AUDIT_CONFIG } from "@omnicross/contracts/audit-types";
@@ -3255,169 +4131,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;
@@ -3469,7 +4184,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;
@@ -3482,13 +4197,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();
@@ -4008,7 +4723,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;
@@ -4017,7 +4732,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);
@@ -4277,33 +4992,51 @@ function isModelsListRequest(url) {
   const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
   return path.endsWith("/models");
 }
-function writeModelsList(res, config, apiKeyId, allowedEndpoints) {
-  const refs = [];
-  const endpointConfigs = [];
+async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoints) {
+  const modelIds = [];
   for (const endpoint of ["chat", "responses", "messages", "gemini"]) {
     if (allowedEndpoints && !allowedEndpoints.includes(endpoint)) continue;
-    endpointConfigs.push(
-      ...candidateGatewayBindings(config.bindings, apiKeyId, endpoint).map(
-        (binding) => gatewayBindingToEndpointConfig(binding)
-      )
-    );
-  }
-  for (const endpoint of endpointConfigs) {
-    if (allowedEndpoints && !allowedEndpoints.includes(endpoint.endpoint)) continue;
-    if (endpoint.endpoint === "chat") refs.push(...endpoint.models ?? []);
-    else if (endpoint.endpoint === "messages" || endpoint.endpoint === "responses") {
-      refs.push(...Object.values(endpoint.modelMap ?? {}));
-    } else {
-      if (endpoint.defaultModel) refs.push(endpoint.defaultModel);
-      if (endpoint.backgroundModel) refs.push(endpoint.backgroundModel);
+    for (const binding of candidateGatewayBindings(config.bindings, apiKeyId, endpoint)) {
+      if (binding.modelMode === "passthrough") {
+        if (binding.target.kind === "provider") {
+          const provider = await llmConfig.getProvider(binding.target.providerId);
+          modelIds.push(...provider?.models ?? []);
+        } else if (Object.prototype.hasOwnProperty.call(
+          SUBSCRIPTION_MODEL_CATALOG,
+          binding.target.providerId
+        )) {
+          modelIds.push(
+            ...SUBSCRIPTION_MODEL_CATALOG[binding.target.providerId]
+          );
+        }
+        continue;
+      }
+      if (binding.modelMappings?.length) {
+        modelIds.push(
+          ...binding.modelMappings.map((mapping) => mapping.source.trim()).filter((source) => source !== "" && !source.includes("*"))
+        );
+        continue;
+      }
+      const endpointConfig = gatewayBindingToEndpointConfig(binding);
+      const refs = [];
+      if (endpointConfig.endpoint === "chat") refs.push(...endpointConfig.models ?? []);
+      else if (endpointConfig.endpoint === "messages" || endpointConfig.endpoint === "responses") {
+        refs.push(...Object.values(endpointConfig.modelMap ?? {}));
+      } else {
+        if (endpointConfig.defaultModel) refs.push(endpointConfig.defaultModel);
+        if (endpointConfig.backgroundModel) refs.push(endpointConfig.backgroundModel);
+      }
+      modelIds.push(
+        ...refs.map((ref) => parseModelRef(ref)?.modelId).filter((modelId) => modelId !== void 0)
+      );
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  const data = refs.map((ref) => parseModelRef(ref)).filter((p) => p !== null).filter((p) => {
-    if (seen.has(p.modelId)) return false;
-    seen.add(p.modelId);
+  const data = modelIds.filter((modelId) => {
+    if (seen.has(modelId)) return false;
+    seen.add(modelId);
     return true;
-  }).map((p) => ({ id: p.modelId, object: "model", owned_by: "omnicross" }));
+  }).map((modelId) => ({ id: modelId, object: "model", owned_by: "omnicross" }));
   res.writeHead(200, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ object: "list", data }));
 }
@@ -4371,7 +5104,7 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       writeJsonError(res, 403, "API key is not allowed to access this endpoint");
       return;
     }
-    writeModelsList(res, config, verified.id, verified.allowedEndpoints);
+    await writeModelsList(res, deps.llmConfig, config, verified.id, verified.allowedEndpoints);
     return;
   }
   const endpoint = selectEndpoint(req.method, req.url);
@@ -4927,6 +5660,70 @@ function __resetOutboundApiServerForTests() {
   instance2 = null;
 }
 
+// src/completion/ReasoningRequestBuilder.ts
+var LEGACY_ANTHROPIC_MAX_TOKENS = 16384;
+function intentFromOptions(options) {
+  return options.thinkLevel ? { effort: options.thinkLevel, enabled: options.thinkLevel !== "none" } : void 0;
+}
+function resolveCompletionReasoningPlan(provider, options, target, requestMaxTokens = options.maxTokens) {
+  return resolveReasoningPlan({
+    intent: intentFromOptions(options),
+    model: options.model,
+    provider,
+    target,
+    requestMaxTokens
+  });
+}
+function resolveOpenAIEffort(provider, options, target) {
+  const plan = resolveCompletionReasoningPlan(provider, options, target);
+  return plan?.kind === "level" && plan.enabled ? plan.effort : void 0;
+}
+function buildAnthropicReasoningWire(provider, options) {
+  const configuredMaxTokens = options.maxTokens ?? LEGACY_ANTHROPIC_MAX_TOKENS;
+  const legacyBound = Math.min(configuredMaxTokens, LEGACY_ANTHROPIC_MAX_TOKENS);
+  const plan = resolveCompletionReasoningPlan(
+    provider,
+    options,
+    "anthropic",
+    legacyBound
+  );
+  if (plan?.kind === "level" && plan.enabled) {
+    return {
+      effectiveMaxTokens: configuredMaxTokens,
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: plan.effort },
+      legacyBudgetEnabled: false
+    };
+  }
+  if (plan?.kind === "budget" && plan.enabled) {
+    return {
+      effectiveMaxTokens: legacyBound,
+      thinking: { type: "enabled", budget_tokens: plan.budgetTokens },
+      legacyBudgetEnabled: true
+    };
+  }
+  return {
+    effectiveMaxTokens: configuredMaxTokens,
+    legacyBudgetEnabled: false
+  };
+}
+function buildGeminiThinkingConfig(provider, options) {
+  const plan = resolveCompletionReasoningPlan(provider, options, "gemini");
+  if (plan?.kind === "level") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingLevel: plan.effort
+    };
+  }
+  if (plan?.kind === "budget") {
+    return {
+      includeThoughts: plan.enabled,
+      thinkingBudget: plan.budgetTokens
+    };
+  }
+  return void 0;
+}
+
 // src/completion/DirectApiHandler.ts
 async function callOpenAICompletion(provider, apiKey, options, logger) {
   const request = {
@@ -4938,11 +5735,9 @@ async function callOpenAICompletion(provider, apiKey, options, logger) {
     stream: false
     // For now, non-streaming only
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort(options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
@@ -4979,16 +5774,19 @@ async function callOpenAICompletion(provider, apiKey, options, logger) {
 }
 async function callAnthropicCompletion(provider, apiKey, options, logger) {
   const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
+  const reasoningWire = buildAnthropicReasoningWire(provider, options);
   if (hasImages) {
     const systemMessages = options.messages.filter((m) => m.role === "system");
     const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
     const anthropicRequest2 = {
       model: options.model,
-      max_tokens: options.maxTokens ?? 16384,
-      temperature: options.temperature,
+      max_tokens: reasoningWire.effectiveMaxTokens,
+      ...reasoningWire.legacyBudgetEnabled ? {} : { temperature: options.temperature },
       ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
       messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
-      stream: false
+      stream: false,
+      ...reasoningWire.thinking ? { thinking: reasoningWire.thinking } : {},
+      ...reasoningWire.outputConfig ? { output_config: reasoningWire.outputConfig } : {}
     };
     const apiUrl2 = buildProviderApiUrl(provider, { model: options.model, stream: false });
     const headers2 = getProviderHeaders(provider, apiKey);
@@ -5030,14 +5828,24 @@ async function callAnthropicCompletion(provider, apiKey, options, logger) {
       content: m.content
     })),
     // Anthropic requires max_tokens; use 16384 default if not explicitly set
-    max_tokens: options.maxTokens ?? 16384,
-    temperature: options.temperature,
+    max_tokens: reasoningWire.effectiveMaxTokens,
+    temperature: reasoningWire.legacyBudgetEnabled ? void 0 : options.temperature,
     stream: false
   };
   const config = {
     defaultModel: options.model
   };
   const anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
+  const anthropicRequestBody = anthropicRequest;
+  if (reasoningWire.thinking) {
+    anthropicRequestBody.thinking = reasoningWire.thinking;
+  }
+  if (reasoningWire.outputConfig) {
+    anthropicRequestBody.output_config = reasoningWire.outputConfig;
+  }
+  if (reasoningWire.legacyBudgetEnabled) {
+    delete anthropicRequestBody.temperature;
+  }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
   logger.info("Calling Anthropic completion API", { url: apiUrl, model: options.model });
@@ -5082,11 +5890,13 @@ async function callGeminiCompletion(provider, apiKey, options, logger) {
       contents.push(convertMessageToGemini(msg));
     }
   }
+  const thinkingConfig = buildGeminiThinkingConfig(provider, options);
   const request = {
     contents,
     generationConfig: {
       ...options.maxTokens !== void 0 ? { maxOutputTokens: options.maxTokens } : {},
-      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...thinkingConfig ? { thinkingConfig } : {}
     }
   };
   if (systemInstruction) {
@@ -5157,11 +5967,9 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
     ...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort(options.thinkLevel);
-    if (effort) {
-      request.reasoning = { effort, summary: "auto" };
-    }
+  const responseEffort = resolveOpenAIEffort(provider, options, "openai-responses");
+  if (responseEffort) {
+    request.reasoning = { effort: responseEffort, summary: "auto" };
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: false });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5213,7 +6021,6 @@ async function callOpenAIResponseCompletion(provider, apiKey, options, logger) {
 }
 
 // src/completion/StreamHandler.ts
-import { buildAnthropicThinking, getOpenAIReasoningEffort as getOpenAIReasoningEffort2 } from "@omnicross/contracts/thinking-config";
 async function streamOpenAICompletion(provider, apiKey, options, messageId, callbacks, logger) {
   const request = {
     model: options.model,
@@ -5223,11 +6030,9 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
     temperature: options.temperature,
     stream: true
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort2(options.thinkLevel);
-    if (effort) {
-      request.reasoning_effort = effort;
-    }
+  const effort = resolveOpenAIEffort(provider, options, "openai-chat");
+  if (effort) {
+    request.reasoning_effort = effort;
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5277,16 +6082,11 @@ async function streamOpenAICompletion(provider, apiKey, options, messageId, call
 }
 async function streamAnthropicCompletion(provider, apiKey, options, messageId, callbacks, logger) {
   const hasImages = options.messages.some((m) => m.images && m.images.length > 0);
-  const MAX_TOKENS_FOR_THINKING = 16384;
-  let effectiveMaxTokens = options.maxTokens ?? 16384;
-  const thinkingMaxTokens = options.thinkLevel && options.thinkLevel !== "none" ? Math.min(effectiveMaxTokens, MAX_TOKENS_FOR_THINKING) : effectiveMaxTokens;
-  const thinkingConfig = options.thinkLevel && options.thinkLevel !== "none" ? buildAnthropicThinking(options.model, options.thinkLevel, thinkingMaxTokens) : void 0;
-  if (thinkingConfig) {
-    effectiveMaxTokens = thinkingMaxTokens;
-  }
+  const reasoningWire = buildAnthropicReasoningWire(provider, options);
+  const effectiveMaxTokens = reasoningWire.effectiveMaxTokens;
   logger.debug("Anthropic thinking configuration", {
     thinkLevel: options.thinkLevel,
-    thinkingConfig,
+    thinkingConfig: reasoningWire.thinking,
     effectiveMaxTokens
   });
   let anthropicRequest;
@@ -5297,12 +6097,15 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
       model: options.model,
       max_tokens: effectiveMaxTokens,
       // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
-      ...thinkingConfig ? {} : { temperature: options.temperature },
+      ...reasoningWire.legacyBudgetEnabled ? {} : { temperature: options.temperature },
       ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n\n") } : {},
       messages: nonSystemMessages.map((m) => convertMessageToAnthropic(m)),
       stream: true,
-      ...thinkingConfig ? { thinking: thinkingConfig } : {}
+      ...reasoningWire.thinking ? { thinking: reasoningWire.thinking } : {}
     };
+    if (reasoningWire.outputConfig) {
+      anthropicRequest.output_config = reasoningWire.outputConfig;
+    }
   } else {
     const config = {
       defaultModel: options.model
@@ -5316,12 +6119,17 @@ async function streamAnthropicCompletion(provider, apiKey, options, messageId, c
       // Anthropic requires max_tokens; use adjusted value
       max_tokens: effectiveMaxTokens,
       // Omit temperature when thinking is enabled (Anthropic will use default temperature=1)
-      temperature: thinkingConfig ? void 0 : options.temperature,
+      temperature: reasoningWire.legacyBudgetEnabled ? void 0 : options.temperature,
       stream: true
     };
     anthropicRequest = convertOpenAIToAnthropic(openaiRequest, config);
-    if (thinkingConfig) {
-      anthropicRequest.thinking = thinkingConfig;
+    if (reasoningWire.thinking) {
+      anthropicRequest.thinking = reasoningWire.thinking;
+    }
+    if (reasoningWire.outputConfig) {
+      anthropicRequest.output_config = reasoningWire.outputConfig;
+    }
+    if (reasoningWire.legacyBudgetEnabled) {
       delete anthropicRequest.temperature;
     }
   }
@@ -5387,11 +6195,13 @@ async function streamGeminiCompletion(provider, apiKey, options, messageId, call
       contents.push(convertMessageToGemini(msg));
     }
   }
+  const thinkingConfig = buildGeminiThinkingConfig(provider, options);
   const request = {
     contents,
     generationConfig: {
       ...options.maxTokens !== void 0 ? { maxOutputTokens: options.maxTokens } : {},
-      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...thinkingConfig ? { thinkingConfig } : {}
     }
   };
   if (systemInstruction) {
@@ -5457,11 +6267,9 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
     ...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
   };
-  if (options.thinkLevel && options.thinkLevel !== "none") {
-    const effort = getOpenAIReasoningEffort2(options.thinkLevel);
-    if (effort) {
-      request.reasoning = { effort, summary: "auto" };
-    }
+  const responseEffort = resolveOpenAIEffort(provider, options, "openai-responses");
+  if (responseEffort) {
+    request.reasoning = { effort: responseEffort, summary: "auto" };
   }
   const apiUrl = buildProviderApiUrl(provider, { model: options.model, stream: true });
   const headers = getProviderHeaders(provider, apiKey);
@@ -5505,7 +6313,7 @@ async function streamOpenAIResponseCompletion(provider, apiKey, options, message
 
 // src/completion/ThinkingResolver.ts
 import {
-  buildAnthropicThinking as buildAnthropicThinking2,
+  buildAnthropicThinking,
   calculateThinkingBudget,
   DEFAULT_MAX_TOKENS,
   getClaudeMaxTokens,
@@ -5549,7 +6357,7 @@ async function resolveThinkingBudget(getProvider, logger, providerId, modelId, m
   const providerName = provider?.name?.toLowerCase() || "";
   const apiFormat = provider ? resolveApiFormat(provider) : "openai";
   if (apiFormat === "anthropic" || providerName === "anthropic" || providerName.includes("claude")) {
-    const thinkingConfig = buildAnthropicThinking2(modelId, thinkLevel, maxTokens);
+    const thinkingConfig = buildAnthropicThinking(modelId, thinkLevel, maxTokens);
     const adjustedMaxTokens = getClaudeMaxTokens(maxTokens, thinkingBudget) || maxTokens;
     logger.debug("Claude model thinking budget", {
       thinkingBudget,
@@ -6204,7 +7012,8 @@ async function completeWithTransformers(options, llmConfig, getProvider, resolve
       name: provider.name,
       baseUrl: provider.api_base_url,
       apiKey,
-      models: provider.models || []
+      models: provider.models || [],
+      modelConfigs: provider.modelConfigs
     };
     const executor = getSharedExecutor2();
     const { response } = await executeProviderCall({
@@ -6334,7 +7143,8 @@ async function completeStreamWithTransformers(options, callbacks, llmConfig, get
       name: provider.name,
       baseUrl: provider.api_base_url,
       apiKey,
-      models: provider.models || []
+      models: provider.models || [],
+      modelConfigs: provider.modelConfigs
     };
     const executor = getSharedExecutor2();
     const { response } = await executeProviderCall({
@@ -6985,6 +7795,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,
@@ -7013,10 +7854,6 @@ export {
   loadServerConfig,
   saveServerConfig,
   mergeServerConfig,
-  gatewayBindingToEndpointConfig,
-  candidateGatewayBindings,
-  candidateBackgroundModelIds,
-  resolveGatewayBinding,
   computeKeyExpiry,
   checkKeyQuota,
   randomBase62,