@omnicross/core 0.1.1 → 0.1.3

package/dist/pipeline/SubscriptionAuthSource.js

@@ -1,102 +1,8 @@
-// src/serializeError.ts
-function serializeError(err) {
-  if (err == null) return "Unknown error (null)";
-  if (err instanceof Error) {
-    let msg = err.message || err.name || "Error";
-    if (err.cause) {
-      msg += ` [cause: ${serializeError(err.cause)}]`;
-    }
-    const anyErr = err;
-    if (anyErr.status != null) msg += ` (status: ${anyErr.status})`;
-    else if (anyErr.code != null) msg += ` (code: ${anyErr.code})`;
-    return msg;
-  }
-  if (typeof err === "string") return err || "Empty error string";
-  if (typeof err !== "object") return String(err);
-  const obj = err;
-  if (typeof obj.message === "string" && obj.message) {
-    let msg = obj.message;
-    if (obj.status != null) msg += ` (status: ${obj.status})`;
-    else if (obj.code != null) msg += ` (code: ${obj.code})`;
-    if (typeof obj.type === "string") msg += ` [type: ${obj.type}]`;
-    return msg;
-  }
-  if (typeof obj.error === "string" && obj.error) {
-    return obj.error;
-  }
-  if (obj.error && typeof obj.error === "object") {
-    const inner = obj.error;
-    if (typeof inner.message === "string" && inner.message) {
-      let msg = inner.message;
-      if (typeof inner.type === "string") msg += ` [type: ${inner.type}]`;
-      return msg;
-    }
-  }
-  try {
-    const json = JSON.stringify(err, getCircularReplacer(), 2);
-    if (json && json.length > 1e3) {
-      return json.slice(0, 1e3) + "... (truncated)";
-    }
-    return json || "Unserializable error";
-  } catch {
-    return `Unserializable error: ${Object.prototype.toString.call(err)}`;
-  }
-}
-function getCircularReplacer() {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return (_key, value) => {
-    if (typeof value === "object" && value !== null) {
-      if (seen.has(value)) return "[Circular]";
-      seen.add(value);
-    }
-    return value;
-  };
-}
-
-// src/pipeline/SubscriptionAuthSource.ts
-function stripAuthHeaders(headers) {
-  delete headers.authorization;
-  delete headers.Authorization;
-  delete headers["x-api-key"];
-  delete headers["X-Api-Key"];
-  delete headers["x-goog-api-key"];
-  delete headers["X-Goog-Api-Key"];
-}
-var SubscriptionAuthSource = class {
-  constructor(profile) {
-    this.profile = profile;
-  }
-  profile;
-  /**
-   * Strip any transformer-set auth headers, then delegate to the bound
-   * strategy. Mirrors `SubscriptionDispatcher`'s
-   * `stripAuthHeaders(...)` + `applyHeadersWithRetry(...)` sequence, including
-   * the best-effort swallow-and-warn around a throwing `applyHeaders`.
-   *
-   * The strategy's looser `AuthApplyHints` (optional `upstreamUrl` /
-   * `resolvedModel`) is fed from the pipeline's required `{ upstreamUrl,
-   * model }` at the boundary.
-   */
-  async applyHeaders(headers, hints) {
-    stripAuthHeaders(headers);
-    try {
-      await this.profile.authStrategy.applyHeaders(headers, {
-        upstreamUrl: hints.upstreamUrl,
-        resolvedModel: hints.model
-      });
-    } catch (err) {
-      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", serializeError(err));
-    }
-  }
-  /** Delegate the 401-refresh decision to the bound strategy. */
-  async onUnauthorized() {
-    return this.profile.authStrategy.onUnauthorized();
-  }
-  /** Resolve the upstream URL from the profile, when it provides one. */
-  resolveUpstreamUrl(model) {
-    return this.profile.resolveUpstreamUrl?.(model);
-  }
-};
+import {
+  SubscriptionAuthSource,
+  stripAuthHeaders
+} from "../chunk-N5QFKSDO.js";
+import "../chunk-AVYJ4YBN.js";
 export {
   SubscriptionAuthSource,
   stripAuthHeaders

package/dist/pipeline/SubscriptionAuthStrategy.cjs

@@ -1,18 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/pipeline/SubscriptionAuthStrategy.ts
-var SubscriptionAuthStrategy_exports = {};
-module.exports = __toCommonJS(SubscriptionAuthStrategy_exports);
+"use strict";

package/dist/pipeline/SubscriptionAuthStrategy.d.cts

@@ -31,6 +31,24 @@ interface AuthApplyHints {
     upstreamUrl?: string;
     /** Resolved model id — same purpose as `upstreamUrl`. */
     resolvedModel?: string;
+    /**
+     * Stable per-conversation session key (subscription-account-scheduling, D5).
+     * When present it drives the account pool's sticky session affinity; absent ⇒
+     * pure priority/LRU selection (still correct — affinity only loses stickiness).
+     */
+    sessionKey?: string;
+    /**
+     * Per-request selection callback (subscription-account-health, D5;
+     * subscription-account-model-map, D3). The strategy invokes it with the
+     * EFFECTIVE account id it resolved so the relay can mark that account's health
+     * against the upstream outcome. The OPTIONAL 3rd `remappedModel` carries the
+     * selected account's ACTUAL upstream model when its `supportedModels` object
+     * remaps `resolvedModel` — the relay rewrites the outbound `body.model` to it on
+     * the pass-through / same-format path; absent ⇒ the body is forwarded verbatim.
+     * Absent callback ⇒ health simply isn't marked on that path (degrades to the
+     * pre-health behavior).
+     */
+    reportSelection?: (accountId: string, isActive: boolean, remappedModel?: string) => void;
 }
 interface AuthStrategy {
     /** Discriminator — also surfaced through `subscription:list` to renderers. */
@@ -52,8 +70,13 @@ interface AuthStrategy {
      *
      * Implementations SHOULD use a shared `RefreshMutex` to dedupe concurrent
      * refreshes so N parallel 401s collapse into one upstream refresh call.
+     *
+     * The OPTIONAL `sessionKey` (subscription-account-scheduling, D7) refreshes the
+     * account the request was ACTUALLY served by: when it resolves to a sticky
+     * non-active account the strategy refreshes THAT account by id; absent (or an
+     * active pick) ⇒ the active-account refresh, unchanged.
      */
-    onUnauthorized(): Promise<boolean>;
+    onUnauthorized(sessionKey?: string): Promise<boolean>;
     /** Diagnostic surface for the `subscription:status` IPC. */
     describeStatus(): Promise<SubscriptionStatusEntry>;
 }

package/dist/pipeline/SubscriptionAuthStrategy.d.ts

@@ -31,6 +31,24 @@ interface AuthApplyHints {
     upstreamUrl?: string;
     /** Resolved model id — same purpose as `upstreamUrl`. */
     resolvedModel?: string;
+    /**
+     * Stable per-conversation session key (subscription-account-scheduling, D5).
+     * When present it drives the account pool's sticky session affinity; absent ⇒
+     * pure priority/LRU selection (still correct — affinity only loses stickiness).
+     */
+    sessionKey?: string;
+    /**
+     * Per-request selection callback (subscription-account-health, D5;
+     * subscription-account-model-map, D3). The strategy invokes it with the
+     * EFFECTIVE account id it resolved so the relay can mark that account's health
+     * against the upstream outcome. The OPTIONAL 3rd `remappedModel` carries the
+     * selected account's ACTUAL upstream model when its `supportedModels` object
+     * remaps `resolvedModel` — the relay rewrites the outbound `body.model` to it on
+     * the pass-through / same-format path; absent ⇒ the body is forwarded verbatim.
+     * Absent callback ⇒ health simply isn't marked on that path (degrades to the
+     * pre-health behavior).
+     */
+    reportSelection?: (accountId: string, isActive: boolean, remappedModel?: string) => void;
 }
 interface AuthStrategy {
     /** Discriminator — also surfaced through `subscription:list` to renderers. */
@@ -52,8 +70,13 @@ interface AuthStrategy {
      *
      * Implementations SHOULD use a shared `RefreshMutex` to dedupe concurrent
      * refreshes so N parallel 401s collapse into one upstream refresh call.
+     *
+     * The OPTIONAL `sessionKey` (subscription-account-scheduling, D7) refreshes the
+     * account the request was ACTUALLY served by: when it resolves to a sticky
+     * non-active account the strategy refreshes THAT account by id; absent (or an
+     * active pick) ⇒ the active-account refresh, unchanged.
      */
-    onUnauthorized(): Promise<boolean>;
+    onUnauthorized(sessionKey?: string): Promise<boolean>;
     /** Diagnostic surface for the `subscription:status` IPC. */
     describeStatus(): Promise<SubscriptionStatusEntry>;
 }

package/dist/pipeline/auditSink.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkAEOZIDEBcjs = require('../chunk-AEOZIDEB.cjs');
+
+
+
+
+
+
+exports.__resetAuditSinkForTests = _chunkAEOZIDEBcjs.__resetAuditSinkForTests; exports.getAuditCaptureConfig = _chunkAEOZIDEBcjs.getAuditCaptureConfig; exports.recordAudit = _chunkAEOZIDEBcjs.recordAudit; exports.setAuditCaptureConfig = _chunkAEOZIDEBcjs.setAuditCaptureConfig; exports.setAuditSink = _chunkAEOZIDEBcjs.setAuditSink;

package/dist/pipeline/auditSink.d.cts

@@ -0,0 +1,48 @@
+import { AuditRecord, AuditConfig } from '@omnicross/contracts/audit-types';
+
+/**
+ * auditSink — the module-slot sink + capture-config port for `@omnicross/core`
+ * (request-audit-log, design D5).
+ *
+ * The outbound server's post-response capture hook calls {@link recordAudit}
+ * with an assembled {@link AuditRecord}. The concrete `AuditWriter` (the
+ * date-rotated jsonl store) lives in the DAEMON and registers itself as the sink
+ * at bootstrap via {@link setAuditSink}. Core imports NOTHING from the daemon —
+ * exactly the `setWebhookSink` / `setUpstreamProxyResolver` precedent.
+ *
+ * A SECOND slot holds the active {@link AuditConfig} ({@link setAuditCaptureConfig}
+ * / {@link getAuditCaptureConfig}). The capture hook reads it to GATE assembly:
+ * absent/`enabled:false` ⇒ the hook does nothing (not even record assembly), so
+ * audit-disabled is byte-identical zero regression. The daemon sets BOTH slots
+ * together (config + sink) when audit is enabled and clears BOTH when disabled.
+ *
+ * HARD CONTRACT (design D5 / risk "the audit write adding latency"):
+ * {@link recordAudit} NEVER throws and NEVER awaits — it hands the record to the
+ * sink (which enqueues and returns immediately) and swallows any sink error, so
+ * a slow/failing/throwing writer can never affect the relay path. Absent a sink
+ * it is a pure no-op.
+ *
+ * @module @omnicross/core/pipeline/auditSink
+ */
+
+/** The sink the daemon registers; it MUST enqueue-and-return (never block/throw). */
+type AuditSink = (record: AuditRecord) => void;
+/** Install (or clear, with `null`) the audit sink. Idempotent; last write wins. */
+declare function setAuditSink(fn: AuditSink | null): void;
+/**
+ * Install (or clear, with `null`) the active audit-capture config. `null` (or an
+ * `enabled:false` config) disables capture entirely — the hook does no work.
+ */
+declare function setAuditCaptureConfig(config: AuditConfig | null): void;
+/** The active capture config, or `null` when audit is disabled/unset. */
+declare function getAuditCaptureConfig(): AuditConfig | null;
+/**
+ * Hand one audit record 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 relay path is ever delayed.
+ */
+declare function recordAudit(record: AuditRecord): void;
+/** TEST SEAM — clear both slots so a suite starts from the no-audit baseline. */
+declare function __resetAuditSinkForTests(): void;
+
+export { type AuditSink, __resetAuditSinkForTests, getAuditCaptureConfig, recordAudit, setAuditCaptureConfig, setAuditSink };

package/dist/pipeline/auditSink.d.ts

@@ -0,0 +1,48 @@
+import { AuditRecord, AuditConfig } from '@omnicross/contracts/audit-types';
+
+/**
+ * auditSink — the module-slot sink + capture-config port for `@omnicross/core`
+ * (request-audit-log, design D5).
+ *
+ * The outbound server's post-response capture hook calls {@link recordAudit}
+ * with an assembled {@link AuditRecord}. The concrete `AuditWriter` (the
+ * date-rotated jsonl store) lives in the DAEMON and registers itself as the sink
+ * at bootstrap via {@link setAuditSink}. Core imports NOTHING from the daemon —
+ * exactly the `setWebhookSink` / `setUpstreamProxyResolver` precedent.
+ *
+ * A SECOND slot holds the active {@link AuditConfig} ({@link setAuditCaptureConfig}
+ * / {@link getAuditCaptureConfig}). The capture hook reads it to GATE assembly:
+ * absent/`enabled:false` ⇒ the hook does nothing (not even record assembly), so
+ * audit-disabled is byte-identical zero regression. The daemon sets BOTH slots
+ * together (config + sink) when audit is enabled and clears BOTH when disabled.
+ *
+ * HARD CONTRACT (design D5 / risk "the audit write adding latency"):
+ * {@link recordAudit} NEVER throws and NEVER awaits — it hands the record to the
+ * sink (which enqueues and returns immediately) and swallows any sink error, so
+ * a slow/failing/throwing writer can never affect the relay path. Absent a sink
+ * it is a pure no-op.
+ *
+ * @module @omnicross/core/pipeline/auditSink
+ */
+
+/** The sink the daemon registers; it MUST enqueue-and-return (never block/throw). */
+type AuditSink = (record: AuditRecord) => void;
+/** Install (or clear, with `null`) the audit sink. Idempotent; last write wins. */
+declare function setAuditSink(fn: AuditSink | null): void;
+/**
+ * Install (or clear, with `null`) the active audit-capture config. `null` (or an
+ * `enabled:false` config) disables capture entirely — the hook does no work.
+ */
+declare function setAuditCaptureConfig(config: AuditConfig | null): void;
+/** The active capture config, or `null` when audit is disabled/unset. */
+declare function getAuditCaptureConfig(): AuditConfig | null;
+/**
+ * Hand one audit record 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 relay path is ever delayed.
+ */
+declare function recordAudit(record: AuditRecord): void;
+/** TEST SEAM — clear both slots so a suite starts from the no-audit baseline. */
+declare function __resetAuditSinkForTests(): void;
+
+export { type AuditSink, __resetAuditSinkForTests, getAuditCaptureConfig, recordAudit, setAuditCaptureConfig, setAuditSink };

package/dist/pipeline/auditSink.js

@@ -0,0 +1,14 @@
+import {
+  __resetAuditSinkForTests,
+  getAuditCaptureConfig,
+  recordAudit,
+  setAuditCaptureConfig,
+  setAuditSink
+} from "../chunk-WNY4WMRF.js";
+export {
+  __resetAuditSinkForTests,
+  getAuditCaptureConfig,
+  recordAudit,
+  setAuditCaptureConfig,
+  setAuditSink
+};

package/dist/pipeline/billingEmit.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkL74VDN4Acjs = require('../chunk-L74VDN4A.cjs');
+
+
+
+
+
+
+exports.__resetBillingSinkForTests = _chunkL74VDN4Acjs.__resetBillingSinkForTests; exports.getBillingCaptureConfig = _chunkL74VDN4Acjs.getBillingCaptureConfig; exports.publishBillingEvent = _chunkL74VDN4Acjs.publishBillingEvent; exports.setBillingCaptureConfig = _chunkL74VDN4Acjs.setBillingCaptureConfig; exports.setBillingSink = _chunkL74VDN4Acjs.setBillingSink;

package/dist/pipeline/billingEmit.d.cts

@@ -0,0 +1,49 @@
+import { BillingEvent, BillingConfig } from '@omnicross/contracts/billing-types';
+
+/**
+ * billingEmit — the module-slot sink + capture-gate port for `@omnicross/core`
+ * (billing-event-stream, design D4/D7).
+ *
+ * The outbound server's post-response billing hook calls {@link publishBillingEvent}
+ * with an assembled {@link BillingEvent}. The concrete `BillingPublisher` (the
+ * durable-first jsonl ledger + built-in POST) lives in the DAEMON and registers
+ * itself as the sink at bootstrap via {@link setBillingSink}. Core imports NOTHING
+ * from the daemon — exactly the `setWebhookSink` / `setAuditSink` precedent.
+ *
+ * A SECOND slot holds the active {@link BillingConfig} ({@link setBillingCaptureConfig}
+ * / {@link getBillingCaptureConfig}). The capture hook reads it to GATE assembly:
+ * absent/`enabled:false` ⇒ the hook does nothing (not even event assembly), so
+ * billing-disabled is byte-identical zero regression. The daemon sets BOTH slots
+ * together (config + sink) when billing is enabled and clears BOTH when disabled.
+ *
+ * HARD CONTRACT (design D7 / risk "a billing POST blocking the request path"):
+ * {@link publishBillingEvent} NEVER throws and NEVER awaits — it hands the event
+ * to the sink (which durably appends + enqueues delivery and returns immediately)
+ * and swallows any sink error, so a slow/failing/throwing publisher can never
+ * affect the relay path. Absent a sink it is a pure no-op.
+ *
+ * @module @omnicross/core/pipeline/billingEmit
+ */
+
+/** The sink the daemon registers; it MUST durably-append-and-return (never block/throw). */
+type BillingSink = (event: BillingEvent) => void;
+/** Install (or clear, with `null`) the billing sink. Idempotent; last write wins. */
+declare function setBillingSink(fn: BillingSink | null): void;
+/**
+ * Install (or clear, with `null`) the active billing config. `null` (or an
+ * `enabled:false` config) disables the capture entirely — the hook does no work.
+ */
+declare function setBillingCaptureConfig(config: BillingConfig | null): void;
+/** The active billing config, or `null` when billing is disabled/unset. */
+declare function getBillingCaptureConfig(): BillingConfig | null;
+/**
+ * Publish one billing 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 durably appends + enqueues delivery, then returns) — so no
+ * relay path is ever delayed.
+ */
+declare function publishBillingEvent(event: BillingEvent): void;
+/** TEST SEAM — clear both slots so a suite starts from the no-billing baseline. */
+declare function __resetBillingSinkForTests(): void;
+
+export { type BillingSink, __resetBillingSinkForTests, getBillingCaptureConfig, publishBillingEvent, setBillingCaptureConfig, setBillingSink };

package/dist/pipeline/billingEmit.d.ts

@@ -0,0 +1,49 @@
+import { BillingEvent, BillingConfig } from '@omnicross/contracts/billing-types';
+
+/**
+ * billingEmit — the module-slot sink + capture-gate port for `@omnicross/core`
+ * (billing-event-stream, design D4/D7).
+ *
+ * The outbound server's post-response billing hook calls {@link publishBillingEvent}
+ * with an assembled {@link BillingEvent}. The concrete `BillingPublisher` (the
+ * durable-first jsonl ledger + built-in POST) lives in the DAEMON and registers
+ * itself as the sink at bootstrap via {@link setBillingSink}. Core imports NOTHING
+ * from the daemon — exactly the `setWebhookSink` / `setAuditSink` precedent.
+ *
+ * A SECOND slot holds the active {@link BillingConfig} ({@link setBillingCaptureConfig}
+ * / {@link getBillingCaptureConfig}). The capture hook reads it to GATE assembly:
+ * absent/`enabled:false` ⇒ the hook does nothing (not even event assembly), so
+ * billing-disabled is byte-identical zero regression. The daemon sets BOTH slots
+ * together (config + sink) when billing is enabled and clears BOTH when disabled.
+ *
+ * HARD CONTRACT (design D7 / risk "a billing POST blocking the request path"):
+ * {@link publishBillingEvent} NEVER throws and NEVER awaits — it hands the event
+ * to the sink (which durably appends + enqueues delivery and returns immediately)
+ * and swallows any sink error, so a slow/failing/throwing publisher can never
+ * affect the relay path. Absent a sink it is a pure no-op.
+ *
+ * @module @omnicross/core/pipeline/billingEmit
+ */
+
+/** The sink the daemon registers; it MUST durably-append-and-return (never block/throw). */
+type BillingSink = (event: BillingEvent) => void;
+/** Install (or clear, with `null`) the billing sink. Idempotent; last write wins. */
+declare function setBillingSink(fn: BillingSink | null): void;
+/**
+ * Install (or clear, with `null`) the active billing config. `null` (or an
+ * `enabled:false` config) disables the capture entirely — the hook does no work.
+ */
+declare function setBillingCaptureConfig(config: BillingConfig | null): void;
+/** The active billing config, or `null` when billing is disabled/unset. */
+declare function getBillingCaptureConfig(): BillingConfig | null;
+/**
+ * Publish one billing 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 durably appends + enqueues delivery, then returns) — so no
+ * relay path is ever delayed.
+ */
+declare function publishBillingEvent(event: BillingEvent): void;
+/** TEST SEAM — clear both slots so a suite starts from the no-billing baseline. */
+declare function __resetBillingSinkForTests(): void;
+
+export { type BillingSink, __resetBillingSinkForTests, getBillingCaptureConfig, publishBillingEvent, setBillingCaptureConfig, setBillingSink };

package/dist/pipeline/billingEmit.js

@@ -0,0 +1,14 @@
+import {
+  __resetBillingSinkForTests,
+  getBillingCaptureConfig,
+  publishBillingEvent,
+  setBillingCaptureConfig,
+  setBillingSink
+} from "../chunk-TKJMZBAH.js";
+export {
+  __resetBillingSinkForTests,
+  getBillingCaptureConfig,
+  publishBillingEvent,
+  setBillingCaptureConfig,
+  setBillingSink
+};

package/dist/pipeline/executeProviderCall.cjs

@@ -1,70 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/pipeline/executeProviderCall.ts
-var executeProviderCall_exports = {};
-__export(executeProviderCall_exports, {
-  executeProviderCall: () => executeProviderCall
-});
-module.exports = __toCommonJS(executeProviderCall_exports);
-async function executeProviderCall(ctx) {
-  const {
-    executor,
-    request,
-    provider,
-    chain,
-    endpointTransformer,
-    extendedContext,
-    resolveUrl,
-    buildHeaders,
-    prepareBody,
-    fetchFn,
-    runResponseChain = false,
-    responseChainRequest
-  } = ctx;
-  const { requestBody, config } = await executor.executeRequestChain(
-    request,
-    provider,
-    chain,
-    { endpointTransformer, extendedContext }
-  );
-  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
-  const url = resolveUrl(config);
-  const headers = buildHeaders(config);
-  const fetched = await fetchFn(url, headers, finalBody);
-  let response = fetched;
-  if (runResponseChain) {
-    response = await executor.executeResponseChain(
-      // Preserve the EXACT first arg each site passed: proxy → requestBody,
-      // unified ingresses → their pre-transform request. The caller supplies
-      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
-      // shape) so the contract is never silently `undefined`.
-      responseChainRequest ?? requestBody,
-      fetched,
-      provider,
-      chain,
-      { endpointTransformer }
-    );
-  }
-  return { response, requestBody, finalBody, config, url, headers };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  executeProviderCall
-});
+var _chunkKUU2RNG6cjs = require('../chunk-KUU2RNG6.cjs');
+
+
+exports.executeProviderCall = _chunkKUU2RNG6cjs.executeProviderCall;

package/dist/pipeline/executeProviderCall.js

@@ -1,45 +1,6 @@
-// src/pipeline/executeProviderCall.ts
-async function executeProviderCall(ctx) {
-  const {
-    executor,
-    request,
-    provider,
-    chain,
-    endpointTransformer,
-    extendedContext,
-    resolveUrl,
-    buildHeaders,
-    prepareBody,
-    fetchFn,
-    runResponseChain = false,
-    responseChainRequest
-  } = ctx;
-  const { requestBody, config } = await executor.executeRequestChain(
-    request,
-    provider,
-    chain,
-    { endpointTransformer, extendedContext }
-  );
-  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
-  const url = resolveUrl(config);
-  const headers = buildHeaders(config);
-  const fetched = await fetchFn(url, headers, finalBody);
-  let response = fetched;
-  if (runResponseChain) {
-    response = await executor.executeResponseChain(
-      // Preserve the EXACT first arg each site passed: proxy → requestBody,
-      // unified ingresses → their pre-transform request. The caller supplies
-      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
-      // shape) so the contract is never silently `undefined`.
-      responseChainRequest ?? requestBody,
-      fetched,
-      provider,
-      chain,
-      { endpointTransformer }
-    );
-  }
-  return { response, requestBody, finalBody, config, url, headers };
-}
+import {
+  executeProviderCall
+} from "../chunk-JO5NLTLY.js";
 export {
   executeProviderCall
 };

package/dist/pipeline/resolveProviderChain.cjs

@@ -1,47 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/pipeline/resolveProviderChain.ts
-var resolveProviderChain_exports = {};
-__export(resolveProviderChain_exports, {
-  resolveProviderChain: () => resolveProviderChain
-});
-module.exports = __toCommonJS(resolveProviderChain_exports);
-async function resolveProviderChain(llmConfig, providerId, model) {
-  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
-  const mainTransformer = await llmConfig.getMainTransformer(providerId);
-  const chain = {
-    providerTransformers: [...cachedChain.providerTransformers],
-    modelTransformers: [...cachedChain.modelTransformers]
-  };
-  if (mainTransformer) {
-    const alreadyInChain = chain.providerTransformers.some(
-      (t) => t.name === mainTransformer.name
-    );
-    if (!alreadyInChain) {
-      chain.providerTransformers.unshift(mainTransformer);
-    }
-  }
-  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
-  return { chain, mainTransformer, hasTransformers };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  resolveProviderChain
-});
+var _chunkQXD4MV2Xcjs = require('../chunk-QXD4MV2X.cjs');
+
+
+exports.resolveProviderChain = _chunkQXD4MV2Xcjs.resolveProviderChain;