@omnicross/core 0.1.0 → 0.1.1

package/dist/pipeline/executeProviderCall.cjs

@@ -0,0 +1,70 @@
+"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);
+
+// 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
+});

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 };

package/dist/pipeline/executeProviderCall.d.ts

@@ -0,0 +1,149 @@
+import { TransformerChainExecutor, ChainExecutionOptions } from '../transformer/TransformerChainExecutor.js';
+import { UnifiedChatRequest, LLMProvider, ResolvedTransformerChain, Transformer, RequestConfig } from '../transformer/types.js';
+
+/**
+ * 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 };

package/dist/pipeline/executeProviderCall.js

@@ -0,0 +1,45 @@
+// 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 };
+}
+export {
+  executeProviderCall
+};

package/dist/pipeline/resolveProviderChain.cjs

@@ -0,0 +1,47 @@
+"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);
+
+// 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
+});

package/dist/pipeline/resolveProviderChain.d.cts

@@ -0,0 +1,58 @@
+import { ProviderConfigSource } from '../ports/provider-config-source.cjs';
+import { Transformer } from '../transformer/types.cjs';
+import '@omnicross/contracts/llm-config';
+import '../transformer/TransformerService.cjs';
+
+/**
+ * resolveProviderChain — shared transformer-chain resolution helper.
+ *
+ * Phase 0 of the `provider-request-pipeline` OpenSpec change.
+ * All three consumer paths (TransformerHandler, the host engine adapter,
+ * and the wire-format proxy handler) previously duplicated the same
+ * resolveTransformerChain + getMainTransformer + shallow-copy + unshift
+ * block verbatim. This module extracts that single shared helper so the
+ * logic lives in exactly one place.
+ *
+ * IMPORTANT: body mutations that are proxy-specific (ReasoningTransformer
+ * auto-inject, thinkingLevel body-inject) are NOT part of this helper —
+ * they remain at each call site as before.
+ *
+ * @module pipeline/resolveProviderChain
+ */
+
+/** The resolved chain returned by each consumer. */
+interface ResolvedProviderChain {
+    chain: {
+        providerTransformers: Transformer[];
+        modelTransformers: Transformer[];
+    };
+    /**
+     * The main transformer resolved for this provider, or `null` when none
+     * is configured. Callers that need the transformer name (e.g. to pass
+     * into `getProviderCacheCaps` as `mainTransformerName`) can read
+     * `mainTransformer?.name` from this field.
+     */
+    mainTransformer: Transformer | null;
+    /**
+     * `true` when there is at least one transformer in either array — used
+     * by callers to gate the transformer-chain path vs the direct-API
+     * fallback.
+     */
+    hasTransformers: boolean;
+}
+/**
+ * Resolve the full transformer chain for a provider + model combination.
+ *
+ * Semantics (identical to all three former inline copies):
+ * 1. Call `llmConfig.resolveTransformerChain(providerId, model)` to get the
+ *    cached chain.
+ * 2. Call `llmConfig.getMainTransformer(providerId)` to get the main
+ *    transformer (e.g. GeminiTransformer for Google providers).
+ * 3. Shallow-copy both arrays so the cached reference is not mutated.
+ * 4. `unshift` the main transformer into `providerTransformers` unless a
+ *    transformer with the same `.name` is already present.
+ * 5. Compute `hasTransformers`.
+ */
+declare function resolveProviderChain(llmConfig: ProviderConfigSource, providerId: string, model: string): Promise<ResolvedProviderChain>;
+
+export { type ResolvedProviderChain, resolveProviderChain };

package/dist/pipeline/resolveProviderChain.d.ts

@@ -0,0 +1,58 @@
+import { ProviderConfigSource } from '../ports/provider-config-source.js';
+import { Transformer } from '../transformer/types.js';
+import '@omnicross/contracts/llm-config';
+import '../transformer/TransformerService.js';
+
+/**
+ * resolveProviderChain — shared transformer-chain resolution helper.
+ *
+ * Phase 0 of the `provider-request-pipeline` OpenSpec change.
+ * All three consumer paths (TransformerHandler, the host engine adapter,
+ * and the wire-format proxy handler) previously duplicated the same
+ * resolveTransformerChain + getMainTransformer + shallow-copy + unshift
+ * block verbatim. This module extracts that single shared helper so the
+ * logic lives in exactly one place.
+ *
+ * IMPORTANT: body mutations that are proxy-specific (ReasoningTransformer
+ * auto-inject, thinkingLevel body-inject) are NOT part of this helper —
+ * they remain at each call site as before.
+ *
+ * @module pipeline/resolveProviderChain
+ */
+
+/** The resolved chain returned by each consumer. */
+interface ResolvedProviderChain {
+    chain: {
+        providerTransformers: Transformer[];
+        modelTransformers: Transformer[];
+    };
+    /**
+     * The main transformer resolved for this provider, or `null` when none
+     * is configured. Callers that need the transformer name (e.g. to pass
+     * into `getProviderCacheCaps` as `mainTransformerName`) can read
+     * `mainTransformer?.name` from this field.
+     */
+    mainTransformer: Transformer | null;
+    /**
+     * `true` when there is at least one transformer in either array — used
+     * by callers to gate the transformer-chain path vs the direct-API
+     * fallback.
+     */
+    hasTransformers: boolean;
+}
+/**
+ * Resolve the full transformer chain for a provider + model combination.
+ *
+ * Semantics (identical to all three former inline copies):
+ * 1. Call `llmConfig.resolveTransformerChain(providerId, model)` to get the
+ *    cached chain.
+ * 2. Call `llmConfig.getMainTransformer(providerId)` to get the main
+ *    transformer (e.g. GeminiTransformer for Google providers).
+ * 3. Shallow-copy both arrays so the cached reference is not mutated.
+ * 4. `unshift` the main transformer into `providerTransformers` unless a
+ *    transformer with the same `.name` is already present.
+ * 5. Compute `hasTransformers`.
+ */
+declare function resolveProviderChain(llmConfig: ProviderConfigSource, providerId: string, model: string): Promise<ResolvedProviderChain>;
+
+export { type ResolvedProviderChain, resolveProviderChain };

package/dist/pipeline/resolveProviderChain.js

@@ -0,0 +1,22 @@
+// src/pipeline/resolveProviderChain.ts
+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 };
+}
+export {
+  resolveProviderChain
+};

package/dist/pipeline/resolveSubscriptionChain.cjs

@@ -0,0 +1,68 @@
+"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);
+
+// src/pipeline/resolveSubscriptionChain.ts
+var resolveSubscriptionChain_exports = {};
+__export(resolveSubscriptionChain_exports, {
+  resolveSubscriptionChain: () => resolveSubscriptionChain
+});
+module.exports = __toCommonJS(resolveSubscriptionChain_exports);
+function resolveOne(transformerService, name) {
+  const t = transformerService.getTransformer(name);
+  if (!t) return null;
+  return typeof t === "function" ? new t() : t;
+}
+function resolveSubscriptionChain(profile, transformerService, fallbackEndpoint, overrideNames) {
+  const providerNames = overrideNames ?? profile.providerTransformerNames ?? [];
+  const modelNames = profile.modelTransformerNames ?? [];
+  if (providerNames.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers: [] };
+  }
+  if (!transformerService) {
+    throw new Error(
+      "[resolveSubscriptionChain] profile declares providerTransformerNames but no TransformerService is wired"
+    );
+  }
+  const providerTransformers = [];
+  for (const name of providerNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Transformer not registered: ${name}`);
+      continue;
+    }
+    providerTransformers.push(instance);
+  }
+  const modelTransformers = [];
+  for (const name of modelNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Model transformer not registered: ${name}`);
+      continue;
+    }
+    modelTransformers.push(instance);
+  }
+  if (providerTransformers.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers };
+  }
+  return { providerTransformers, modelTransformers };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveSubscriptionChain
+});