@omnicross/core 0.1.3 → 0.1.5

package/dist/pipeline/SubscriptionAuthSource.js

@@ -1,7 +1,7 @@
 import {
   SubscriptionAuthSource,
   stripAuthHeaders
-} from "../chunk-N5QFKSDO.js";
+} from "../chunk-HRRYG2AX.js";
 import "../chunk-AVYJ4YBN.js";
 export {
   SubscriptionAuthSource,

package/dist/pipeline/SubscriptionAuthStrategy.d.cts

@@ -49,6 +49,12 @@ interface AuthApplyHints {
      * pre-health behavior).
      */
     reportSelection?: (accountId: string, isActive: boolean, remappedModel?: string) => void;
+    /**
+     * OPTIONAL preferred subscription account id (provider/subscription duality).
+     * When set and schedulable the account picker resolves it directly; absent or
+     * unschedulable ⇒ pool auto-schedule.
+     */
+    preferredAccountId?: string;
 }
 interface AuthStrategy {
     /** Discriminator — also surfaced through `subscription:list` to renderers. */

package/dist/pipeline/SubscriptionAuthStrategy.d.ts

@@ -49,6 +49,12 @@ interface AuthApplyHints {
      * pre-health behavior).
      */
     reportSelection?: (accountId: string, isActive: boolean, remappedModel?: string) => void;
+    /**
+     * OPTIONAL preferred subscription account id (provider/subscription duality).
+     * When set and schedulable the account picker resolves it directly; absent or
+     * unschedulable ⇒ pool auto-schedule.
+     */
+    preferredAccountId?: string;
 }
 interface AuthStrategy {
     /** Discriminator — also surfaced through `subscription:list` to renderers. */

package/dist/pipeline/auditUsageStash.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkXSVNC2UDcjs = require('../chunk-XSVNC2UD.cjs');
+
+
+
+
+exports.__clearAuditUsageForTests = _chunkXSVNC2UDcjs.__clearAuditUsageForTests; exports.readAuditUsage = _chunkXSVNC2UDcjs.readAuditUsage; exports.stashAuditUsage = _chunkXSVNC2UDcjs.stashAuditUsage;

package/dist/pipeline/auditUsageStash.d.cts

@@ -0,0 +1,37 @@
+/**
+ * auditUsageStash — a per-request usage correlation stash for the audit capture
+ * (request-audit-log, design D1). The audit record is assembled at the outbound
+ * router's post-response point, but token counts + cost are produced downstream
+ * by the usage tap → `UsageRecorder`. This `WeakMap<res, detail>` bridges them:
+ * the recorder stashes the usage detail keyed by the SAME `http.ServerResponse`
+ * the audit capture holds, so `beginAuditCapture` can read it at response close.
+ *
+ * The token counts + model/provider are stashed SYNCHRONOUSLY at `record()` time
+ * (before the response closes ⇒ reliably present); the cost is stashed on the
+ * deferred pricing tick (best-effort — populated when it lands before close).
+ * Keyed by the response OBJECT (a `WeakMap`, so a completed request's entry is
+ * GC'd with the response — no leak, no cleanup needed).
+ *
+ * This is OPT-IN + gated: only the outbound taps set `auditResponse`, and the
+ * audit capture only reads when audit is enabled. Any other `UsageRecorder`
+ * caller leaves `auditResponse` unset ⇒ this map is never touched ⇒ zero
+ * regression.
+ *
+ * @module @omnicross/core/pipeline/auditUsageStash
+ */
+/** The subset of usage numbers an audit record carries (all optional). */
+interface AuditUsageDetail {
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
+    model?: string;
+    provider?: string;
+}
+/** Merge a partial usage detail into the entry keyed by `key` (the response). */
+declare function stashAuditUsage(key: object, detail: AuditUsageDetail): void;
+/** Read the accumulated usage detail for `key`, or `undefined` when none. */
+declare function readAuditUsage(key: object): AuditUsageDetail | undefined;
+/** TEST SEAM — drop a stashed entry so a suite starts clean. */
+declare function __clearAuditUsageForTests(key: object): void;
+
+export { type AuditUsageDetail, __clearAuditUsageForTests, readAuditUsage, stashAuditUsage };

package/dist/pipeline/auditUsageStash.d.ts

@@ -0,0 +1,37 @@
+/**
+ * auditUsageStash — a per-request usage correlation stash for the audit capture
+ * (request-audit-log, design D1). The audit record is assembled at the outbound
+ * router's post-response point, but token counts + cost are produced downstream
+ * by the usage tap → `UsageRecorder`. This `WeakMap<res, detail>` bridges them:
+ * the recorder stashes the usage detail keyed by the SAME `http.ServerResponse`
+ * the audit capture holds, so `beginAuditCapture` can read it at response close.
+ *
+ * The token counts + model/provider are stashed SYNCHRONOUSLY at `record()` time
+ * (before the response closes ⇒ reliably present); the cost is stashed on the
+ * deferred pricing tick (best-effort — populated when it lands before close).
+ * Keyed by the response OBJECT (a `WeakMap`, so a completed request's entry is
+ * GC'd with the response — no leak, no cleanup needed).
+ *
+ * This is OPT-IN + gated: only the outbound taps set `auditResponse`, and the
+ * audit capture only reads when audit is enabled. Any other `UsageRecorder`
+ * caller leaves `auditResponse` unset ⇒ this map is never touched ⇒ zero
+ * regression.
+ *
+ * @module @omnicross/core/pipeline/auditUsageStash
+ */
+/** The subset of usage numbers an audit record carries (all optional). */
+interface AuditUsageDetail {
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
+    model?: string;
+    provider?: string;
+}
+/** Merge a partial usage detail into the entry keyed by `key` (the response). */
+declare function stashAuditUsage(key: object, detail: AuditUsageDetail): void;
+/** Read the accumulated usage detail for `key`, or `undefined` when none. */
+declare function readAuditUsage(key: object): AuditUsageDetail | undefined;
+/** TEST SEAM — drop a stashed entry so a suite starts clean. */
+declare function __clearAuditUsageForTests(key: object): void;
+
+export { type AuditUsageDetail, __clearAuditUsageForTests, readAuditUsage, stashAuditUsage };

package/dist/pipeline/auditUsageStash.js

@@ -0,0 +1,10 @@
+import {
+  __clearAuditUsageForTests,
+  readAuditUsage,
+  stashAuditUsage
+} from "../chunk-OZFM4X3S.js";
+export {
+  __clearAuditUsageForTests,
+  readAuditUsage,
+  stashAuditUsage
+};

package/dist/pipeline/executeProviderCall.cjs

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkKUU2RNG6cjs = require('../chunk-KUU2RNG6.cjs');
+var _chunkHYN75H6Gcjs = require('../chunk-HYN75H6G.cjs');
 
 
-exports.executeProviderCall = _chunkKUU2RNG6cjs.executeProviderCall;
+exports.executeProviderCall = _chunkHYN75H6Gcjs.executeProviderCall;

package/dist/pipeline/executeProviderCall.js

@@ -1,6 +1,6 @@
 import {
   executeProviderCall
-} from "../chunk-JO5NLTLY.js";
+} from "../chunk-IK3KE3AU.js";
 export {
   executeProviderCall
 };

package/dist/pipeline/upstreamFetch.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkPG7PS2NNcjs = require('../chunk-PG7PS2NN.cjs');
+require('../chunk-3Z5BQZFM.cjs');
+
+
+
+
+
+
+exports.__resetUpstreamProxyForTests = _chunkPG7PS2NNcjs.__resetUpstreamProxyForTests; exports.bumpUpstreamProxyGeneration = _chunkPG7PS2NNcjs.bumpUpstreamProxyGeneration; exports.fetchUpstream = _chunkPG7PS2NNcjs.fetchUpstream; exports.resolveUpstreamDispatcher = _chunkPG7PS2NNcjs.resolveUpstreamDispatcher; exports.setUpstreamProxyResolver = _chunkPG7PS2NNcjs.setUpstreamProxyResolver;

package/dist/pipeline/upstreamFetch.d.cts

@@ -0,0 +1,89 @@
+import { ProxyConfig } from '@omnicross/contracts/account-tokens-types';
+import { Dispatcher } from 'undici';
+
+/**
+ * upstreamFetch — the single proxy-aware egress seam for `@omnicross/core`
+ * (upstream-proxy).
+ *
+ * Every outbound UPSTREAM call (relay ingress `fetchFn` closures, the OAuth
+ * token-refresh `FetchLike`, the Gemini Code Assist handshake) routes through
+ * {@link fetchUpstream}. When a proxy resolves for the call it attaches an
+ * undici {@link Dispatcher} (`ProxyAgent` for http/https, an `Agent` with a
+ * socks5 connector for socks5); ABSENT any proxy it is a BARE `fetch` — the
+ * dispatcher option is never set, so behavior is byte-identical to the
+ * pre-change code (the zero-regression guarantee).
+ *
+ * Core stays config/account-agnostic: it only knows opaque `providerId` /
+ * `accountId` strings + a {@link ProxyConfig} descriptor. The daemon injects the
+ * layered lookup via {@link setUpstreamProxyResolver} — the same module-slot
+ * pattern as `setSubscriptionRegistryForOutbound`. Core never imports config or
+ * account material.
+ *
+ * Dispatchers are CACHED by resolved-proxy identity (one instance reused, not
+ * per-request, so keep-alive holds and sockets don't leak). A config change bumps
+ * a generation via {@link bumpUpstreamProxyGeneration} (also called by
+ * `setUpstreamProxyResolver`) which disposes the old dispatchers and rebuilds on
+ * next use.
+ *
+ * FROZEN SEAM: `#7` (client fingerprint) attaches per-account TLS/agent behavior
+ * at this SAME dispatcher point — do not fork a second egress path.
+ *
+ * DEBUG TRACE: when the daemon installs an upstream-trace path (gated on the
+ * audit `captureBodies` opt-in), relay calls (`ctx.providerId` set) clone the
+ * response and append the FULL exchange (request + verbatim response incl. SSE)
+ * to the trace file. Absent a path (the default) it is a pure no-op — zero
+ * regression. See `upstreamTrace.ts`.
+ *
+ * @module @omnicross/core/pipeline/upstreamFetch
+ */
+
+/** The opaque call context the resolver maps to a proxy (precedence input). */
+interface UpstreamProxyContext {
+    /** The subscription provider id (`claude`/`codex`/`gemini`/`opencodego`) or `'byo'`. */
+    providerId?: string;
+    /** The selected pooled account id (per-account override input). */
+    accountId?: string;
+    /**
+     * The target upstream URL. Injected by {@link fetchUpstream} so the resolver can
+     * apply host-based bypass (loopback / `NO_PROXY`). Callers of the ingress helpers
+     * do NOT set this — it is filled from the fetch `url`.
+     */
+    url?: string;
+}
+/**
+ * The layered proxy lookup the daemon injects. Applies precedence
+ * account > provider > global > env and returns the WINNING `ProxyConfig`, or
+ * `undefined` for a direct (non-proxied) call.
+ */
+type UpstreamProxyResolver = (ctx: UpstreamProxyContext) => ProxyConfig | undefined;
+/**
+ * Inject (or clear, with `null`) the layered proxy resolver. Idempotent — last
+ * write wins. Bumps the dispatcher generation so a resolver swap (or a config
+ * edit that re-registers) rebuilds dispatchers from the new lookup and disposes
+ * the old ones.
+ */
+declare function setUpstreamProxyResolver(fn: UpstreamProxyResolver | null): void;
+/**
+ * Invalidate every cached dispatcher (config change / admin edit). Old
+ * dispatchers are `close()`d best-effort so in-flight sockets drain; new calls
+ * rebuild from the current resolver output.
+ */
+declare function bumpUpstreamProxyGeneration(): void;
+/**
+ * Resolve the dispatcher for one call. Returns `undefined` (⇒ bare fetch) when
+ * no resolver is registered, the resolver returns undefined, or the descriptor
+ * is malformed. A resolver throw is swallowed → direct call (egress never breaks
+ * on a proxy-lookup error).
+ */
+declare function resolveUpstreamDispatcher(ctx: UpstreamProxyContext): Dispatcher | undefined;
+/**
+ * Proxy-aware `fetch`. Attaches the resolved undici dispatcher ONLY when a proxy
+ * applies; otherwise it is a BARE `fetch(url, init)` — byte-identical to the
+ * pre-change egress (zero-regression). The `dispatcher` option is undici-specific
+ * (Node's global fetch IS undici); the cast threads it without a DOM-lib type.
+ */
+declare function fetchUpstream(url: string, init: RequestInit, ctx?: UpstreamProxyContext): Promise<Response>;
+/** TEST SEAM — clear the resolver + cache so a suite starts from the direct-fetch baseline. */
+declare function __resetUpstreamProxyForTests(): void;
+
+export { type UpstreamProxyContext, type UpstreamProxyResolver, __resetUpstreamProxyForTests, bumpUpstreamProxyGeneration, fetchUpstream, resolveUpstreamDispatcher, setUpstreamProxyResolver };

package/dist/pipeline/upstreamFetch.d.ts

@@ -0,0 +1,89 @@
+import { ProxyConfig } from '@omnicross/contracts/account-tokens-types';
+import { Dispatcher } from 'undici';
+
+/**
+ * upstreamFetch — the single proxy-aware egress seam for `@omnicross/core`
+ * (upstream-proxy).
+ *
+ * Every outbound UPSTREAM call (relay ingress `fetchFn` closures, the OAuth
+ * token-refresh `FetchLike`, the Gemini Code Assist handshake) routes through
+ * {@link fetchUpstream}. When a proxy resolves for the call it attaches an
+ * undici {@link Dispatcher} (`ProxyAgent` for http/https, an `Agent` with a
+ * socks5 connector for socks5); ABSENT any proxy it is a BARE `fetch` — the
+ * dispatcher option is never set, so behavior is byte-identical to the
+ * pre-change code (the zero-regression guarantee).
+ *
+ * Core stays config/account-agnostic: it only knows opaque `providerId` /
+ * `accountId` strings + a {@link ProxyConfig} descriptor. The daemon injects the
+ * layered lookup via {@link setUpstreamProxyResolver} — the same module-slot
+ * pattern as `setSubscriptionRegistryForOutbound`. Core never imports config or
+ * account material.
+ *
+ * Dispatchers are CACHED by resolved-proxy identity (one instance reused, not
+ * per-request, so keep-alive holds and sockets don't leak). A config change bumps
+ * a generation via {@link bumpUpstreamProxyGeneration} (also called by
+ * `setUpstreamProxyResolver`) which disposes the old dispatchers and rebuilds on
+ * next use.
+ *
+ * FROZEN SEAM: `#7` (client fingerprint) attaches per-account TLS/agent behavior
+ * at this SAME dispatcher point — do not fork a second egress path.
+ *
+ * DEBUG TRACE: when the daemon installs an upstream-trace path (gated on the
+ * audit `captureBodies` opt-in), relay calls (`ctx.providerId` set) clone the
+ * response and append the FULL exchange (request + verbatim response incl. SSE)
+ * to the trace file. Absent a path (the default) it is a pure no-op — zero
+ * regression. See `upstreamTrace.ts`.
+ *
+ * @module @omnicross/core/pipeline/upstreamFetch
+ */
+
+/** The opaque call context the resolver maps to a proxy (precedence input). */
+interface UpstreamProxyContext {
+    /** The subscription provider id (`claude`/`codex`/`gemini`/`opencodego`) or `'byo'`. */
+    providerId?: string;
+    /** The selected pooled account id (per-account override input). */
+    accountId?: string;
+    /**
+     * The target upstream URL. Injected by {@link fetchUpstream} so the resolver can
+     * apply host-based bypass (loopback / `NO_PROXY`). Callers of the ingress helpers
+     * do NOT set this — it is filled from the fetch `url`.
+     */
+    url?: string;
+}
+/**
+ * The layered proxy lookup the daemon injects. Applies precedence
+ * account > provider > global > env and returns the WINNING `ProxyConfig`, or
+ * `undefined` for a direct (non-proxied) call.
+ */
+type UpstreamProxyResolver = (ctx: UpstreamProxyContext) => ProxyConfig | undefined;
+/**
+ * Inject (or clear, with `null`) the layered proxy resolver. Idempotent — last
+ * write wins. Bumps the dispatcher generation so a resolver swap (or a config
+ * edit that re-registers) rebuilds dispatchers from the new lookup and disposes
+ * the old ones.
+ */
+declare function setUpstreamProxyResolver(fn: UpstreamProxyResolver | null): void;
+/**
+ * Invalidate every cached dispatcher (config change / admin edit). Old
+ * dispatchers are `close()`d best-effort so in-flight sockets drain; new calls
+ * rebuild from the current resolver output.
+ */
+declare function bumpUpstreamProxyGeneration(): void;
+/**
+ * Resolve the dispatcher for one call. Returns `undefined` (⇒ bare fetch) when
+ * no resolver is registered, the resolver returns undefined, or the descriptor
+ * is malformed. A resolver throw is swallowed → direct call (egress never breaks
+ * on a proxy-lookup error).
+ */
+declare function resolveUpstreamDispatcher(ctx: UpstreamProxyContext): Dispatcher | undefined;
+/**
+ * Proxy-aware `fetch`. Attaches the resolved undici dispatcher ONLY when a proxy
+ * applies; otherwise it is a BARE `fetch(url, init)` — byte-identical to the
+ * pre-change egress (zero-regression). The `dispatcher` option is undici-specific
+ * (Node's global fetch IS undici); the cast threads it without a DOM-lib type.
+ */
+declare function fetchUpstream(url: string, init: RequestInit, ctx?: UpstreamProxyContext): Promise<Response>;
+/** TEST SEAM — clear the resolver + cache so a suite starts from the direct-fetch baseline. */
+declare function __resetUpstreamProxyForTests(): void;
+
+export { type UpstreamProxyContext, type UpstreamProxyResolver, __resetUpstreamProxyForTests, bumpUpstreamProxyGeneration, fetchUpstream, resolveUpstreamDispatcher, setUpstreamProxyResolver };

package/dist/pipeline/upstreamFetch.js

@@ -0,0 +1,15 @@
+import {
+  __resetUpstreamProxyForTests,
+  bumpUpstreamProxyGeneration,
+  fetchUpstream,
+  resolveUpstreamDispatcher,
+  setUpstreamProxyResolver
+} from "../chunk-D3TDKWRP.js";
+import "../chunk-SYQF7OIR.js";
+export {
+  __resetUpstreamProxyForTests,
+  bumpUpstreamProxyGeneration,
+  fetchUpstream,
+  resolveUpstreamDispatcher,
+  setUpstreamProxyResolver
+};

package/dist/pipeline/upstreamTrace.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunk3Z5BQZFMcjs = require('../chunk-3Z5BQZFM.cjs');
+
+
+
+
+
+
+exports.__resetUpstreamTraceForTests = _chunk3Z5BQZFMcjs.__resetUpstreamTraceForTests; exports.getUpstreamTracePath = _chunk3Z5BQZFMcjs.getUpstreamTracePath; exports.redactHeaders = _chunk3Z5BQZFMcjs.redactHeaders; exports.setUpstreamTracePath = _chunk3Z5BQZFMcjs.setUpstreamTracePath; exports.writeUpstreamTrace = _chunk3Z5BQZFMcjs.writeUpstreamTrace;

package/dist/pipeline/upstreamTrace.d.cts

@@ -0,0 +1,85 @@
+/**
+ * upstreamTrace — opt-in COMPLETE upstream-exchange capture for debugging
+ * (the omnicross → provider leg, e.g. the codex Responses call).
+ *
+ * The request-audit-log (`auditCapture`) only sees the CLIENT-facing leg
+ * (what the client sent to omnicross + what omnicross returned). It can NOT
+ * show the actual upstream provider request/response — and for a streaming
+ * codex reply it records metadata only. Every protocol-level codex bug
+ * (missing `Content-Type`, `store:false`, `input_text`, …) lives in the
+ * UPSTREAM exchange, so this module captures it verbatim.
+ *
+ * {@link fetchUpstream} is the single egress seam for every upstream call.
+ * When a trace path is installed it clones the response, reads the FULL body
+ * (a `text/event-stream` included — `clone().text()` tees the stream so the
+ * relay keeps streaming the original while the clone is buffered for the
+ * trace), and appends one {@link UpstreamTraceRecord} JSON line. Relay calls
+ * carry an opaque `providerId`; OAuth-refresh / webhook sends do not, so they
+ * are skipped (less noise). Tracing is fire-and-forget: a read/write failure
+ * is swallowed so the egress path is never affected.
+ *
+ * The daemon installs the path via {@link setUpstreamTracePath} (gated on the
+ * audit segment's `captureBodies`, hot-reloaded like the audit sink). Absent a
+ * path the trace is a pure no-op — byte-identical zero regression.
+ *
+ * Secret discipline: request/response AUTHORIZATION + api-key HEADER values are
+ * masked (`***REDACTED***`) — they are OAuth bearer tokens, not the thing under
+ * test, and a plaintext trace file must not hold them. Header KEYS stay visible
+ * so presence is verifiable. The request/response BODIES are captured VERBATIM
+ * (a prompt / a codex SSE stream) — that is the whole point.
+ *
+ * @module @omnicross/core/pipeline/upstreamTrace
+ */
+/**
+ * Install (or clear, with `null`/blank) the trace file path. Idempotent — last
+ * write wins. The path is resolved by the daemon relative to the audit store.
+ */
+declare function setUpstreamTracePath(path: string | null): void;
+/** The active trace file path, or `null` when tracing is disabled. */
+declare function getUpstreamTracePath(): string | null;
+/**
+ * Mask secret header values while keeping the keys. Accepts a web `Headers`
+ * (from a fetch response) or a plain `Record<string,string>` (from a relay
+ * `buildHeaders`). Never throws.
+ */
+declare function redactHeaders(headers: Headers | Record<string, string> | Array<[string, string]> | undefined | null): Record<string, string>;
+/** One complete upstream-exchange trace record (appended as one JSON line). */
+interface UpstreamTraceRecord {
+    /** Epoch ms the call started (request send time). */
+    ts: number;
+    /** Round-trip duration in ms (response fully read). */
+    durationMs: number;
+    /** The opaque relay provider id (`codex`/`claude`/`gemini`/`opencodego`/`byo`). */
+    providerId?: string;
+    /** The selected pooled account id, when the relay reported one. */
+    accountId?: string;
+    /** The upstream URL the request was sent to. */
+    url: string;
+    /** HTTP method. */
+    method: string;
+    /** Outbound request headers (secret values masked). */
+    requestHeaders: Record<string, string>;
+    /** Outbound request body verbatim (the codex Responses payload), when a string. */
+    requestBody: string | null;
+    /** Upstream HTTP status (`0` when the fetch itself failed). */
+    status: number;
+    /** Upstream HTTP status text. */
+    statusText: string;
+    /** Upstream response headers. */
+    responseHeaders: Record<string, string>;
+    /** Upstream response body verbatim — the FULL `text/event-stream` for a stream. */
+    responseBody: string;
+    /** Response body size in UTF-8 bytes. */
+    responseBytes: number;
+}
+/**
+ * Append one trace record to the installed file. A no-op (zero work) when no
+ * path is installed. Fire-and-forget safe: any fs error is swallowed — a trace
+ * failure must NEVER surface into the egress path. ASYNC so a slow disk / large
+ * SSE body never blocks the event loop (the call site does not await it).
+ */
+declare function writeUpstreamTrace(record: UpstreamTraceRecord): Promise<void>;
+/** TEST SEAM — clear the trace path so a suite starts from the no-trace baseline. */
+declare function __resetUpstreamTraceForTests(): void;
+
+export { type UpstreamTraceRecord, __resetUpstreamTraceForTests, getUpstreamTracePath, redactHeaders, setUpstreamTracePath, writeUpstreamTrace };

package/dist/pipeline/upstreamTrace.d.ts

@@ -0,0 +1,85 @@
+/**
+ * upstreamTrace — opt-in COMPLETE upstream-exchange capture for debugging
+ * (the omnicross → provider leg, e.g. the codex Responses call).
+ *
+ * The request-audit-log (`auditCapture`) only sees the CLIENT-facing leg
+ * (what the client sent to omnicross + what omnicross returned). It can NOT
+ * show the actual upstream provider request/response — and for a streaming
+ * codex reply it records metadata only. Every protocol-level codex bug
+ * (missing `Content-Type`, `store:false`, `input_text`, …) lives in the
+ * UPSTREAM exchange, so this module captures it verbatim.
+ *
+ * {@link fetchUpstream} is the single egress seam for every upstream call.
+ * When a trace path is installed it clones the response, reads the FULL body
+ * (a `text/event-stream` included — `clone().text()` tees the stream so the
+ * relay keeps streaming the original while the clone is buffered for the
+ * trace), and appends one {@link UpstreamTraceRecord} JSON line. Relay calls
+ * carry an opaque `providerId`; OAuth-refresh / webhook sends do not, so they
+ * are skipped (less noise). Tracing is fire-and-forget: a read/write failure
+ * is swallowed so the egress path is never affected.
+ *
+ * The daemon installs the path via {@link setUpstreamTracePath} (gated on the
+ * audit segment's `captureBodies`, hot-reloaded like the audit sink). Absent a
+ * path the trace is a pure no-op — byte-identical zero regression.
+ *
+ * Secret discipline: request/response AUTHORIZATION + api-key HEADER values are
+ * masked (`***REDACTED***`) — they are OAuth bearer tokens, not the thing under
+ * test, and a plaintext trace file must not hold them. Header KEYS stay visible
+ * so presence is verifiable. The request/response BODIES are captured VERBATIM
+ * (a prompt / a codex SSE stream) — that is the whole point.
+ *
+ * @module @omnicross/core/pipeline/upstreamTrace
+ */
+/**
+ * Install (or clear, with `null`/blank) the trace file path. Idempotent — last
+ * write wins. The path is resolved by the daemon relative to the audit store.
+ */
+declare function setUpstreamTracePath(path: string | null): void;
+/** The active trace file path, or `null` when tracing is disabled. */
+declare function getUpstreamTracePath(): string | null;
+/**
+ * Mask secret header values while keeping the keys. Accepts a web `Headers`
+ * (from a fetch response) or a plain `Record<string,string>` (from a relay
+ * `buildHeaders`). Never throws.
+ */
+declare function redactHeaders(headers: Headers | Record<string, string> | Array<[string, string]> | undefined | null): Record<string, string>;
+/** One complete upstream-exchange trace record (appended as one JSON line). */
+interface UpstreamTraceRecord {
+    /** Epoch ms the call started (request send time). */
+    ts: number;
+    /** Round-trip duration in ms (response fully read). */
+    durationMs: number;
+    /** The opaque relay provider id (`codex`/`claude`/`gemini`/`opencodego`/`byo`). */
+    providerId?: string;
+    /** The selected pooled account id, when the relay reported one. */
+    accountId?: string;
+    /** The upstream URL the request was sent to. */
+    url: string;
+    /** HTTP method. */
+    method: string;
+    /** Outbound request headers (secret values masked). */
+    requestHeaders: Record<string, string>;
+    /** Outbound request body verbatim (the codex Responses payload), when a string. */
+    requestBody: string | null;
+    /** Upstream HTTP status (`0` when the fetch itself failed). */
+    status: number;
+    /** Upstream HTTP status text. */
+    statusText: string;
+    /** Upstream response headers. */
+    responseHeaders: Record<string, string>;
+    /** Upstream response body verbatim — the FULL `text/event-stream` for a stream. */
+    responseBody: string;
+    /** Response body size in UTF-8 bytes. */
+    responseBytes: number;
+}
+/**
+ * Append one trace record to the installed file. A no-op (zero work) when no
+ * path is installed. Fire-and-forget safe: any fs error is swallowed — a trace
+ * failure must NEVER surface into the egress path. ASYNC so a slow disk / large
+ * SSE body never blocks the event loop (the call site does not await it).
+ */
+declare function writeUpstreamTrace(record: UpstreamTraceRecord): Promise<void>;
+/** TEST SEAM — clear the trace path so a suite starts from the no-trace baseline. */
+declare function __resetUpstreamTraceForTests(): void;
+
+export { type UpstreamTraceRecord, __resetUpstreamTraceForTests, getUpstreamTracePath, redactHeaders, setUpstreamTracePath, writeUpstreamTrace };

package/dist/pipeline/upstreamTrace.js

@@ -0,0 +1,14 @@
+import {
+  __resetUpstreamTraceForTests,
+  getUpstreamTracePath,
+  redactHeaders,
+  setUpstreamTracePath,
+  writeUpstreamTrace
+} from "../chunk-SYQF7OIR.js";
+export {
+  __resetUpstreamTraceForTests,
+  getUpstreamTracePath,
+  redactHeaders,
+  setUpstreamTracePath,
+  writeUpstreamTrace
+};

package/dist/pipeline/webhookEmit.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkUIBD2YY5cjs = require('../chunk-UIBD2YY5.cjs');
+
+
+
+
+exports.__resetWebhookSinkForTests = _chunkUIBD2YY5cjs.__resetWebhookSinkForTests; exports.emitWebhookEvent = _chunkUIBD2YY5cjs.emitWebhookEvent; exports.setWebhookSink = _chunkUIBD2YY5cjs.setWebhookSink;

package/dist/pipeline/webhookEmit.d.cts

@@ -0,0 +1,36 @@
+import { WebhookEvent } from '@omnicross/contracts/webhook-types';
+
+/**
+ * webhookEmit — the module-slot emit port for `@omnicross/core`
+ * (webhook-notifications, design D2).
+ *
+ * Core SOURCES (the wire quota path in `outboundApiRouter`, the relay/dispatch
+ * error path) call {@link emitWebhookEvent}. The concrete `WebhookDispatcher`
+ * (config/secrets/HTTP/HMAC) lives in the DAEMON and registers itself as the
+ * sink at bootstrap via {@link setWebhookSink}. Core imports NOTHING from the
+ * daemon — exactly the `setSharedAccountHealth` / `setUpstreamProxyResolver`
+ * precedent.
+ *
+ * HARD CONTRACT (design D2 / risk "a webhook blocking the request path"):
+ * {@link emitWebhookEvent} NEVER throws and NEVER awaits. It hands the event to
+ * the sink (which enqueues and returns immediately) — a slow/failing/throwing
+ * sink can never affect the caller. Absent a sink it is a pure no-op, so a
+ * no-webhook-config daemon is byte-identical to before this change.
+ *
+ * @module @omnicross/core/pipeline/webhookEmit
+ */
+
+/** The sink the daemon registers; it MUST enqueue-and-return (never block). */
+type WebhookSink = (event: WebhookEvent) => void;
+/** Install (or clear, with `null`) the webhook sink. Idempotent; last write wins. */
+declare function setWebhookSink(fn: WebhookSink | null): void;
+/**
+ * Emit a webhook event to the registered sink. A no-op when no sink is set
+ * (zero regression). NEVER throws (a misbehaving sink is swallowed) and NEVER
+ * awaits (the sink enqueues + returns) — so no request path is ever delayed.
+ */
+declare function emitWebhookEvent(event: WebhookEvent): void;
+/** TEST SEAM — clear the sink so a suite starts from the no-sink baseline. */
+declare function __resetWebhookSinkForTests(): void;
+
+export { type WebhookSink, __resetWebhookSinkForTests, emitWebhookEvent, setWebhookSink };

package/dist/pipeline/webhookEmit.d.ts

@@ -0,0 +1,36 @@
+import { WebhookEvent } from '@omnicross/contracts/webhook-types';
+
+/**
+ * webhookEmit — the module-slot emit port for `@omnicross/core`
+ * (webhook-notifications, design D2).
+ *
+ * Core SOURCES (the wire quota path in `outboundApiRouter`, the relay/dispatch
+ * error path) call {@link emitWebhookEvent}. The concrete `WebhookDispatcher`
+ * (config/secrets/HTTP/HMAC) lives in the DAEMON and registers itself as the
+ * sink at bootstrap via {@link setWebhookSink}. Core imports NOTHING from the
+ * daemon — exactly the `setSharedAccountHealth` / `setUpstreamProxyResolver`
+ * precedent.
+ *
+ * HARD CONTRACT (design D2 / risk "a webhook blocking the request path"):
+ * {@link emitWebhookEvent} NEVER throws and NEVER awaits. It hands the event to
+ * the sink (which enqueues and returns immediately) — a slow/failing/throwing
+ * sink can never affect the caller. Absent a sink it is a pure no-op, so a
+ * no-webhook-config daemon is byte-identical to before this change.
+ *
+ * @module @omnicross/core/pipeline/webhookEmit
+ */
+
+/** The sink the daemon registers; it MUST enqueue-and-return (never block). */
+type WebhookSink = (event: WebhookEvent) => void;
+/** Install (or clear, with `null`) the webhook sink. Idempotent; last write wins. */
+declare function setWebhookSink(fn: WebhookSink | null): void;
+/**
+ * Emit a webhook event to the registered sink. A no-op when no sink is set
+ * (zero regression). NEVER throws (a misbehaving sink is swallowed) and NEVER
+ * awaits (the sink enqueues + returns) — so no request path is ever delayed.
+ */
+declare function emitWebhookEvent(event: WebhookEvent): void;
+/** TEST SEAM — clear the sink so a suite starts from the no-sink baseline. */
+declare function __resetWebhookSinkForTests(): void;
+
+export { type WebhookSink, __resetWebhookSinkForTests, emitWebhookEvent, setWebhookSink };