@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-DK4A7DLE.js

@@ -0,0 +1,266 @@
+// 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 {
+  transformers = /* @__PURE__ */ new Map();
+  logger;
+  // Performance optimization: Cache instantiated transformers
+  instanceCache = /* @__PURE__ */ new Map();
+  // Performance optimization: Cache endpoint transformer results
+  endpointTransformersCache = null;
+  noEndpointTransformersCache = null;
+  constructor(logger) {
+    this.logger = 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 && transformer.prototype?.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 (instance?.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 = TransformerClass.TransformerName ?? key;
+          this.registerTransformer(staticName, TransformerClass);
+        } else {
+          const name = 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(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");
+  }
+};
+
+export {
+  TransformerService
+};

package/dist/chunk-DQ5VAYZ6.cjs

@@ -0,0 +1,42 @@
+"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 _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
+
+// src/completion/openrouter-headers.ts
+var OPENROUTER_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+function buildOpenRouterHeaders(credentials, options = {}) {
+  const apiKey = _optionalChain([credentials, 'access', _ => _.apiKey, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+  if (!apiKey) {
+    throw new Error("OpenRouter API key is required");
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    ..._chunkUNEFIWXIcjs.OPENROUTER_APP_HEADERS
+  };
+  if (options.contentType !== false) {
+    headers["Content-Type"] = _nullishCoalesce(options.contentType, () => ( "application/json"));
+  }
+  if (options.extra) {
+    for (const [key, value] of Object.entries(options.extra)) {
+      headers[key] = value;
+    }
+  }
+  return headers;
+}
+function resolveOpenRouterBaseUrl(endpoint) {
+  const raw = _optionalChain([endpoint, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  const base = raw && raw.length > 0 ? raw : OPENROUTER_DEFAULT_BASE_URL;
+  return base.replace(/\/+$/, "");
+}
+function buildOpenRouterUrl(endpoint, path) {
+  const base = resolveOpenRouterBaseUrl(endpoint);
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${cleanPath}`;
+}
+
+
+
+
+
+
+exports.OPENROUTER_DEFAULT_BASE_URL = OPENROUTER_DEFAULT_BASE_URL; exports.buildOpenRouterHeaders = buildOpenRouterHeaders; exports.resolveOpenRouterBaseUrl = resolveOpenRouterBaseUrl; exports.buildOpenRouterUrl = buildOpenRouterUrl;

package/dist/chunk-DRWHTIIZ.js

@@ -0,0 +1,13 @@
+// src/ports/gemini-code-assist-resolver.ts
+var resolver = null;
+function setGeminiCodeAssistResolver(impl) {
+  resolver = impl;
+}
+function getGeminiCodeAssistResolver() {
+  return resolver;
+}
+
+export {
+  setGeminiCodeAssistResolver,
+  getGeminiCodeAssistResolver
+};

package/dist/chunk-DWKQZ2SK.cjs

@@ -0,0 +1,254 @@
+"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/transformers/ReasoningTransformer.ts
+
+
+
+
+
+var _thinkingconfig = require('@omnicross/contracts/thinking-config');
+var ReasoningTransformer = (_class = class {
+  static __initStatic() {this.TransformerName = "reasoning"}
+  __init() {this.name = "reasoning"}
+  
+  
+  constructor(options) {;_class.prototype.__init.call(this);
+    this.enabled = _optionalChain([options, 'optionalAccess', _ => _.enable]) !== false;
+  }
+  /**
+   * Transform request: convert reasoning config to thinking parameters
+   * Uses model-specific budget calculation based on effort level
+   */
+  async transformRequestIn(request, provider, _context) {
+    const extendedRequest = request;
+    const modelId = request.model;
+    if (!this.enabled) {
+      extendedRequest.thinking = {
+        type: "disabled",
+        budget_tokens: -1
+      };
+      extendedRequest.enable_thinking = false;
+      return extendedRequest;
+    }
+    if (request.reasoning) {
+      const effortLevel = request.reasoning.effort || "none";
+      const userMaxTokens = request.reasoning.max_tokens || request.max_tokens;
+      const calculatedBudget = _thinkingconfig.calculateThinkingBudget.call(void 0, modelId, effortLevel, userMaxTokens);
+      const providerName = _optionalChain([provider, 'access', _2 => _2.name, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4()]) || "";
+      if (providerName === "anthropic" || providerName.includes("claude")) {
+        const thinkingConfig = _thinkingconfig.buildAnthropicThinking.call(void 0, modelId, effortLevel, userMaxTokens);
+        if (thinkingConfig) {
+          extendedRequest.thinking = thinkingConfig;
+        } else {
+          extendedRequest.thinking = {
+            type: "disabled"
+          };
+        }
+      } else if (providerName === "openai" || modelId.match(/^o[134]/i)) {
+        const reasoningEffort = _thinkingconfig.getOpenAIReasoningEffort.call(void 0, effortLevel);
+        if (reasoningEffort) {
+          extendedRequest.reasoning_effort = reasoningEffort;
+        }
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+      } else if (providerName === "deepseek" && _optionalChain([modelId, 'optionalAccess', _5 => _5.startsWith, 'call', _6 => _6("deepseek-v4")])) {
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+        if (effortLevel !== "none") {
+          extendedRequest.reasoning_effort = effortLevel === "high" ? "max" : "high";
+        }
+      } else if (providerName === "deepseek" || providerName === "qwen" || providerName === "alibaba") {
+        const qwenConfig = _thinkingconfig.buildQwenThinkingConfig.call(void 0, effortLevel, userMaxTokens);
+        extendedRequest.enable_thinking = qwenConfig.enable_thinking;
+        if (qwenConfig.thinking_budget) {
+          extendedRequest.thinking_budget = qwenConfig.thinking_budget;
+        }
+        extendedRequest.thinking = {
+          type: qwenConfig.enable_thinking ? "enabled" : "disabled",
+          budget_tokens: calculatedBudget
+        };
+      } else {
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+        extendedRequest.enable_thinking = effortLevel !== "none";
+      }
+      _optionalChain([this, 'access', _7 => _7.logger, 'optionalAccess', _8 => _8.debug, 'call', _9 => _9(`[ReasoningTransformer] Model: ${modelId}, Effort: ${effortLevel}, Budget: ${calculatedBudget}`)]);
+    }
+    return extendedRequest;
+  }
+  /**
+   * Transform response: convert reasoning_content to thinking blocks
+   */
+  async transformResponseOut(response, _context) {
+    if (!this.enabled) return response;
+    const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+    if (contentType.includes("application/json")) {
+      return this.handleJsonResponse(response);
+    } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+      return this.handleStreamResponse(response);
+    }
+    return response;
+  }
+  /**
+   * Handle JSON (non-streaming) response
+   */
+  async handleJsonResponse(response) {
+    const jsonResponse = await response.json();
+    if (_optionalChain([jsonResponse, 'access', _10 => _10.choices, 'optionalAccess', _11 => _11[0], 'optionalAccess', _12 => _12.message, 'optionalAccess', _13 => _13.reasoning_content])) {
+      jsonResponse.thinking = {
+        content: jsonResponse.choices[0].message.reasoning_content
+      };
+      delete jsonResponse.choices[0].message.reasoning_content;
+    }
+    return new Response(JSON.stringify(jsonResponse), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  /**
+   * Handle streaming response - convert reasoning_content to thinking blocks
+   */
+  handleStreamResponse(response) {
+    if (!response.body) {
+      return response;
+    }
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let reasoningContent = "";
+    let isReasoningComplete = false;
+    let buffer = "";
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const reader = response.body.getReader();
+        const processLine = (line) => {
+          _optionalChain([this, 'access', _14 => _14.logger, 'optionalAccess', _15 => _15.debug, 'call', _16 => _16("Processing reasoning line:", line)]);
+          if (line.startsWith("data: ") && line.trim() !== "data: [DONE]") {
+            try {
+              const data = JSON.parse(line.slice(6));
+              if (_optionalChain([data, 'access', _17 => _17.choices, 'optionalAccess', _18 => _18[0], 'optionalAccess', _19 => _19.delta, 'optionalAccess', _20 => _20.reasoning_content])) {
+                reasoningContent += data.choices[0].delta.reasoning_content;
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        thinking: {
+                          content: data.choices[0].delta.reasoning_content
+                        }
+                      }
+                    }
+                  ]
+                };
+                delete thinkingChunk.choices[0].delta.reasoning_content;
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+                return;
+              }
+              if ((_optionalChain([data, 'access', _21 => _21.choices, 'optionalAccess', _22 => _22[0], 'optionalAccess', _23 => _23.delta, 'optionalAccess', _24 => _24.content]) || _optionalChain([data, 'access', _25 => _25.choices, 'optionalAccess', _26 => _26[0], 'optionalAccess', _27 => _27.delta, 'optionalAccess', _28 => _28.tool_calls])) && reasoningContent && !isReasoningComplete) {
+                isReasoningComplete = true;
+                const signature = Date.now().toString();
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        content: null,
+                        thinking: {
+                          signature
+                        }
+                      }
+                    }
+                  ]
+                };
+                delete thinkingChunk.choices[0].delta.reasoning_content;
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+              }
+              if (_optionalChain([data, 'access', _29 => _29.choices, 'optionalAccess', _30 => _30[0], 'optionalAccess', _31 => _31.delta, 'optionalAccess', _32 => _32.reasoning_content])) {
+                delete data.choices[0].delta.reasoning_content;
+              }
+              if (_optionalChain([data, 'access', _33 => _33.choices, 'optionalAccess', _34 => _34[0], 'optionalAccess', _35 => _35.delta]) && Object.keys(data.choices[0].delta).length > 0) {
+                if (isReasoningComplete) {
+                  data.choices[0].index++;
+                }
+                const modifiedLine = `data: ${JSON.stringify(data)}
+
+`;
+                controller.enqueue(encoder.encode(modifiedLine));
+              }
+            } catch (_e) {
+              controller.enqueue(encoder.encode(line + "\n"));
+            }
+          } else {
+            controller.enqueue(encoder.encode(line + "\n"));
+          }
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                const lines2 = buffer.split("\n");
+                for (const line of lines2) {
+                  if (line.trim()) {
+                    controller.enqueue(encoder.encode(line + "\n"));
+                  }
+                }
+              }
+              break;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                processLine(line);
+              } catch (error) {
+                _optionalChain([this, 'access', _36 => _36.logger, 'optionalAccess', _37 => _37.error, 'call', _38 => _38("Error processing reasoning stream line:", error)]);
+                controller.enqueue(encoder.encode(line + "\n"));
+              }
+            }
+          }
+        } catch (error) {
+          _optionalChain([this, 'access', _39 => _39.logger, 'optionalAccess', _40 => _40.error, 'call', _41 => _41("Reasoning stream error:", error)]);
+          controller.error(error);
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch (e) {
+            _optionalChain([this, 'access', _42 => _42.logger, 'optionalAccess', _43 => _43.error, 'call', _44 => _44("Error releasing reader lock:", e)]);
+          }
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: new Headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      })
+    });
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.ReasoningTransformer = ReasoningTransformer;

package/dist/chunk-EYZYXJTJ.cjs

@@ -0,0 +1 @@
+"use strict";