@omnicross/core 0.1.0 → 0.1.2

package/dist/pipeline/SubscriptionAuthSource.d.cts

@@ -1,3 +1,165 @@
-import '@omnicross/contracts/subscription-types';
-export { S as SubscriptionAuthProfile, a as SubscriptionAuthSource, b as SubscriptionRequestSummary, s as stripAuthHeaders } from '../SubscriptionAuthSource-Cr4fVEYY.cjs';
-import './SubscriptionAuthStrategy.cjs';
+import { OpenCodeGoTokenConfig, OpenCodeGoScenario, OpenCodeGoModelEntry } from '@omnicross/contracts/subscription-types';
+import { AuthSource, AuthApplyHints } from './AuthSource.cjs';
+import { AuthStrategy } from './SubscriptionAuthStrategy.cjs';
+
+/**
+ * SubscriptionAuthSource — `AuthSource` wrapping a subscription `AuthStrategy`.
+ *
+ * Phase 2 of the `provider-request-pipeline` OpenSpec change (design D3, task 4.3).
+ *
+ * Re-expresses the subscription auth used by `SubscriptionDispatcher` behind
+ * the unified `AuthSource` contract, delegating to the existing
+ * `AuthStrategy` so the OAuth refresh / token formatting logic is NOT
+ * rewritten:
+ *
+ *   - `applyHeaders` → `stripAuthHeaders(headers)` then
+ *     `authStrategy.applyHeaders(headers, { upstreamUrl, resolvedModel })`,
+ *     wrapped in the same best-effort try/catch as
+ *     `SubscriptionDispatcher.applyHeadersWithRetry` (a thrown
+ *     `applyHeaders` is logged + swallowed, NOT propagated — preserved
+ *     verbatim).
+ *   - `onUnauthorized` → `authStrategy.onUnauthorized()`.
+ *   - `resolveUpstreamUrl` → `profile.resolveUpstreamUrl?.(model)`.
+ *
+ * IMPORTANT (Phase 2 scope): this WRAPS the strategy + strip behavior but does
+ * NOT re-route `SubscriptionDispatcher` through it. The dispatcher's fragile
+ * 401-refresh + fallback loop is left UNCHANGED (task 4.5 deferred). This
+ * class is unit-tested in isolation only.
+ *
+ * @module pipeline/SubscriptionAuthSource
+ */
+
+/**
+ * Lightweight summary derived from the inbound request body — consumed by a
+ * profile's `modelMapper` (scenario routing). Structural mirror of
+ * `provider-proxy/types.ts`'s `SubscriptionRequestSummary`, declared here so
+ * `SubscriptionAuthProfile.modelMapper` is type-identical WITHOUT a circular
+ * import back into `provider-proxy/types` (which imports THIS module).
+ */
+interface SubscriptionRequestSummary {
+    messageCount: number;
+    estimatedInputTokens: number;
+    /**
+     * OPTIONAL bounded per-message match-text slice — kept structurally identical
+     * to the canonical declaration in `provider-proxy/types.ts` (the two are
+     * deliberate mirrors, not one shared import). Consumed only by the OpenCodeGo
+     * keyword matcher in `@omnicross/subscriptions`; core writes, never reads it.
+     */
+    matchText?: string[];
+}
+/**
+ * The subset of a `SubscriptionDispatchProfile` the subscription paths need.
+ * Kept structural (not the full profile type) so the wrapper does not pull in
+ * the whole registry surface. The full `SubscriptionDispatchProfile` (which IS
+ * what gets passed here) satisfies this shape; the optional `mode` + `modelMapper`
+ * are read by the built-in `/v1/messages` subscription path (RT2.1) to decide the
+ * verbatim-vs-transformer shape and to apply opencodego scenario routing.
+ */
+interface SubscriptionAuthProfile {
+    readonly authStrategy: AuthStrategy;
+    /** Per-model upstream URL resolver (transformer profiles). Optional for
+     *  pass-through profiles that hard-code their endpoint upstream. The OPTIONAL
+     *  2nd `config` arg (opencodego `baseUrl` override, D1) is additive — existing
+     *  one-arg callers compile unchanged; mirrors the full
+     *  `SubscriptionDispatchProfile.resolveUpstreamUrl` so the registry profile
+     *  stays assignable. */
+    readonly resolveUpstreamUrl?: (resolvedModel: string, config?: OpenCodeGoTokenConfig) => string;
+    /**
+     * Names of provider-level transformers (registered in `TransformerService`)
+     * to run on the subscription chain — re-encode Unified → the upstream's wire.
+     * The full `SubscriptionDispatchProfile` (which IS what gets passed here)
+     * carries these; exposing them on the narrow structural type lets the
+     * Responses ingress build the profile's REAL chain (cross-vendor route-to,
+     * task #29) instead of hard-coding `['openai-response']`. Absent/empty →
+     * the ingress falls back to its endpoint transformer (codex byte-identity).
+     */
+    readonly providerTransformerNames?: readonly string[];
+    /** Names of model-specific transformers — usually empty. See above. */
+    readonly modelTransformerNames?: readonly string[];
+    /**
+     * OPTIONAL shape-aware provider transformer-name resolver (opencodego zen).
+     * Type-identical to `SubscriptionDispatchProfile.resolveProviderTransformerNames`
+     * so the registry profile stays assignable. The built-in `/v1/messages`
+     * subscription path (Phase 3) consults it via
+     * `profile.resolveProviderTransformerNames?.(model, route.subscriptionConfig)`
+     * to pick the right zen chain per resolved shape. `config` is `unknown` (core
+     * opaque-config discipline — no `@omnicross/subscriptions` import). When ABSENT
+     * the path reads the static `providerTransformerNames` exactly as today (codex
+     * byte-identity).
+     */
+    readonly resolveProviderTransformerNames?: (model: string, config?: unknown) => readonly string[];
+    /**
+     * Pass-through (claude) vs transformer (codex / opencodego / gemini). The
+     * built-in `/v1/messages` subscription path (RT2.1) reads this for its
+     * core-local same-format signal (pass-through ⇒ always verbatim relay).
+     * Optional on the narrow type — partial profiles built by other route-minting
+     * sites may omit it.
+     */
+    readonly mode?: 'pass-through' | 'transformer';
+    /**
+     * Optional model placeholder rewriter — only set for OpenCodeGo. Type-identical
+     * to `SubscriptionDispatchProfile.modelMapper` so the registry profile stays
+     * assignable. Applied by the built-in `/v1/messages` subscription path BEFORE
+     * resolving the upstream URL (so scenario-based shape routing picks the right
+     * Anthropic-shape vs OpenAI-shape upstream).
+     */
+    readonly modelMapper?: (sdkModel: string, summary: SubscriptionRequestSummary, config: OpenCodeGoTokenConfig | undefined) => {
+        resolvedModel: string;
+        scenario: OpenCodeGoScenario;
+    };
+    /**
+     * Optional fallback resolver — only set for OpenCodeGo. Type-identical to
+     * `SubscriptionDispatchProfile.nextFallback` so the registry profile stays
+     * assignable. Read by the built-in `/v1/messages` fallback loop (D6b) to pick
+     * the next model after an unrecoverable upstream failure; returns `null` when
+     * exhausted (claude / codex / gemini omit it → no fallback attempted).
+     */
+    readonly nextFallback?: (scenario: OpenCodeGoScenario, attempted: readonly string[], config: OpenCodeGoTokenConfig | undefined) => OpenCodeGoModelEntry | null;
+    /**
+     * Optional circuit-breaker admission gate for the PRIMARY (mapped) model (D5
+     * primary-gating). Type-identical to `SubscriptionDispatchProfile.allowModel`.
+     * Only OpenCodeGo sets it; the core `/v1/messages` loop consults it for the
+     * primary before its first attempt and jumps to the first admitting
+     * `nextFallback` candidate when the primary's circuit is open. Absent ⇒ the
+     * primary is always admitted (claude / codex / gemini — no breaker).
+     */
+    readonly allowModel?: (modelId: string) => boolean;
+    /**
+     * Optional record-outcome callback (D5 record seam). Type-identical to
+     * `SubscriptionDispatchProfile.recordModelOutcome`. The core `/v1/messages`
+     * loop calls `profile.recordModelOutcome?.(model, ok)` THROUGH this optional
+     * field after each attempt, so `@omnicross/core` gains NO import of
+     * `@omnicross/subscriptions` (the cross-layer litmus stays 0 — exactly the
+     * `nextFallback` precedent). `ok: true` on `2xx`; `ok: false` on
+     * thrown/`5xx`/`429`; a non-429 `4xx` is NEUTRAL (the loop does NOT call it).
+     * Absent for claude / codex / gemini ⇒ no-op.
+     */
+    readonly recordModelOutcome?: (modelId: string, ok: boolean) => void;
+}
+/**
+ * Drop auth headers the transformer chain may have set so the `AuthStrategy`
+ * is the single source of truth for outbound authentication. Byte-identical
+ * to `SubscriptionDispatcher.stripAuthHeaders`.
+ */
+declare function stripAuthHeaders(headers: Record<string, string>): void;
+declare class SubscriptionAuthSource implements AuthSource {
+    private readonly profile;
+    constructor(profile: SubscriptionAuthProfile);
+    /**
+     * 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.
+     */
+    applyHeaders(headers: Record<string, string>, hints: AuthApplyHints): Promise<void>;
+    /** Delegate the 401-refresh decision to the bound strategy. */
+    onUnauthorized(): Promise<boolean>;
+    /** Resolve the upstream URL from the profile, when it provides one. */
+    resolveUpstreamUrl(model: string): string | undefined;
+}
+
+export { type SubscriptionAuthProfile, SubscriptionAuthSource, type SubscriptionRequestSummary, stripAuthHeaders };

package/dist/pipeline/SubscriptionAuthSource.d.ts

@@ -1,3 +1,165 @@
-import '@omnicross/contracts/subscription-types';
-export { S as SubscriptionAuthProfile, a as SubscriptionAuthSource, b as SubscriptionRequestSummary, s as stripAuthHeaders } from '../SubscriptionAuthSource-D89zmiSS.js';
-import './SubscriptionAuthStrategy.js';
+import { OpenCodeGoTokenConfig, OpenCodeGoScenario, OpenCodeGoModelEntry } from '@omnicross/contracts/subscription-types';
+import { AuthSource, AuthApplyHints } from './AuthSource.js';
+import { AuthStrategy } from './SubscriptionAuthStrategy.js';
+
+/**
+ * SubscriptionAuthSource — `AuthSource` wrapping a subscription `AuthStrategy`.
+ *
+ * Phase 2 of the `provider-request-pipeline` OpenSpec change (design D3, task 4.3).
+ *
+ * Re-expresses the subscription auth used by `SubscriptionDispatcher` behind
+ * the unified `AuthSource` contract, delegating to the existing
+ * `AuthStrategy` so the OAuth refresh / token formatting logic is NOT
+ * rewritten:
+ *
+ *   - `applyHeaders` → `stripAuthHeaders(headers)` then
+ *     `authStrategy.applyHeaders(headers, { upstreamUrl, resolvedModel })`,
+ *     wrapped in the same best-effort try/catch as
+ *     `SubscriptionDispatcher.applyHeadersWithRetry` (a thrown
+ *     `applyHeaders` is logged + swallowed, NOT propagated — preserved
+ *     verbatim).
+ *   - `onUnauthorized` → `authStrategy.onUnauthorized()`.
+ *   - `resolveUpstreamUrl` → `profile.resolveUpstreamUrl?.(model)`.
+ *
+ * IMPORTANT (Phase 2 scope): this WRAPS the strategy + strip behavior but does
+ * NOT re-route `SubscriptionDispatcher` through it. The dispatcher's fragile
+ * 401-refresh + fallback loop is left UNCHANGED (task 4.5 deferred). This
+ * class is unit-tested in isolation only.
+ *
+ * @module pipeline/SubscriptionAuthSource
+ */
+
+/**
+ * Lightweight summary derived from the inbound request body — consumed by a
+ * profile's `modelMapper` (scenario routing). Structural mirror of
+ * `provider-proxy/types.ts`'s `SubscriptionRequestSummary`, declared here so
+ * `SubscriptionAuthProfile.modelMapper` is type-identical WITHOUT a circular
+ * import back into `provider-proxy/types` (which imports THIS module).
+ */
+interface SubscriptionRequestSummary {
+    messageCount: number;
+    estimatedInputTokens: number;
+    /**
+     * OPTIONAL bounded per-message match-text slice — kept structurally identical
+     * to the canonical declaration in `provider-proxy/types.ts` (the two are
+     * deliberate mirrors, not one shared import). Consumed only by the OpenCodeGo
+     * keyword matcher in `@omnicross/subscriptions`; core writes, never reads it.
+     */
+    matchText?: string[];
+}
+/**
+ * The subset of a `SubscriptionDispatchProfile` the subscription paths need.
+ * Kept structural (not the full profile type) so the wrapper does not pull in
+ * the whole registry surface. The full `SubscriptionDispatchProfile` (which IS
+ * what gets passed here) satisfies this shape; the optional `mode` + `modelMapper`
+ * are read by the built-in `/v1/messages` subscription path (RT2.1) to decide the
+ * verbatim-vs-transformer shape and to apply opencodego scenario routing.
+ */
+interface SubscriptionAuthProfile {
+    readonly authStrategy: AuthStrategy;
+    /** Per-model upstream URL resolver (transformer profiles). Optional for
+     *  pass-through profiles that hard-code their endpoint upstream. The OPTIONAL
+     *  2nd `config` arg (opencodego `baseUrl` override, D1) is additive — existing
+     *  one-arg callers compile unchanged; mirrors the full
+     *  `SubscriptionDispatchProfile.resolveUpstreamUrl` so the registry profile
+     *  stays assignable. */
+    readonly resolveUpstreamUrl?: (resolvedModel: string, config?: OpenCodeGoTokenConfig) => string;
+    /**
+     * Names of provider-level transformers (registered in `TransformerService`)
+     * to run on the subscription chain — re-encode Unified → the upstream's wire.
+     * The full `SubscriptionDispatchProfile` (which IS what gets passed here)
+     * carries these; exposing them on the narrow structural type lets the
+     * Responses ingress build the profile's REAL chain (cross-vendor route-to,
+     * task #29) instead of hard-coding `['openai-response']`. Absent/empty →
+     * the ingress falls back to its endpoint transformer (codex byte-identity).
+     */
+    readonly providerTransformerNames?: readonly string[];
+    /** Names of model-specific transformers — usually empty. See above. */
+    readonly modelTransformerNames?: readonly string[];
+    /**
+     * OPTIONAL shape-aware provider transformer-name resolver (opencodego zen).
+     * Type-identical to `SubscriptionDispatchProfile.resolveProviderTransformerNames`
+     * so the registry profile stays assignable. The built-in `/v1/messages`
+     * subscription path (Phase 3) consults it via
+     * `profile.resolveProviderTransformerNames?.(model, route.subscriptionConfig)`
+     * to pick the right zen chain per resolved shape. `config` is `unknown` (core
+     * opaque-config discipline — no `@omnicross/subscriptions` import). When ABSENT
+     * the path reads the static `providerTransformerNames` exactly as today (codex
+     * byte-identity).
+     */
+    readonly resolveProviderTransformerNames?: (model: string, config?: unknown) => readonly string[];
+    /**
+     * Pass-through (claude) vs transformer (codex / opencodego / gemini). The
+     * built-in `/v1/messages` subscription path (RT2.1) reads this for its
+     * core-local same-format signal (pass-through ⇒ always verbatim relay).
+     * Optional on the narrow type — partial profiles built by other route-minting
+     * sites may omit it.
+     */
+    readonly mode?: 'pass-through' | 'transformer';
+    /**
+     * Optional model placeholder rewriter — only set for OpenCodeGo. Type-identical
+     * to `SubscriptionDispatchProfile.modelMapper` so the registry profile stays
+     * assignable. Applied by the built-in `/v1/messages` subscription path BEFORE
+     * resolving the upstream URL (so scenario-based shape routing picks the right
+     * Anthropic-shape vs OpenAI-shape upstream).
+     */
+    readonly modelMapper?: (sdkModel: string, summary: SubscriptionRequestSummary, config: OpenCodeGoTokenConfig | undefined) => {
+        resolvedModel: string;
+        scenario: OpenCodeGoScenario;
+    };
+    /**
+     * Optional fallback resolver — only set for OpenCodeGo. Type-identical to
+     * `SubscriptionDispatchProfile.nextFallback` so the registry profile stays
+     * assignable. Read by the built-in `/v1/messages` fallback loop (D6b) to pick
+     * the next model after an unrecoverable upstream failure; returns `null` when
+     * exhausted (claude / codex / gemini omit it → no fallback attempted).
+     */
+    readonly nextFallback?: (scenario: OpenCodeGoScenario, attempted: readonly string[], config: OpenCodeGoTokenConfig | undefined) => OpenCodeGoModelEntry | null;
+    /**
+     * Optional circuit-breaker admission gate for the PRIMARY (mapped) model (D5
+     * primary-gating). Type-identical to `SubscriptionDispatchProfile.allowModel`.
+     * Only OpenCodeGo sets it; the core `/v1/messages` loop consults it for the
+     * primary before its first attempt and jumps to the first admitting
+     * `nextFallback` candidate when the primary's circuit is open. Absent ⇒ the
+     * primary is always admitted (claude / codex / gemini — no breaker).
+     */
+    readonly allowModel?: (modelId: string) => boolean;
+    /**
+     * Optional record-outcome callback (D5 record seam). Type-identical to
+     * `SubscriptionDispatchProfile.recordModelOutcome`. The core `/v1/messages`
+     * loop calls `profile.recordModelOutcome?.(model, ok)` THROUGH this optional
+     * field after each attempt, so `@omnicross/core` gains NO import of
+     * `@omnicross/subscriptions` (the cross-layer litmus stays 0 — exactly the
+     * `nextFallback` precedent). `ok: true` on `2xx`; `ok: false` on
+     * thrown/`5xx`/`429`; a non-429 `4xx` is NEUTRAL (the loop does NOT call it).
+     * Absent for claude / codex / gemini ⇒ no-op.
+     */
+    readonly recordModelOutcome?: (modelId: string, ok: boolean) => void;
+}
+/**
+ * Drop auth headers the transformer chain may have set so the `AuthStrategy`
+ * is the single source of truth for outbound authentication. Byte-identical
+ * to `SubscriptionDispatcher.stripAuthHeaders`.
+ */
+declare function stripAuthHeaders(headers: Record<string, string>): void;
+declare class SubscriptionAuthSource implements AuthSource {
+    private readonly profile;
+    constructor(profile: SubscriptionAuthProfile);
+    /**
+     * 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.
+     */
+    applyHeaders(headers: Record<string, string>, hints: AuthApplyHints): Promise<void>;
+    /** Delegate the 401-refresh decision to the bound strategy. */
+    onUnauthorized(): Promise<boolean>;
+    /** Resolve the upstream URL from the profile, when it provides one. */
+    resolveUpstreamUrl(model: string): string | undefined;
+}
+
+export { type SubscriptionAuthProfile, SubscriptionAuthSource, type SubscriptionRequestSummary, stripAuthHeaders };

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-74TMJA7Z.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/executeProviderCall.cjs

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

package/dist/pipeline/executeProviderCall.d.cts

@@ -0,0 +1,149 @@
+import { TransformerChainExecutor, ChainExecutionOptions } from '../transformer/TransformerChainExecutor.cjs';
+import { UnifiedChatRequest, LLMProvider, ResolvedTransformerChain, Transformer, RequestConfig } from '../transformer/types.cjs';
+
+/**
+ * executeProviderCall — shared provider-request exchange core.
+ *
+ * Phase 1 of the `provider-request-pipeline` OpenSpec change (design D2/D4/D6).
+ *
+ * The three consumer paths (the wire-format proxy handler, the host engine
+ * adapter, TransformerHandler) each re-implemented the same middle:
+ *
+ *   executor.executeRequestChain(...) → resolve URL → assemble headers
+ *   → fetch → (optionally) executor.executeResponseChain(...)
+ *
+ * This module owns ONLY that common exchange. Every step that diverges
+ * between the three sites is injected via options so each call site keeps
+ * its CURRENT behavior verbatim:
+ *
+ *   - URL building       → `resolveUrl(config)`
+ *   - header assembly    → `buildHeaders(config)`
+ *   - post-transform body mutation → `prepareBody(requestBody, config)`
+ *   - fetch mechanism    → `fetchFn(url, headers, body)`
+ *   - endpoint transform → `endpointTransformer` (proxy = Anthropic; others omit)
+ *   - response chain     → `runResponseChain` flag + `responseChainRequest`
+ *
+ * IMPORTANT subtleties preserved verbatim:
+ *
+ *   1. The response chain's FIRST argument is the REQUEST body, NOT the
+ *      mutated `prepareBody` output. Each site passes a DIFFERENT variable
+ *      there today (proxy → post-transform `requestBody`; Adapter/Handler →
+ *      the pre-transform `unifiedRequest`), so the core does not hard-code
+ *      it — `responseChainRequest` is supplied by the caller when
+ *      `runResponseChain` is true.
+ *
+ *   2. The engine adapter and Handler check `response.ok` on the RAW fetch response
+ *      BEFORE running the response chain. Those sites therefore set
+ *      `runResponseChain: false` (the default) and run `executeResponseChain`
+ *      themselves at the call site after their `.ok` gate. The proxy uses
+ *      `fetchWithRetry` (no raw `.ok` gate between fetch and the response
+ *      chain) so it sets `runResponseChain: true` and lets the core run it.
+ *
+ * @module pipeline/executeProviderCall
+ */
+
+/**
+ * Inputs for {@link executeProviderCall}. Everything that differs between
+ * the three ingress adapters is injected here; the core owns only the
+ * fixed orchestration between `executeRequestChain` and the fetch.
+ */
+interface ProviderCallContext {
+    /** Shared (stateless) transformer-chain executor. */
+    executor: TransformerChainExecutor;
+    /**
+     * The request to send into the request chain. For the proxy this is the
+     * raw Anthropic wire body (decoded by `endpointTransformer`); for the
+     * unified ingresses this is a `UnifiedChatRequest`.
+     */
+    request: UnifiedChatRequest | Record<string, unknown>;
+    /** Provider config in transformer runtime shape. */
+    provider: LLMProvider;
+    /** Resolved transformer chain (provider + model transformers). */
+    chain: ResolvedTransformerChain;
+    /**
+     * Endpoint transformer — present only for wire-format ingress (the proxy
+     * passes `AnthropicTransformer`). Omitted for unified ingresses.
+     */
+    endpointTransformer?: Transformer;
+    /**
+     * 1M-context opt-in, threaded straight through to
+     * `executeRequestChain`'s `extendedContext` option, exactly as the call
+     * sites pass it today.
+     */
+    extendedContext?: ChainExecutionOptions['extendedContext'];
+    /**
+     * Build the target URL from the post-request-chain `config`. Each site
+     * supplies its CURRENT URL logic:
+     *   - proxy:        always `buildProviderApiUrl(...)` (ignores config.url)
+     *   - Adapter/Handler: `config.url instanceof URL ? config.url.toString() : buildProviderApiUrl(...)`
+     */
+    resolveUrl: (config: RequestConfig) => string;
+    /**
+     * Assemble the outbound headers from the post-request-chain `config`.
+     * Each site supplies its CURRENT header logic:
+     *   - proxy:        getProviderHeaders + config.headers EXCLUDING AUTH_HEADER_KEYS
+     *   - Adapter/Handler: getProviderHeaders + config.headers + OpenRouter app headers
+     */
+    buildHeaders: (config: RequestConfig) => Record<string, string>;
+    /**
+     * Post-transform / pre-fetch body mutation seam (design D4). Applied to
+     * the request-chain output `requestBody` immediately before fetch. The
+     * default is identity. NOTE: the value returned here becomes the fetched
+     * body ONLY — the response chain still receives the pre-mutation request
+     * (see `responseChainRequest`).
+     */
+    prepareBody?: (requestBody: unknown, config: RequestConfig) => unknown | Promise<unknown>;
+    /**
+     * The fetch mechanism. Each site supplies its CURRENT mechanism:
+     *   - proxy:        `this.deps.errors.fetchWithRetry(url, headers, body, model)`
+     *   - Adapter:      `fetch(url, { ..., signal: AbortSignal.timeout(...) })`
+     *   - Handler:      `fetch(url, { ... })`
+     */
+    fetchFn: (url: string, headers: Record<string, string>, body: unknown) => Promise<Response>;
+    /**
+     * When `true`, the core runs `executeResponseChain` on the fetched
+     * response and returns the TRANSFORMED response. When `false` (default),
+     * the core returns the RAW fetched response and the caller runs the
+     * response chain itself — this preserves call sites that gate on
+     * `response.ok` BEFORE the response chain (Adapter / Handler).
+     */
+    runResponseChain?: boolean;
+    /**
+     * The first argument passed to `executeResponseChain` when
+     * `runResponseChain` is true. This is REQUIRED in that mode because the
+     * sites diverge on which variable they pass (proxy → post-transform
+     * `requestBody`; the unified ingresses → the pre-transform request). The
+     * core never assumes it equals `prepareBody`'s output.
+     */
+    responseChainRequest?: UnifiedChatRequest;
+}
+/**
+ * Result of the common exchange.
+ *
+ * `response` is the TRANSFORMED response when `runResponseChain` was true,
+ * otherwise the RAW fetched response. The remaining fields expose the
+ * request-chain outputs so callers can run the response chain themselves
+ * (when `runResponseChain` is false) with the exact variables they used
+ * before, and so the wire-capture / logging hooks keep their inputs.
+ */
+interface ProviderCallResult {
+    /** Transformed response (runResponseChain=true) or raw response (false). */
+    response: Response;
+    /** Request-chain output body (pre-`prepareBody`). */
+    requestBody: unknown;
+    /** Final body actually sent to `fetchFn` (post-`prepareBody`). */
+    finalBody: unknown;
+    /** Request-chain output config (headers/url/etc.). */
+    config: RequestConfig;
+    /** The resolved target URL. */
+    url: string;
+    /** The assembled outbound headers. */
+    headers: Record<string, string>;
+}
+/**
+ * Run the common provider-request exchange. See the module + option JSDoc
+ * for the precise per-site contract this preserves.
+ */
+declare function executeProviderCall(ctx: ProviderCallContext): Promise<ProviderCallResult>;
+
+export { type ProviderCallContext, type ProviderCallResult, executeProviderCall };