@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-3OPYJG76.cjs

@@ -0,0 +1,266 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/transformer/TransformerService.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[TransformerService] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[TransformerService] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[TransformerService] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[TransformerService] ${msg}`, ...args)
+};
+var TransformerService = (_class = class {
+  __init() {this.transformers = /* @__PURE__ */ new Map()}
+  
+  // Performance optimization: Cache instantiated transformers
+  __init2() {this.instanceCache = /* @__PURE__ */ new Map()}
+  // Performance optimization: Cache endpoint transformer results
+  __init3() {this.endpointTransformersCache = null}
+  __init4() {this.noEndpointTransformersCache = null}
+  constructor(logger) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.logger = _nullishCoalesce(logger, () => ( defaultLogger));
+  }
+  /**
+   * Clear instance caches
+   */
+  clearInstanceCache() {
+    this.instanceCache.clear();
+    this.endpointTransformersCache = null;
+    this.noEndpointTransformersCache = null;
+  }
+  /**
+   * Get cache statistics for diagnostics
+   */
+  getCacheStats() {
+    return {
+      instanceCacheSize: this.instanceCache.size,
+      hasEndpointCache: this.endpointTransformersCache !== null
+    };
+  }
+  /**
+   * Register a transformer by name
+   * @param name - Unique transformer name
+   * @param transformer - Transformer instance or constructor
+   */
+  registerTransformer(name, transformer) {
+    this.transformers.set(name, transformer);
+    this.clearInstanceCache();
+    const endpoint = "endPoint" in transformer ? transformer.endPoint : "prototype" in transformer && _optionalChain([transformer, 'access', _ => _.prototype, 'optionalAccess', _2 => _2.endPoint]) ? transformer.prototype.endPoint : void 0;
+    this.logger.info(
+      `Registered transformer: ${name}${endpoint ? ` (endpoint: ${endpoint})` : " (no endpoint)"}`
+    );
+  }
+  /**
+   * Get a transformer by name
+   * @param name - Transformer name
+   * @returns Transformer instance/constructor or undefined
+   */
+  getTransformer(name) {
+    return this.transformers.get(name);
+  }
+  /**
+   * Get all registered transformers
+   * @returns Map of all transformers
+   */
+  getAllTransformers() {
+    return new Map(this.transformers);
+  }
+  /**
+   * Get transformers that have an endpoint defined
+   * Uses cache to avoid redundant traversal
+   * @returns Array of transformers with endpoints
+   */
+  getTransformersWithEndpoint() {
+    if (this.endpointTransformersCache) {
+      return this.endpointTransformersCache;
+    }
+    const result = [];
+    this.transformers.forEach((transformer, name) => {
+      const instance = this.instantiateIfNeeded(transformer);
+      if (_optionalChain([instance, 'optionalAccess', _3 => _3.endPoint])) {
+        result.push({ name, transformer: instance });
+      }
+    });
+    this.endpointTransformersCache = result;
+    return result;
+  }
+  /**
+   * Get transformers without endpoints
+   * Uses cache to avoid redundant traversal
+   * @returns Array of transformers without endpoints
+   */
+  getTransformersWithoutEndpoint() {
+    if (this.noEndpointTransformersCache) {
+      return this.noEndpointTransformersCache;
+    }
+    const result = [];
+    this.transformers.forEach((transformer, name) => {
+      const instance = this.instantiateIfNeeded(transformer);
+      if (instance && !instance.endPoint) {
+        result.push({ name, transformer: instance });
+      }
+    });
+    this.noEndpointTransformersCache = result;
+    return result;
+  }
+  /**
+   * Remove a transformer by name
+   * @param name - Transformer name
+   * @returns true if removed, false if not found
+   */
+  removeTransformer(name) {
+    const removed = this.transformers.delete(name);
+    if (removed) {
+      this.clearInstanceCache();
+    }
+    return removed;
+  }
+  /**
+   * Check if a transformer is registered
+   * @param name - Transformer name
+   * @returns true if registered
+   */
+  hasTransformer(name) {
+    return this.transformers.has(name);
+  }
+  /**
+   * Initialize the service with default transformers
+   * @param defaultTransformers - Map or object of default transformers
+   */
+  async initialize(defaultTransformers) {
+    try {
+      if (defaultTransformers) {
+        await this.registerDefaultTransformers(defaultTransformers);
+      }
+      this.logger.info(
+        `TransformerService initialized with ${this.transformers.size} transformers`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`TransformerService init error: ${errorMessage}`);
+      throw error;
+    }
+  }
+  /**
+   * Register default transformers from a map
+   * @param transformers - Map of transformer name to transformer
+   */
+  async registerDefaultTransformers(transformers) {
+    for (const [key, TransformerClass] of Object.entries(transformers)) {
+      try {
+        if (this.isTransformerConstructor(TransformerClass)) {
+          const staticName = _nullishCoalesce(TransformerClass.TransformerName, () => ( key));
+          this.registerTransformer(staticName, TransformerClass);
+        } else {
+          const name = _nullishCoalesce(TransformerClass.name, () => ( key));
+          TransformerClass.logger = this.logger;
+          this.registerTransformer(name, TransformerClass);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Failed to register transformer ${key}: ${errorMessage}`);
+      }
+    }
+  }
+  /**
+   * Resolve a transformer chain configuration to actual transformer instances
+   * @param chainConfig - Transformer chain configuration
+   * @param modelName - Model name for model-specific transformers
+   * @returns Resolved transformer chain with instances
+   */
+  resolveTransformerChain(chainConfig, modelName) {
+    const result = {
+      providerTransformers: [],
+      modelTransformers: []
+    };
+    if (!chainConfig) {
+      return result;
+    }
+    if (chainConfig.use) {
+      result.providerTransformers = this.resolveTransformerReferences(chainConfig.use);
+    }
+    if (modelName && chainConfig[modelName]) {
+      const modelConfig = chainConfig[modelName];
+      if (Array.isArray(modelConfig)) {
+        result.modelTransformers = this.resolveTransformerReferences(modelConfig);
+      } else if (modelConfig && typeof modelConfig === "object" && "use" in modelConfig) {
+        result.modelTransformers = this.resolveTransformerReferences(_nullishCoalesce(modelConfig.use, () => ( [])));
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve an array of transformer references to instances
+   * @param refs - Array of transformer references
+   * @returns Array of transformer instances
+   */
+  resolveTransformerReferences(refs) {
+    const instances = [];
+    for (const ref of refs) {
+      const [name, options] = Array.isArray(ref) ? ref : [ref, void 0];
+      const transformer = this.getTransformer(name);
+      if (!transformer) {
+        this.logger.warn(`Transformer not found: ${name}`);
+        continue;
+      }
+      const instance = this.instantiateIfNeeded(transformer, options);
+      if (instance) {
+        instance.logger = this.logger;
+        instances.push(instance);
+      }
+    }
+    return instances;
+  }
+  /**
+   * Instantiate a transformer if it's a constructor
+   * Uses instance cache to avoid redundant instantiation
+   *
+   * @param transformer - Transformer instance or constructor
+   * @param options - Options to pass to constructor
+   * @returns Transformer instance
+   */
+  instantiateIfNeeded(transformer, options) {
+    if (!this.isTransformerConstructor(transformer)) {
+      return transformer;
+    }
+    const constructorName = transformer.TransformerName || transformer.name || "anonymous";
+    const optionsHash = options ? JSON.stringify(options) : "";
+    const cacheKey = `${constructorName}:${optionsHash}`;
+    if (this.instanceCache.has(cacheKey)) {
+      return this.instanceCache.get(cacheKey);
+    }
+    try {
+      const instance = new transformer(options);
+      instance.logger = this.logger;
+      this.instanceCache.set(cacheKey, instance);
+      return instance;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to instantiate transformer: ${errorMessage}`);
+      return void 0;
+    }
+  }
+  /**
+   * Check if a value is a transformer constructor
+   * @param value - Value to check
+   * @returns true if it's a constructor
+   */
+  isTransformerConstructor(value) {
+    return typeof value === "function" && value.prototype && (typeof value.prototype.transformRequestIn === "function" || typeof value.prototype.transformRequestOut === "function" || typeof value.prototype.transformResponseIn === "function" || typeof value.prototype.transformResponseOut === "function" || "TransformerName" in value);
+  }
+  /**
+   * Get list of all registered transformer names
+   * @returns Array of transformer names
+   */
+  getTransformerNames() {
+    return Array.from(this.transformers.keys());
+  }
+  /**
+   * Clear all registered transformers
+   */
+  clear() {
+    this.transformers.clear();
+    this.clearInstanceCache();
+    this.logger.info("All transformers cleared");
+  }
+}, _class);
+
+
+
+exports.TransformerService = TransformerService;

package/dist/chunk-3QOSDDNI.cjs

@@ -0,0 +1,130 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/auditUsageStash.ts
+var stash = /* @__PURE__ */ new WeakMap();
+function stashAuditUsage(key, detail) {
+  const existing = stash.get(key);
+  stash.set(key, existing ? { ...existing, ...detail } : { ...detail });
+}
+function readAuditUsage(key) {
+  return stash.get(key);
+}
+
+// src/usage/usage-recorder.ts
+var UsageRecorder = class {
+  constructor(store, pricing, logger, options = {}) {
+    this.store = store;
+    this.pricing = pricing;
+    this.logger = logger;
+    this.defer = _nullishCoalesce(options.defer, () => ( ((fn) => setTimeout(fn, 0))));
+    this.onRecord = options.onRecord;
+  }
+  
+  
+  
+  
+  
+  /**
+   * Record one LLM request. Returns immediately — the actual store insert is
+   * deferred so the caller's response path is unblocked.
+   *
+   * Errors during the insert are logged but never thrown.
+   */
+  record(input) {
+    if (input.auditResponse) {
+      stashAuditUsage(input.auditResponse, {
+        inputTokens: input.usage.inputTokens,
+        outputTokens: input.usage.outputTokens,
+        model: input.model,
+        provider: input.providerId
+      });
+    }
+    this.defer(() => {
+      void this.recordAsync(input).catch((err) => {
+        this.logger.warn("[UsageRecorder] failed to persist usage event", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    });
+  }
+  /**
+   * Same as `record()` but awaitable — preferred in tests so they can assert
+   * after the row exists.
+   */
+  async recordAsync(input) {
+    const { costUsd, costSavedByCacheUsd } = await this.pricing.calculateCost(
+      input.providerId,
+      input.model,
+      input.usage
+    );
+    if (input.auditResponse) {
+      try {
+        stashAuditUsage(input.auditResponse, { costUsd });
+      } catch (e) {
+      }
+    }
+    if (this.onRecord && input.apiKeyId) {
+      try {
+        this.onRecord(input.apiKeyId, costUsd, Date.now());
+      } catch (e2) {
+      }
+    }
+    const row = {
+      messageId: _nullishCoalesce(input.messageId, () => ( null)),
+      parentMessageId: _nullishCoalesce(input.parentMessageId, () => ( null)),
+      sessionId: _nullishCoalesce(input.sessionId, () => ( null)),
+      providerId: input.providerId,
+      model: input.model,
+      apiKeyId: _nullishCoalesce(input.apiKeyId, () => ( null)),
+      engineOrigin: input.engineOrigin,
+      inputTokens: input.usage.inputTokens,
+      outputTokens: input.usage.outputTokens,
+      cacheReadTokens: input.usage.cacheReadTokens,
+      cacheCreationTokens: input.usage.cacheCreationTokens,
+      reasoningTokens: input.usage.reasoningTokens,
+      costUsd,
+      costSavedByCacheUsd,
+      rawUsage: input.rawUsage != null ? safeStringify(input.rawUsage) : null,
+      runId: _nullishCoalesce(input.runId, () => ( null)),
+      eventId: _nullishCoalesce(input.eventId, () => ( null))
+    };
+    try {
+      return await this.store.insert(row);
+    } catch (err) {
+      this.logger.warn("[UsageRecorder] store insert failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  // ===== Query delegates =====
+  getTotals(range) {
+    return this.store.getTotals(range);
+  }
+  getByModel(range) {
+    return this.store.getByModel(range);
+  }
+  getByApiKey(range) {
+    return this.store.getByApiKey(range);
+  }
+  getTimeSeries(range, bucket) {
+    return this.store.getTimeSeries(range, bucket);
+  }
+  getMessagesForSession(sessionId) {
+    return this.store.getMessagesForSession(sessionId);
+  }
+  /** Cumulative cache hit/miss stats for one session. */
+  getSessionCacheStats(sessionId) {
+    return this.store.getSessionCacheStats(sessionId);
+  }
+};
+var safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch (e3) {
+    return "";
+  }
+};
+
+
+
+
+exports.readAuditUsage = readAuditUsage; exports.UsageRecorder = UsageRecorder;

package/dist/chunk-46ZIFWYG.cjs

@@ -0,0 +1,277 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkGBHYAGX3cjs = require('./chunk-GBHYAGX3.cjs');
+
+// 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 {
+  
+  constructor(logger) {
+    this.logger = _nullishCoalesce(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 && _optionalChain([endpointTransformer, 'optionalAccess', _ => _.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 = _nullishCoalesce(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 (_optionalChain([extendedContext, 'optionalAccess', _2 => _2.enabled])) {
+      if (!config.headers || typeof config.headers !== "object") {
+        config.headers = {};
+      }
+      _chunkGBHYAGX3cjs.injectExtendedContextBeta.call(void 0, 
+        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 (_optionalChain([endpointTransformer, 'optionalAccess', _3 => _3.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 (_optionalChain([endpointTransformer, 'optionalAccess', _4 => _4.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 = { ..._nullishCoalesce(config.headers, () => ( {})), ..._nullishCoalesce(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 (!_optionalChain([endpointTransformer, 'optionalAccess', _5 => _5.name])) {
+      return false;
+    }
+    const providerHasOnlyEndpoint = chain.providerTransformers.length === 1 && _optionalChain([chain, 'access', _6 => _6.providerTransformers, 'access', _7 => _7[0], 'optionalAccess', _8 => _8.name]) === endpointTransformer.name;
+    const modelHasNoTransformers = chain.modelTransformers.length === 0;
+    const modelHasOnlyEndpoint = chain.modelTransformers.length === 1 && _optionalChain([chain, 'access', _9 => _9.modelTransformers, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.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);
+  }
+};
+
+
+
+exports.TransformerChainExecutor = TransformerChainExecutor;