@omnicross/core 0.1.0

package/dist/transformer/TransformerChainExecutor.cjs

@@ -0,0 +1,321 @@
+"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/transformer/TransformerChainExecutor.ts
+var TransformerChainExecutor_exports = {};
+__export(TransformerChainExecutor_exports, {
+  TransformerChainExecutor: () => TransformerChainExecutor
+});
+module.exports = __toCommonJS(TransformerChainExecutor_exports);
+
+// src/transformer/anthropicBetaInject.ts
+var import_extended_context = require("@omnicross/contracts/extended-context");
+var EXTENDED_CONTEXT_BETA = "context-1m-2025-08-07";
+var ANTHROPIC_BETA_HEADER = "anthropic-beta";
+function injectExtendedContextBeta(headers, model, useExtendedContext) {
+  if (!useExtendedContext) return;
+  if (!(0, import_extended_context.isExtendedContextCapable)(model)) return;
+  let existingValue = "";
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === ANTHROPIC_BETA_HEADER) {
+      const v = headers[key];
+      if (typeof v === "string") existingValue = v;
+      if (key !== ANTHROPIC_BETA_HEADER) delete headers[key];
+    }
+  }
+  const parts = existingValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (!parts.includes(EXTENDED_CONTEXT_BETA)) {
+    parts.push(EXTENDED_CONTEXT_BETA);
+  }
+  headers[ANTHROPIC_BETA_HEADER] = parts.join(",");
+}
+
+// src/transformer/TransformerChainExecutor.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[ChainExecutor] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[ChainExecutor] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[ChainExecutor] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[ChainExecutor] ${msg}`, ...args)
+};
+var TransformerChainExecutor = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? defaultLogger;
+  }
+  /**
+   * Execute the request transformation chain
+   *
+   * @param request - Original request body
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed request result
+   */
+  async executeRequestChain(request, provider, chain, options = {}) {
+    const { endpointTransformer, headers, extendedContext } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let requestBody = request;
+    let config = {};
+    let bypass = false;
+    bypass = this.shouldBypassTransformers(
+      chain,
+      endpointTransformer,
+      requestBody
+    );
+    if (bypass) {
+      if (headers) {
+        const cleanHeaders = this.cleanHeaders(headers);
+        config.headers = cleanHeaders;
+      }
+      this.logger.debug("Bypass mode enabled - skipping transformations");
+    }
+    if (!bypass && endpointTransformer?.transformRequestOut) {
+      this.logger.debug("Executing transformRequestOut");
+      try {
+        const transformOut = await endpointTransformer.transformRequestOut(requestBody, context);
+        if (transformOut && typeof transformOut === "object") {
+          if ("body" in transformOut) {
+            requestBody = transformOut.body;
+            config = transformOut.config ?? {};
+          } else {
+            requestBody = transformOut;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    if (!bypass && chain.providerTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
+      for (const transformer of chain.providerTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const transformIn = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            if (transformIn && typeof transformIn === "object") {
+              if ("body" in transformIn) {
+                requestBody = transformIn.body;
+                config = { ...config, ...transformIn.config };
+              } else {
+                requestBody = transformIn;
+              }
+            }
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (!bypass && chain.modelTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.modelTransformers.length} model transformers`);
+      for (const transformer of chain.modelTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const result = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            requestBody = result;
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (extendedContext?.enabled) {
+      if (!config.headers || typeof config.headers !== "object") {
+        config.headers = {};
+      }
+      injectExtendedContextBeta(
+        config.headers,
+        extendedContext.model,
+        true
+      );
+    }
+    return { requestBody, config, bypass };
+  }
+  /**
+   * Execute the response transformation chain
+   *
+   * @param request - Original request (for context)
+   * @param response - Response from provider
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed response
+   */
+  async executeResponseChain(request, response, provider, chain, options = {}) {
+    const { endpointTransformer } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let finalResponse = response;
+    const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);
+    if (bypass) {
+      this.logger.debug("Bypass mode - skipping response transformations");
+      return finalResponse;
+    }
+    if (chain.modelTransformers.length > 0) {
+      const reversedModelTransformers = [...chain.modelTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedModelTransformers.length} model response transformers (reversed)`
+      );
+      for (const transformer of reversedModelTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (chain.providerTransformers.length > 0) {
+      const reversedProviderTransformers = [...chain.providerTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedProviderTransformers.length} provider response transformers (reversed)`
+      );
+      for (const transformer of reversedProviderTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (endpointTransformer?.transformResponseIn) {
+      this.logger.debug("Executing transformResponseIn");
+      try {
+        finalResponse = await endpointTransformer.transformResponseIn(finalResponse, context);
+      } catch (error) {
+        this.logger.error(`transformResponseIn error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return finalResponse;
+  }
+  /**
+   * Execute authentication handler if available
+   *
+   * @param request - Request body
+   * @param provider - LLM provider
+   * @param endpointTransformer - Endpoint transformer with auth handler
+   * @param context - Transformer context
+   * @returns Auth result with potentially modified request and config
+   */
+  async executeAuth(request, provider, endpointTransformer, context) {
+    let requestBody = request;
+    let config = {};
+    if (endpointTransformer?.auth) {
+      this.logger.debug("Executing auth handler");
+      try {
+        const auth = await endpointTransformer.auth(requestBody, provider, context);
+        if (auth && typeof auth === "object") {
+          if ("body" in auth) {
+            requestBody = auth.body;
+            const authConfig = auth.config;
+            if (authConfig) {
+              const headers = { ...config.headers ?? {}, ...authConfig.headers ?? {} };
+              delete headers["host"];
+              config = { ...config, ...authConfig, headers };
+            }
+          } else {
+            requestBody = auth;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`Auth handler error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return { requestBody, config };
+  }
+  /**
+   * Check if transformers should be bypassed (optimization)
+   *
+   * Bypass is enabled when:
+   * - Provider has only one transformer that matches the endpoint transformer
+   * - Model has no specific transformers or only the same endpoint transformer
+   */
+  shouldBypassTransformers(chain, endpointTransformer, _request) {
+    if (!endpointTransformer?.name) {
+      return false;
+    }
+    const providerHasOnlyEndpoint = chain.providerTransformers.length === 1 && chain.providerTransformers[0]?.name === endpointTransformer.name;
+    const modelHasNoTransformers = chain.modelTransformers.length === 0;
+    const modelHasOnlyEndpoint = chain.modelTransformers.length === 1 && chain.modelTransformers[0]?.name === endpointTransformer.name;
+    return providerHasOnlyEndpoint && (modelHasNoTransformers || modelHasOnlyEndpoint);
+  }
+  /**
+   * Clean headers for pass-through
+   */
+  cleanHeaders(headers) {
+    const result = {};
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      });
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get error message from unknown error
+   */
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformerChainExecutor
+});

package/dist/transformer/TransformerChainExecutor.d.cts

@@ -0,0 +1,104 @@
+import { Transformer, TransformerLogger, LLMProvider, ResolvedTransformerChain, TransformRequestResult, UnifiedChatRequest, TransformerContext, RequestConfig } from './types.cjs';
+
+/**
+ * TransformerChainExecutor - Executes transformer chains for requests and responses
+ *
+ * Implements the transformer pipeline:
+ * Request: transformRequestOut 鈫?Provider transformers 鈫?Model transformers 鈫?HTTP
+ * Response: Model transformers (reverse) 鈫?Provider transformers (reverse) 鈫?transformResponseIn
+ *
+ * @module transformer/TransformerChainExecutor
+ */
+
+/**
+ * Options for chain execution
+ */
+interface ChainExecutionOptions {
+    /** The primary/endpoint transformer */
+    endpointTransformer?: Transformer;
+    /** Request headers */
+    headers?: Record<string, string> | Headers;
+    /** Logger instance */
+    logger?: TransformerLogger;
+    /**
+     * 1M-context opt-in. When `enabled` is true and the post-chain request body
+     * looks Anthropic-shaped (has a `messages` array), the executor injects
+     * `'context-1m-2025-08-07'` into `body.anthropic_beta`. Capability gating
+     * (model id allowlist) lives inside `injectExtendedContextBeta` itself.
+     */
+    extendedContext?: {
+        enabled: boolean;
+        model: string;
+    };
+}
+/**
+ * TransformerChainExecutor handles the execution of transformer chains.
+ *
+ * The execution flow follows the llms project pattern:
+ *
+ * Request Phase:
+ * 1. transformRequestOut (endpoint transformer) - Convert to unified format
+ * 2. Provider transformers [].transformRequestIn (forward order)
+ * 3. Model transformers [].transformRequestIn (forward order)
+ *
+ * Response Phase:
+ * 4. Model transformers [].transformResponseOut (reverse order)
+ * 5. Provider transformers [].transformResponseOut (reverse order)
+ * 6. transformResponseIn (endpoint transformer) - Convert to client format
+ */
+declare class TransformerChainExecutor {
+    private logger;
+    constructor(logger?: TransformerLogger);
+    /**
+     * Execute the request transformation chain
+     *
+     * @param request - Original request body
+     * @param provider - LLM provider configuration
+     * @param chain - Resolved transformer chain
+     * @param options - Execution options
+     * @returns Transformed request result
+     */
+    executeRequestChain(request: unknown, provider: LLMProvider, chain: ResolvedTransformerChain, options?: ChainExecutionOptions): Promise<TransformRequestResult>;
+    /**
+     * Execute the response transformation chain
+     *
+     * @param request - Original request (for context)
+     * @param response - Response from provider
+     * @param provider - LLM provider configuration
+     * @param chain - Resolved transformer chain
+     * @param options - Execution options
+     * @returns Transformed response
+     */
+    executeResponseChain(request: UnifiedChatRequest, response: Response, provider: LLMProvider, chain: ResolvedTransformerChain, options?: ChainExecutionOptions): Promise<Response>;
+    /**
+     * Execute authentication handler if available
+     *
+     * @param request - Request body
+     * @param provider - LLM provider
+     * @param endpointTransformer - Endpoint transformer with auth handler
+     * @param context - Transformer context
+     * @returns Auth result with potentially modified request and config
+     */
+    executeAuth(request: unknown, provider: LLMProvider, endpointTransformer: Transformer | undefined, context: TransformerContext): Promise<{
+        requestBody: unknown;
+        config: RequestConfig;
+    }>;
+    /**
+     * Check if transformers should be bypassed (optimization)
+     *
+     * Bypass is enabled when:
+     * - Provider has only one transformer that matches the endpoint transformer
+     * - Model has no specific transformers or only the same endpoint transformer
+     */
+    private shouldBypassTransformers;
+    /**
+     * Clean headers for pass-through
+     */
+    private cleanHeaders;
+    /**
+     * Get error message from unknown error
+     */
+    private getErrorMessage;
+}
+
+export { type ChainExecutionOptions, TransformerChainExecutor };

package/dist/transformer/TransformerChainExecutor.d.ts

@@ -0,0 +1,104 @@
+import { Transformer, TransformerLogger, LLMProvider, ResolvedTransformerChain, TransformRequestResult, UnifiedChatRequest, TransformerContext, RequestConfig } from './types.js';
+
+/**
+ * TransformerChainExecutor - Executes transformer chains for requests and responses
+ *
+ * Implements the transformer pipeline:
+ * Request: transformRequestOut 鈫?Provider transformers 鈫?Model transformers 鈫?HTTP
+ * Response: Model transformers (reverse) 鈫?Provider transformers (reverse) 鈫?transformResponseIn
+ *
+ * @module transformer/TransformerChainExecutor
+ */
+
+/**
+ * Options for chain execution
+ */
+interface ChainExecutionOptions {
+    /** The primary/endpoint transformer */
+    endpointTransformer?: Transformer;
+    /** Request headers */
+    headers?: Record<string, string> | Headers;
+    /** Logger instance */
+    logger?: TransformerLogger;
+    /**
+     * 1M-context opt-in. When `enabled` is true and the post-chain request body
+     * looks Anthropic-shaped (has a `messages` array), the executor injects
+     * `'context-1m-2025-08-07'` into `body.anthropic_beta`. Capability gating
+     * (model id allowlist) lives inside `injectExtendedContextBeta` itself.
+     */
+    extendedContext?: {
+        enabled: boolean;
+        model: string;
+    };
+}
+/**
+ * TransformerChainExecutor handles the execution of transformer chains.
+ *
+ * The execution flow follows the llms project pattern:
+ *
+ * Request Phase:
+ * 1. transformRequestOut (endpoint transformer) - Convert to unified format
+ * 2. Provider transformers [].transformRequestIn (forward order)
+ * 3. Model transformers [].transformRequestIn (forward order)
+ *
+ * Response Phase:
+ * 4. Model transformers [].transformResponseOut (reverse order)
+ * 5. Provider transformers [].transformResponseOut (reverse order)
+ * 6. transformResponseIn (endpoint transformer) - Convert to client format
+ */
+declare class TransformerChainExecutor {
+    private logger;
+    constructor(logger?: TransformerLogger);
+    /**
+     * Execute the request transformation chain
+     *
+     * @param request - Original request body
+     * @param provider - LLM provider configuration
+     * @param chain - Resolved transformer chain
+     * @param options - Execution options
+     * @returns Transformed request result
+     */
+    executeRequestChain(request: unknown, provider: LLMProvider, chain: ResolvedTransformerChain, options?: ChainExecutionOptions): Promise<TransformRequestResult>;
+    /**
+     * Execute the response transformation chain
+     *
+     * @param request - Original request (for context)
+     * @param response - Response from provider
+     * @param provider - LLM provider configuration
+     * @param chain - Resolved transformer chain
+     * @param options - Execution options
+     * @returns Transformed response
+     */
+    executeResponseChain(request: UnifiedChatRequest, response: Response, provider: LLMProvider, chain: ResolvedTransformerChain, options?: ChainExecutionOptions): Promise<Response>;
+    /**
+     * Execute authentication handler if available
+     *
+     * @param request - Request body
+     * @param provider - LLM provider
+     * @param endpointTransformer - Endpoint transformer with auth handler
+     * @param context - Transformer context
+     * @returns Auth result with potentially modified request and config
+     */
+    executeAuth(request: unknown, provider: LLMProvider, endpointTransformer: Transformer | undefined, context: TransformerContext): Promise<{
+        requestBody: unknown;
+        config: RequestConfig;
+    }>;
+    /**
+     * Check if transformers should be bypassed (optimization)
+     *
+     * Bypass is enabled when:
+     * - Provider has only one transformer that matches the endpoint transformer
+     * - Model has no specific transformers or only the same endpoint transformer
+     */
+    private shouldBypassTransformers;
+    /**
+     * Clean headers for pass-through
+     */
+    private cleanHeaders;
+    /**
+     * Get error message from unknown error
+     */
+    private getErrorMessage;
+}
+
+export { type ChainExecutionOptions, TransformerChainExecutor };