@omnicross/core 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,77 +1,146 @@
 import {
   CompletionService,
+  ConcurrencyQueueFullError,
+  ConcurrencyWaitCancelledError,
+  ConcurrencyWaitTimeoutError,
+  DEFAULT_ACCOUNT_PROBE,
+  DEFAULT_CONCURRENCY_QUEUE,
+  DEFAULT_FINGERPRINT,
   DEFAULT_OUTBOUND_PORT,
   DEFAULT_ROUTE_IDLE_MS,
+  DEFAULT_USER_MESSAGE_QUEUE,
+  KeySpendTracker,
+  KeyedMutex,
   OUTBOUND_API_SERVER_CONFIG_KEY,
+  OutboundApiConfigError,
   OutboundApiServer,
+  OutboundConcurrencyGate,
   OutboundRateLimiter,
   ProviderProxy,
   ProviderProxyRouteMap,
+  SerialQueueTimeoutError,
+  UserMessageSerialQueue,
   __resetOutboundApiServerForTests,
   __resetProviderProxyForTests,
   addOpenRouterProviderToRequest,
   attach,
+  checkKeyQuota,
+  computeKeyExpiry,
+  computeVoucherGrant,
   convertMessageToAnthropic,
   convertMessageToGemini,
   convertMessageToOpenAI,
   createNamedKey,
   defaultServerConfig,
-  detectRequestRole,
   emit,
-  endpointToIngressFormat,
   extractRouteToken,
   formatUrls,
+  generateVoucherCode,
   getOpenRouterProviderConfig,
   getOutboundApiServer,
   getProviderProxy,
+  handleVoucherRedeem,
   hashKey,
+  hashVoucherCode,
+  isConcurrencyRejection,
+  isRedeemRequest,
+  isSerialQueueTimeout,
+  isUserMessageRequest,
   loadServerConfig,
   mergeServerConfig,
+  newVoucherId,
+  normalizeAccountProbe,
+  normalizeAudit,
+  normalizeBilling,
+  normalizeFingerprint,
+  normalizePrefixTargets,
+  normalizeProxyConfig,
+  normalizeProxySegment,
+  normalizeQueueSegments,
   normalizeServerConfig,
+  normalizeVoucher,
+  normalizeWebhookDestination,
+  normalizeWebhookSegment,
+  randomBase62,
   register,
   release,
   saveServerConfig,
-  verifyPresentedKey
-} from "./chunk-2FEVTJWG.js";
-import "./chunk-QOCNX236.js";
+  startOfLocalDay,
+  startOfLocalWeek,
+  toVoucherInfo,
+  verifyKey,
+  verifyPresentedKey,
+  voucherCodePrefix
+} from "./chunk-QYTT6GE3.js";
 import {
   createSSEParser,
   streamSSEResponse
 } from "./chunk-VVEHS2LI.js";
 import "./chunk-46RLHI7D.js";
-import {
-  TransformerChainExecutor
-} from "./chunk-G2UTNSGU.js";
-import "./chunk-MZNPGW5Q.js";
 import {
   TransformerService
 } from "./chunk-DK4A7DLE.js";
 import {
   registerBuiltinTransformers
-} from "./chunk-O466Y272.js";
-import "./chunk-C7PSERMH.js";
-import "./chunk-5HTVET6E.js";
-import "./chunk-Z7LUNECE.js";
+} from "./chunk-VPBAUQ2M.js";
 import "./chunk-ZJZAOKI7.js";
 import "./chunk-FTQ7IQUC.js";
+import "./chunk-C7PSERMH.js";
+import "./chunk-TIER4SUC.js";
+import "./chunk-Z7LUNECE.js";
 import "./chunk-7VU7V2E4.js";
 import {
   PricingEngine
 } from "./chunk-ZLX3KGXX.js";
 import {
   UsageRecorder
-} from "./chunk-MNYKI4CI.js";
+} from "./chunk-BPKCU575.js";
+import {
+  TransformerChainExecutor
+} from "./chunk-G2UTNSGU.js";
+import "./chunk-MZNPGW5Q.js";
+import "./chunk-XTEI64OU.js";
+import "./chunk-XX6NQJMA.js";
+import "./chunk-IAXWICZU.js";
+import "./chunk-OE6TDIWW.js";
 import "./chunk-DRWHTIIZ.js";
-import "./chunk-JO5NLTLY.js";
+import "./chunk-IK3KE3AU.js";
 import {
   getProviderHeaders
-} from "./chunk-PXUJF5HS.js";
+} from "./chunk-ZY6KU6P3.js";
 import "./chunk-JWC6APFQ.js";
 import "./chunk-5ERIZW3D.js";
-import "./chunk-74TMJA7Z.js";
+import "./chunk-5ENKBSWO.js";
+import "./chunk-HRRYG2AX.js";
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
+import {
+  beginBillingCapture
+} from "./chunk-WLYIIEAF.js";
+import "./chunk-TKJMZBAH.js";
+import "./chunk-3QFXFCHG.js";
+import {
+  SUBSCRIPTION_PROVIDER_IDS,
+  classifyModelPrefix,
+  detectModelKind,
+  detectRequestRole,
+  endpointSupportsSubscription,
+  endpointToIngressFormat,
+  isKindMappedEndpoint,
+  isSubscriptionProviderId,
+  modelKindsForEndpoint,
+  parseModelRef,
+  pickModelRefFromList,
+  resolvePrefixTarget,
+  resolveRoute,
+  validateEndpointModelConfig,
+  validateServerModelConfig
+} from "./chunk-UHGVBFU3.js";
+import "./chunk-AQ5TNQB7.js";
+import {
+  ENDPOINT_MODEL_KINDS
+} from "./chunk-XEKD23J5.js";
 import {
   buildAnthropicApiUrl,
   buildAzureOpenAIApiUrl,
@@ -84,12 +153,14 @@ import {
   resolveProviderEndpoint
 } from "./chunk-H5JUT3KV.js";
 import {
-  SUBSCRIPTION_PROVIDER_IDS,
-  endpointSupportsSubscription,
-  isSubscriptionProviderId,
-  resolveRoute
-} from "./chunk-3MEACFK3.js";
-import "./chunk-AQ5TNQB7.js";
+  beginAuditCapture
+} from "./chunk-7Y47UCF2.js";
+import {
+  AUDIT_REDACTED,
+  redactAuditText
+} from "./chunk-K5NM7VAH.js";
+import "./chunk-WNY4WMRF.js";
+import "./chunk-OZFM4X3S.js";
 import {
   convertAnthropicRequestToOpenAI,
   convertAnthropicStreamToOpenAI,
@@ -104,6 +175,7 @@ import {
 } from "./chunk-5ZQBEOMD.js";
 import "./chunk-Z7Y2NPHY.js";
 import "./chunk-S4WBV25P.js";
+import "./chunk-XK5CIRMQ.js";
 import {
   BuiltinToolExecutor,
   getBuiltinSearchTools
@@ -112,36 +184,55 @@ import {
   applyAugmentation,
   buildNativeSearchAugmentation,
   detectNativeSearch
-} from "./chunk-745DV5FL.js";
-import {
-  OPENROUTER_APP_HEADERS,
-  isOpenRouterProvider
-} from "./chunk-E3WHL7CO.js";
+} from "./chunk-Y7FO65VT.js";
 import {
   NATIVE_SEARCH_TOOL_NAMES
 } from "./chunk-FMOBD2OQ.js";
+import {
+  OPENROUTER_APP_HEADERS,
+  getOpenRouterAppIdentity,
+  isOpenRouterProvider,
+  setOpenRouterAppIdentity
+} from "./chunk-HUZZZ3JL.js";
 export {
+  AUDIT_REDACTED,
   BuiltinToolExecutor,
   CompletionService,
+  ConcurrencyQueueFullError,
+  ConcurrencyWaitCancelledError,
+  ConcurrencyWaitTimeoutError,
+  DEFAULT_ACCOUNT_PROBE,
+  DEFAULT_CONCURRENCY_QUEUE,
+  DEFAULT_FINGERPRINT,
   DEFAULT_OUTBOUND_PORT,
   DEFAULT_ROUTE_IDLE_MS,
+  DEFAULT_USER_MESSAGE_QUEUE,
+  ENDPOINT_MODEL_KINDS,
+  KeySpendTracker,
+  KeyedMutex,
   NATIVE_SEARCH_TOOL_NAMES,
   OPENROUTER_APP_HEADERS,
   OUTBOUND_API_SERVER_CONFIG_KEY,
+  OutboundApiConfigError,
   OutboundApiServer,
+  OutboundConcurrencyGate,
   OutboundRateLimiter,
   PricingEngine,
   ProviderProxy,
   ProviderProxyRouteMap,
   SUBSCRIPTION_PROVIDER_IDS,
+  SerialQueueTimeoutError,
   TransformerChainExecutor,
   TransformerService,
   UsageRecorder,
+  UserMessageSerialQueue,
   __resetOutboundApiServerForTests,
   __resetProviderProxyForTests,
   addOpenRouterProviderToRequest,
   applyAugmentation,
   attach as attachStreamEventBuffer,
+  beginAuditCapture,
+  beginBillingCapture,
   buildAnthropicApiUrl,
   buildAzureOpenAIApiUrl,
   buildGeminiApiUrl,
@@ -149,6 +240,10 @@ export {
   buildOpenAIApiUrl,
   buildOpenAIResponseApiUrl,
   buildProviderApiUrl,
+  checkKeyQuota,
+  classifyModelPrefix,
+  computeKeyExpiry,
+  computeVoucherGrant,
   convertAnthropicRequestToOpenAI,
   convertAnthropicStreamToOpenAI,
   convertAnthropicToOpenAI,
@@ -163,6 +258,7 @@ export {
   createNamedKey,
   createSSEParser,
   defaultServerConfig,
+  detectModelKind,
   detectNativeSearch,
   detectRequestRole,
   emit as emitStreamEvent,
@@ -170,28 +266,63 @@ export {
   endpointToIngressFormat,
   extractRouteToken,
   formatUrls,
+  generateVoucherCode,
   getBuiltinSearchTools,
+  getOpenRouterAppIdentity,
   getOpenRouterProviderConfig,
   getOutboundApiServer,
   getProviderHeaders,
   getProviderProxy,
+  handleVoucherRedeem,
   hasImageContent,
   hasThinkingEnabled,
   hashKey,
+  hashVoucherCode,
+  isConcurrencyRejection,
+  isKindMappedEndpoint,
   isOpenRouterProvider,
+  isRedeemRequest,
+  isSerialQueueTimeout,
   isSubscriptionProviderId,
+  isUserMessageRequest,
   loadServerConfig,
   mergeServerConfig,
+  modelKindsForEndpoint,
+  newVoucherId,
+  normalizeAccountProbe,
+  normalizeAudit,
   normalizeAzureEndpoint,
+  normalizeBilling,
+  normalizeFingerprint,
+  normalizePrefixTargets,
+  normalizeProxyConfig,
+  normalizeProxySegment,
+  normalizeQueueSegments,
   normalizeServerConfig,
+  normalizeVoucher,
+  normalizeWebhookDestination,
+  normalizeWebhookSegment,
+  parseModelRef,
+  pickModelRefFromList,
+  randomBase62,
+  redactAuditText,
   registerBuiltinTransformers,
   register as registerStreamEventBuffer,
   release as releaseStreamEventBuffer,
   resolveApiFormat,
+  resolvePrefixTarget,
   resolveProviderEndpoint,
   resolveRoute,
   saveServerConfig,
   serializeError,
+  setOpenRouterAppIdentity,
+  startOfLocalDay,
+  startOfLocalWeek,
   streamSSEResponse,
-  verifyPresentedKey
+  toVoucherInfo,
+  validateEndpointModelConfig,
+  validateServerModelConfig,
+  verifyKey,
+  verifyPresentedKey,
+  voucherCodePrefix
 };

package/dist/keyPolicy-Cp0FntZl.d.cts

@@ -0,0 +1,90 @@
+/**
+ * keyPolicy — PURE decision helpers for the outbound key-policy envelope
+ * (`outbound-key-policy`, design D2/D4). Expiry/activation resolution +
+ * cost-quota decision. No I/O, no clock ownership (the caller passes `now`), so
+ * these are trivially unit-testable and reused by both the auth path
+ * (`verifyKey`) and the wire path (`outboundApiRouter`).
+ *
+ * The #6 (`restrictedModels`) and #9 (voucher) children EXTEND the key-policy
+ * schema; they must not change the shapes frozen here.
+ *
+ * @module outbound-api/keyPolicy
+ */
+/** The expiry/activation subset of a key row `computeKeyExpiry` reads. */
+interface KeyExpiryInput {
+    /** Fixed-mode absolute expiry (epoch ms). */
+    expiresAt?: number | null;
+    /** Expiry mode; absent ⇒ `'fixed'`. */
+    activationMode?: 'fixed' | 'activation';
+    /** Activation-mode lifetime in days (absent/null ⇒ never expires). */
+    activationDays?: number | null;
+    /** First-use activation stamp (epoch ms); null ⇒ not yet activated. */
+    activatedAt?: number | null;
+}
+/** Result of {@link computeKeyExpiry}. */
+interface KeyExpiryResult {
+    expired: boolean;
+    /** The resolved absolute expiry (epoch ms), when the key has one. */
+    effectiveExpiresAt?: number;
+    /**
+     * True when this is an activation-mode key that has NOT been activated yet, so
+     * the caller SHOULD stamp the activation (best-effort) on a successful verify.
+     */
+    needsActivation?: boolean;
+}
+/**
+ * Resolve whether a key is past its effective expiry (design D2).
+ *  - `fixed`: expired when `expiresAt != null && now >= expiresAt`.
+ *  - `activation`: while `activatedAt == null` the key is NOT expired (it
+ *    activates on THIS use → `needsActivation`); once activated, expired when
+ *    `now >= activatedAt + activationDays*DAY`. A null `activationDays` never
+ *    expires.
+ * A key with no expiry configured never expires.
+ */
+declare function computeKeyExpiry(row: KeyExpiryInput, now: number): KeyExpiryResult;
+/** Per-key USD cost limits carried on the verified key (absent scope ⇒ no cap). */
+interface KeyCostLimits {
+    dailyUsd?: number;
+    totalUsd?: number;
+    weeklyUsd?: number;
+}
+/** In-memory per-key accumulated spend snapshot (see `keySpendTracker`). */
+interface KeySpend {
+    dailyUsd: number;
+    /** Local-midnight boundary the `dailyUsd` window opened at (epoch ms). */
+    dailyWindowStart: number;
+    weeklyUsd: number;
+    /** Local week-start boundary the `weeklyUsd` window opened at (epoch ms). */
+    weeklyWindowStart: number;
+    totalUsd: number;
+}
+/** Decision returned by {@link checkKeyQuota}. */
+type QuotaDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    scope: 'daily' | 'weekly' | 'total';
+    limitUsd: number;
+    spentUsd: number;
+};
+/**
+ * Decide whether the key's accumulated spend already meets/exceeds any
+ * configured cost limit (design D4). `allowed:false` when a scope's PRIOR spend
+ * is `>= limit` (the triggering request's own cost is unknown pre-flight →
+ * bounded one-request overage, CRS-equivalent). An unconfigured scope is never
+ * gated; a `limits`-less key always passes.
+ */
+declare function checkKeyQuota(limits: KeyCostLimits | undefined, spend: KeySpend): QuotaDecision;
+/**
+ * Per-key model restriction carried on the verified key (outbound-key-policy #6).
+ * Present ONLY when the key has `enableModelRestriction === true` — so the wire
+ * layer's presence check (`if (key.modelRestriction) …`) is the zero-regression
+ * gate.
+ */
+interface ModelRestriction {
+    mode: 'blacklist' | 'allowlist';
+    /** Bare modelIds the mode acts on. Empty allowlist denies every model. */
+    models: string[];
+}
+
+export { type KeyCostLimits as K, type ModelRestriction as M, type QuotaDecision as Q, type KeyExpiryInput as a, type KeyExpiryResult as b, type KeySpend as c, checkKeyQuota as d, computeKeyExpiry as e };

package/dist/keyPolicy-Cp0FntZl.d.ts

@@ -0,0 +1,90 @@
+/**
+ * keyPolicy — PURE decision helpers for the outbound key-policy envelope
+ * (`outbound-key-policy`, design D2/D4). Expiry/activation resolution +
+ * cost-quota decision. No I/O, no clock ownership (the caller passes `now`), so
+ * these are trivially unit-testable and reused by both the auth path
+ * (`verifyKey`) and the wire path (`outboundApiRouter`).
+ *
+ * The #6 (`restrictedModels`) and #9 (voucher) children EXTEND the key-policy
+ * schema; they must not change the shapes frozen here.
+ *
+ * @module outbound-api/keyPolicy
+ */
+/** The expiry/activation subset of a key row `computeKeyExpiry` reads. */
+interface KeyExpiryInput {
+    /** Fixed-mode absolute expiry (epoch ms). */
+    expiresAt?: number | null;
+    /** Expiry mode; absent ⇒ `'fixed'`. */
+    activationMode?: 'fixed' | 'activation';
+    /** Activation-mode lifetime in days (absent/null ⇒ never expires). */
+    activationDays?: number | null;
+    /** First-use activation stamp (epoch ms); null ⇒ not yet activated. */
+    activatedAt?: number | null;
+}
+/** Result of {@link computeKeyExpiry}. */
+interface KeyExpiryResult {
+    expired: boolean;
+    /** The resolved absolute expiry (epoch ms), when the key has one. */
+    effectiveExpiresAt?: number;
+    /**
+     * True when this is an activation-mode key that has NOT been activated yet, so
+     * the caller SHOULD stamp the activation (best-effort) on a successful verify.
+     */
+    needsActivation?: boolean;
+}
+/**
+ * Resolve whether a key is past its effective expiry (design D2).
+ *  - `fixed`: expired when `expiresAt != null && now >= expiresAt`.
+ *  - `activation`: while `activatedAt == null` the key is NOT expired (it
+ *    activates on THIS use → `needsActivation`); once activated, expired when
+ *    `now >= activatedAt + activationDays*DAY`. A null `activationDays` never
+ *    expires.
+ * A key with no expiry configured never expires.
+ */
+declare function computeKeyExpiry(row: KeyExpiryInput, now: number): KeyExpiryResult;
+/** Per-key USD cost limits carried on the verified key (absent scope ⇒ no cap). */
+interface KeyCostLimits {
+    dailyUsd?: number;
+    totalUsd?: number;
+    weeklyUsd?: number;
+}
+/** In-memory per-key accumulated spend snapshot (see `keySpendTracker`). */
+interface KeySpend {
+    dailyUsd: number;
+    /** Local-midnight boundary the `dailyUsd` window opened at (epoch ms). */
+    dailyWindowStart: number;
+    weeklyUsd: number;
+    /** Local week-start boundary the `weeklyUsd` window opened at (epoch ms). */
+    weeklyWindowStart: number;
+    totalUsd: number;
+}
+/** Decision returned by {@link checkKeyQuota}. */
+type QuotaDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    scope: 'daily' | 'weekly' | 'total';
+    limitUsd: number;
+    spentUsd: number;
+};
+/**
+ * Decide whether the key's accumulated spend already meets/exceeds any
+ * configured cost limit (design D4). `allowed:false` when a scope's PRIOR spend
+ * is `>= limit` (the triggering request's own cost is unknown pre-flight →
+ * bounded one-request overage, CRS-equivalent). An unconfigured scope is never
+ * gated; a `limits`-less key always passes.
+ */
+declare function checkKeyQuota(limits: KeyCostLimits | undefined, spend: KeySpend): QuotaDecision;
+/**
+ * Per-key model restriction carried on the verified key (outbound-key-policy #6).
+ * Present ONLY when the key has `enableModelRestriction === true` — so the wire
+ * layer's presence check (`if (key.modelRestriction) …`) is the zero-regression
+ * gate.
+ */
+interface ModelRestriction {
+    mode: 'blacklist' | 'allowlist';
+    /** Bare modelIds the mode acts on. Empty allowlist denies every model. */
+    models: string[];
+}
+
+export { type KeyCostLimits as K, type ModelRestriction as M, type QuotaDecision as Q, type KeyExpiryInput as a, type KeyExpiryResult as b, type KeySpend as c, checkKeyQuota as d, computeKeyExpiry as e };

package/dist/outbound-api/auditCapture.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkE3UCVHLPcjs = require('../chunk-E3UCVHLP.cjs');
+require('../chunk-FCR77GYM.cjs');
+require('../chunk-AEOZIDEB.cjs');
+require('../chunk-XSVNC2UD.cjs');
+
+
+exports.beginAuditCapture = _chunkE3UCVHLPcjs.beginAuditCapture;

package/dist/outbound-api/auditCapture.d.cts

@@ -0,0 +1,52 @@
+import http from 'node:http';
+
+/**
+ * auditCapture — the outbound server's post-response audit capture hook
+ * (request-audit-log, design D1/D3/D5).
+ *
+ * {@link beginAuditCapture} is called at the TOP of `handleOutboundRequest`. It
+ * reads the active capture config from the core slot; when audit is DISABLED it
+ * returns `null` immediately (one slot read — no assembly, no listener, zero
+ * regression). When enabled it:
+ *  - registers a one-shot `res.on('close')` listener that, at response end,
+ *    assembles the {@link AuditRecord} from the http `req` (IP via the socket, or
+ *    a trusted `X-Forwarded-For` only when configured — LEAD OQ1 anti-spoof; UA;
+ *    method; path with the query string DROPPED), the response `statusCode`, the
+ *    elapsed ms, and the fields the handler fills in (keyId / model / provider /
+ *    error / bodies) — then hands it to the fire-and-forget `recordAudit`;
+ *  - when `captureBodies` is ALSO on, wraps `res.write`/`res.end` to accumulate a
+ *    BOUNDED response body (metadata-only for a streaming `text/event-stream`
+ *    response — a full stream is unbounded), and truncates+redacts both bodies.
+ *
+ * Request HEADERS are NEVER read into a record (Authorization / x-api-key live
+ * there). Every stored body passes through {@link redactAuditText}. The assembly
+ * is wrapped so a capture failure can never surface into the relay path.
+ *
+ * @module @omnicross/core/outbound-api/auditCapture
+ */
+
+/**
+ * The mutable context the request handler enriches as it progresses. `null` is
+ * returned by {@link beginAuditCapture} when audit is disabled — the handler
+ * guards every write with `if (audit)`.
+ */
+interface AuditCaptureContext {
+    /** Outbound key id (set after auth). NEVER the key material. */
+    keyId?: string | null;
+    /** Resolved upstream model (set after route resolution). */
+    model?: string;
+    /** Upstream provider id (set after route resolution). */
+    provider?: string;
+    /** Sanitized error message (set on a relay/dispatch failure). */
+    error?: string;
+    /** Stash the raw request body for capture (a no-op unless `captureBodies`). */
+    setRequestBody(raw: string): void;
+}
+/**
+ * Begin audit capture for one request. Returns a mutable context the handler
+ * enriches, or `null` when audit is disabled (zero-cost path). The record is
+ * emitted on response `close` via the fire-and-forget sink.
+ */
+declare function beginAuditCapture(req: http.IncomingMessage, res: http.ServerResponse, now: number): AuditCaptureContext | null;
+
+export { type AuditCaptureContext, beginAuditCapture };

package/dist/outbound-api/auditCapture.d.ts

@@ -0,0 +1,52 @@
+import http from 'node:http';
+
+/**
+ * auditCapture — the outbound server's post-response audit capture hook
+ * (request-audit-log, design D1/D3/D5).
+ *
+ * {@link beginAuditCapture} is called at the TOP of `handleOutboundRequest`. It
+ * reads the active capture config from the core slot; when audit is DISABLED it
+ * returns `null` immediately (one slot read — no assembly, no listener, zero
+ * regression). When enabled it:
+ *  - registers a one-shot `res.on('close')` listener that, at response end,
+ *    assembles the {@link AuditRecord} from the http `req` (IP via the socket, or
+ *    a trusted `X-Forwarded-For` only when configured — LEAD OQ1 anti-spoof; UA;
+ *    method; path with the query string DROPPED), the response `statusCode`, the
+ *    elapsed ms, and the fields the handler fills in (keyId / model / provider /
+ *    error / bodies) — then hands it to the fire-and-forget `recordAudit`;
+ *  - when `captureBodies` is ALSO on, wraps `res.write`/`res.end` to accumulate a
+ *    BOUNDED response body (metadata-only for a streaming `text/event-stream`
+ *    response — a full stream is unbounded), and truncates+redacts both bodies.
+ *
+ * Request HEADERS are NEVER read into a record (Authorization / x-api-key live
+ * there). Every stored body passes through {@link redactAuditText}. The assembly
+ * is wrapped so a capture failure can never surface into the relay path.
+ *
+ * @module @omnicross/core/outbound-api/auditCapture
+ */
+
+/**
+ * The mutable context the request handler enriches as it progresses. `null` is
+ * returned by {@link beginAuditCapture} when audit is disabled — the handler
+ * guards every write with `if (audit)`.
+ */
+interface AuditCaptureContext {
+    /** Outbound key id (set after auth). NEVER the key material. */
+    keyId?: string | null;
+    /** Resolved upstream model (set after route resolution). */
+    model?: string;
+    /** Upstream provider id (set after route resolution). */
+    provider?: string;
+    /** Sanitized error message (set on a relay/dispatch failure). */
+    error?: string;
+    /** Stash the raw request body for capture (a no-op unless `captureBodies`). */
+    setRequestBody(raw: string): void;
+}
+/**
+ * Begin audit capture for one request. Returns a mutable context the handler
+ * enriches, or `null` when audit is disabled (zero-cost path). The record is
+ * emitted on response `close` via the fire-and-forget sink.
+ */
+declare function beginAuditCapture(req: http.IncomingMessage, res: http.ServerResponse, now: number): AuditCaptureContext | null;
+
+export { type AuditCaptureContext, beginAuditCapture };

package/dist/outbound-api/auditCapture.js

@@ -0,0 +1,9 @@
+import {
+  beginAuditCapture
+} from "../chunk-7Y47UCF2.js";
+import "../chunk-K5NM7VAH.js";
+import "../chunk-WNY4WMRF.js";
+import "../chunk-OZFM4X3S.js";
+export {
+  beginAuditCapture
+};

package/dist/outbound-api/auditRedact.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkFCR77GYMcjs = require('../chunk-FCR77GYM.cjs');
+
+
+
+exports.AUDIT_REDACTED = _chunkFCR77GYMcjs.AUDIT_REDACTED; exports.redactAuditText = _chunkFCR77GYMcjs.redactAuditText;

package/dist/outbound-api/auditRedact.d.cts

@@ -0,0 +1,30 @@
+/**
+ * auditRedact — the pure secret-redaction pass for captured audit bodies
+ * (request-audit-log, design D3/D7).
+ *
+ * Body capture is opt-in and inherently sensitive: a prompt or tool argument can
+ * embed a secret. {@link redactAuditText} is run over EVERY captured body (and
+ * any other free text stored in a record) BEFORE it is persisted — defense in
+ * depth on top of "request headers are NEVER captured" (so an Authorization /
+ * x-api-key HEADER value never enters a record in the first place).
+ *
+ * It masks the obvious, high-confidence secret shapes ONLY (frozen list) — never
+ * a broad heuristic that would gut a legitimate prompt:
+ *  - `sk-…` API keys (covers `sk-ant-…`, `sk-omnicross-…`, `sk-proj-…`, OpenAI).
+ *  - `Bearer <token>` authorization values.
+ *  - `x-api-key` / `api-key` / `authorization` values written inline as text.
+ *  - Google `AIza…` API keys.
+ *
+ * Pure + allocation-light + never throws.
+ *
+ * @module @omnicross/core/outbound-api/auditRedact
+ */
+/** The sentinel a masked secret is replaced with. */
+declare const AUDIT_REDACTED = "***REDACTED***";
+/**
+ * Mask obvious secrets in `text`. Pure; returns the input unchanged when it holds
+ * no recognized secret shape. Never throws (a bad input returns `''`).
+ */
+declare function redactAuditText(text: string): string;
+
+export { AUDIT_REDACTED, redactAuditText };