@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-3MEACFK3.js

@@ -0,0 +1,193 @@
+import {
+  getSubscriptionRegistryForOutbound
+} from "./chunk-AQ5TNQB7.js";
+
+// src/outbound-api/subscriptionSupport.ts
+var SUBSCRIPTION_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencodego"
+];
+var SUBSCRIPTION_ID_SET = new Set(SUBSCRIPTION_PROVIDER_IDS);
+function isSubscriptionProviderId(providerId) {
+  if (SUBSCRIPTION_ID_SET.has(providerId)) return true;
+  const registry = getSubscriptionRegistryForOutbound();
+  return registry?.getProfile(providerId) != null;
+}
+var SUBSCRIPTION_SUPPORTED_ENDPOINTS = /* @__PURE__ */ new Set([
+  "messages",
+  "responses"
+]);
+function endpointSupportsSubscription(endpoint) {
+  return SUBSCRIPTION_SUPPORTED_ENDPOINTS.has(endpoint);
+}
+
+// src/outbound-api/routeResolver.ts
+function parseModelRef(ref) {
+  if (!ref) return null;
+  const idx = ref.indexOf(",");
+  if (idx <= 0) return null;
+  const providerId = ref.slice(0, idx).trim();
+  const modelId = ref.slice(idx + 1).trim();
+  if (!providerId || !modelId) return null;
+  return { providerId, modelId };
+}
+function pickModelRefForRole(config, role) {
+  if (role === "vision") {
+    if (config.visionModel && config.visionModel.trim()) {
+      return { ref: config.visionModel, effectiveRole: "vision" };
+    }
+    return { ref: config.defaultModel, effectiveRole: "default" };
+  }
+  if (role === "background") {
+    return { ref: config.backgroundModel, effectiveRole: "background" };
+  }
+  return { ref: config.defaultModel, effectiveRole: "default" };
+}
+async function resolveRoute(args) {
+  const { config, role, ingressFormat, llmConfig } = args;
+  const sessionId = args.sessionId ?? null;
+  const { ref, effectiveRole } = pickModelRefForRole(config, role);
+  if (!ref || !ref.trim()) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `endpoint '${config.endpoint}' has no ${effectiveRole} model configured`
+      }
+    };
+  }
+  const parsed = parseModelRef(ref);
+  if (!parsed) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `endpoint '${config.endpoint}' ${effectiveRole} model ref is malformed: '${ref}'`
+      }
+    };
+  }
+  const { providerId, modelId } = parsed;
+  const provider = await llmConfig.getProvider(providerId);
+  if (!provider) {
+    if (isSubscriptionProviderId(providerId)) {
+      return await resolveSubscriptionRoute({
+        config,
+        providerId,
+        modelId,
+        ingressFormat,
+        sessionId,
+        effectiveRole
+      });
+    }
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `provider '${providerId}' not found for endpoint '${config.endpoint}'`
+      }
+    };
+  }
+  const isOfficialProvider = provider.isOfficial === true || provider.id === "anthropic";
+  const targetProviderFormat = isOfficialProvider ? "anthropic" : "transform";
+  let anthropicSdkHints = null;
+  if (ingressFormat === "anthropic-messages") {
+    anthropicSdkHints = {
+      apiKey: resolveApiKey(provider.api_key),
+      isOfficialProvider,
+      passThrough: false,
+      attribution: { sessionId, apiKeyId: null }
+    };
+  }
+  const route = {
+    sessionId,
+    targetProviderFormat,
+    model: modelId,
+    ingressFormat,
+    authMode: "byo",
+    providerId,
+    anthropicSdkHints
+  };
+  return { ok: true, route, usedRole: effectiveRole };
+}
+async function resolveSubscriptionRoute(args) {
+  const { config, providerId, modelId, ingressFormat, sessionId, effectiveRole } = args;
+  if (!config.useSubscription) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `subscription routing disabled for endpoint '${config.endpoint}'`
+      }
+    };
+  }
+  if (!endpointSupportsSubscription(config.endpoint)) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `subscription routing is not supported on the '${config.endpoint}' endpoint; use a BYO API-key provider, or the /v1/messages or /v1/responses endpoint`
+      }
+    };
+  }
+  const registry = getSubscriptionRegistryForOutbound();
+  const profile = registry?.getProfile(providerId) ?? null;
+  if (!profile) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `subscription provider '${providerId}' is not available`
+      }
+    };
+  }
+  const hints = {
+    apiKey: "",
+    isOfficialProvider: false,
+    passThrough: false,
+    subscriptionProfile: profile,
+    attribution: { sessionId, apiKeyId: null }
+  };
+  const subscriptionConfig = providerId === "opencodego" ? await registry?.getOpenCodeGoConfig?.() : void 0;
+  const route = {
+    sessionId,
+    targetProviderFormat: "transform",
+    model: modelId,
+    ingressFormat,
+    authMode: "subscription",
+    providerId,
+    // Anthropic delegation carries the dispatch profile inside
+    // `anthropicSdkHints.subscriptionProfile`. The Responses ingress reads the
+    // TOP-LEVEL `route.subscriptionProfile`, and so does the built-in
+    // (factory-absent) `/v1/messages` subscription path (RT2.1) — the registry's
+    // `SubscriptionDispatchProfile` structurally satisfies `SubscriptionAuthProfile`
+    // ({ authStrategy, resolveUpstreamUrl, providerTransformerNames }), so set it
+    // for BOTH. This is INERT when an Anthropic ingress factory is present: that
+    // delegation reads the hint-bundle field above (and uses a different
+    // route-minting path), never the top-level field. (chat/gemini never reach
+    // here — Gate 2 rejected them.)
+    subscriptionProfile: ingressFormat === "openai-responses" || ingressFormat === "anthropic-messages" ? profile : void 0,
+    // Opaque per-account config (opencodego-only; `undefined` otherwise). Read by
+    // the built-in `/v1/messages` plan builder; INERT for the factory-present
+    // delegation path + non-opencodego.
+    subscriptionConfig,
+    anthropicSdkHints: hints
+  };
+  return { ok: true, route, usedRole: effectiveRole };
+}
+function resolveApiKey(apiKey) {
+  if (!apiKey) return "";
+  if (apiKey.startsWith("$")) {
+    return process.env[apiKey.slice(1)] || "";
+  }
+  return apiKey;
+}
+
+export {
+  SUBSCRIPTION_PROVIDER_IDS,
+  isSubscriptionProviderId,
+  endpointSupportsSubscription,
+  parseModelRef,
+  resolveRoute
+};

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;