@omnicross/core 0.1.2 → 0.1.4

package/dist/chunk-UHGVBFU3.js

@@ -0,0 +1,385 @@
+import {
+  getSubscriptionRegistryForOutbound
+} from "./chunk-AQ5TNQB7.js";
+import {
+  ENDPOINT_MODEL_KINDS
+} from "./chunk-XEKD23J5.js";
+
+// src/outbound-api/kindDetection.ts
+import { normalizeModelId as normalizeModelId2 } from "@omnicross/contracts/canonical-models";
+
+// src/outbound-api/roleDetection.ts
+import { normalizeModelId } from "@omnicross/contracts/canonical-models";
+var BACKGROUND_TIER_TOKENS = /* @__PURE__ */ new Set([
+  "haiku",
+  "mini",
+  "flash",
+  "small",
+  "lite",
+  "nano",
+  "8b"
+]);
+function modelTokens(normalizedId) {
+  return normalizedId.split(/[-._:/\s]+/).filter(Boolean);
+}
+function isBackgroundTierModel(rawModelId) {
+  if (!rawModelId) return false;
+  const tokens = modelTokens(normalizeModelId(rawModelId));
+  return tokens.some((tok) => BACKGROUND_TIER_TOKENS.has(tok));
+}
+function extractRequestedModel(ingressFormat, body) {
+  const model = body["model"];
+  return typeof model === "string" && model ? model : void 0;
+}
+function detectRequestRole(ingressFormat, body, options) {
+  const requestedModel = extractRequestedModel(ingressFormat, body);
+  if (requestedModel) {
+    const overrides = options?.backgroundModelIds;
+    if (overrides && overrides.length > 0) {
+      const reqNorm = normalizeModelId(requestedModel);
+      const inOverride = overrides.some((id) => {
+        if (!id) return false;
+        const candidate = id.includes(",") ? id.slice(id.indexOf(",") + 1) : id;
+        return normalizeModelId(candidate) === reqNorm || candidate === requestedModel;
+      });
+      if (inOverride) return "background";
+    }
+    if (isBackgroundTierModel(requestedModel)) return "background";
+  }
+  return "default";
+}
+function endpointToIngressFormat(endpoint) {
+  switch (endpoint) {
+    case "chat":
+      return "openai-chat";
+    case "responses":
+      return "openai-responses";
+    case "messages":
+      return "anthropic-messages";
+    case "gemini":
+      return "gemini-generatecontent";
+  }
+}
+
+// src/outbound-api/kindDetection.ts
+function isNonBlankRef(ref) {
+  return typeof ref === "string" && ref.trim() !== "";
+}
+function isKindMappedEndpoint(endpoint) {
+  return Object.prototype.hasOwnProperty.call(ENDPOINT_MODEL_KINDS, endpoint);
+}
+function modelKindsForEndpoint(endpoint) {
+  return ENDPOINT_MODEL_KINDS[endpoint];
+}
+function detectModelKind(endpoint, requestedModelId) {
+  if (!requestedModelId || requestedModelId.trim() === "") return void 0;
+  if (endpoint === "messages") {
+    const declared = ENDPOINT_MODEL_KINDS.messages;
+    for (const tok of modelTokens(normalizeModelId2(requestedModelId))) {
+      if (declared.includes(tok)) return tok;
+    }
+    return void 0;
+  }
+  return isBackgroundTierModel(requestedModelId) ? "mini" : "codex";
+}
+function validateEndpointModelConfig(config) {
+  if (!isKindMappedEndpoint(config.endpoint)) return [];
+  const map = config.modelMap ?? {};
+  return modelKindsForEndpoint(config.endpoint).filter(
+    (kind) => !isNonBlankRef(map[kind])
+  );
+}
+function validateServerModelConfig(config) {
+  const errors = [];
+  for (const endpoint of Object.keys(ENDPOINT_MODEL_KINDS)) {
+    const ep = config.endpoints.find((e) => e.endpoint === endpoint);
+    const declared = modelKindsForEndpoint(endpoint);
+    const missingKinds = ep ? validateEndpointModelConfig(ep) : [...declared];
+    if (missingKinds.length > 0 && missingKinds.length < declared.length) {
+      errors.push({ endpoint, missingKinds });
+    }
+  }
+  return errors;
+}
+
+// src/outbound-api/modelPrefixDispatch.ts
+function classifyModelPrefix(model) {
+  if (!model) return null;
+  const id = model.trim().toLowerCase();
+  if (!id) return null;
+  if (matchesPrefix(id, "claude")) return "claude";
+  if (matchesPrefix(id, "gemini")) return "gemini";
+  if (matchesPrefix(id, "gpt") || matchesOSeries(id)) return "gpt";
+  return null;
+}
+function matchesPrefix(id, prefix) {
+  return id === prefix || id.startsWith(`${prefix}-`);
+}
+function matchesOSeries(id) {
+  return /^o\d/.test(id);
+}
+function resolvePrefixTarget(targets, model) {
+  const kind = classifyModelPrefix(model);
+  if (!kind) return null;
+  const ref = targets?.[kind];
+  if (!ref || !ref.trim()) return null;
+  return { kind, ref };
+}
+
+// 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",
+  "chat"
+]);
+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 };
+}
+var MESSAGES_FALLBACK_ORDER = ["sonnet", "opus", "haiku", "fable"];
+function isNonBlankRef2(ref) {
+  return typeof ref === "string" && ref.trim() !== "";
+}
+function pickModelRefFromList(models, requestedModel) {
+  if (!requestedModel || !models || models.length === 0) return void 0;
+  const wanted = requestedModel.trim();
+  let ciHit;
+  for (const ref of models) {
+    const parsed = parseModelRef(ref);
+    if (!parsed) continue;
+    if (parsed.modelId === wanted) return ref;
+    if (!ciHit && parsed.modelId.toLowerCase() === wanted.toLowerCase()) ciHit = ref;
+  }
+  return ciHit;
+}
+function pickModelRefForRole(config, role) {
+  if (role === "background") {
+    return { ref: config.backgroundModel, effectiveRole: "background" };
+  }
+  return { ref: config.defaultModel, effectiveRole: "default" };
+}
+function pickModelRefForKind(config, endpoint, requestedModel) {
+  const map = config.modelMap ?? {};
+  const detected = detectModelKind(endpoint, requestedModel);
+  const kind = detected ?? "unmapped";
+  if (detected && isNonBlankRef2(map[detected])) {
+    return { ref: map[detected], kind: detected };
+  }
+  if (endpoint === "messages") {
+    for (const k of MESSAGES_FALLBACK_ORDER) {
+      if (isNonBlankRef2(map[k])) return { ref: map[k], kind };
+    }
+    return { ref: void 0, kind };
+  }
+  if (isNonBlankRef2(map["codex"])) return { ref: map["codex"], kind };
+  return { ref: void 0, kind };
+}
+async function resolveRoute(args) {
+  const { config, ingressFormat, llmConfig } = args;
+  const sessionId = args.sessionId ?? null;
+  const endpoint = config.endpoint;
+  const kindMapped = isKindMappedEndpoint(endpoint);
+  const requestedModel = kindMapped ? args.requestedModel : void 0;
+  let ref;
+  let effectiveRole = "default";
+  let noModelStatus = 503;
+  let noModelMessage;
+  let malformedMessage;
+  if (kindMapped) {
+    const picked = pickModelRefForKind(config, endpoint, args.requestedModel);
+    ref = picked.ref;
+    noModelMessage = `endpoint '${config.endpoint}' has no model configured for kind '${picked.kind}'`;
+    malformedMessage = (r) => `endpoint '${config.endpoint}' model ref for kind '${picked.kind}' is malformed: '${r}'`;
+  } else if (endpoint === "chat" && config.dispatchMode === "prefix") {
+    ref = resolvePrefixTarget(config.prefixTargets, args.requestedModel)?.ref;
+    noModelStatus = 404;
+    noModelMessage = args.requestedModel ? `model '${args.requestedModel}' has no matching prefix target (claude-* / gpt-* / gemini-*) on the 'chat' endpoint` : `request has no 'model'; a prefix-dispatch 'chat' endpoint routes claude-* / gpt-* / gemini-*`;
+    malformedMessage = (r) => `endpoint 'chat' prefix target ref is malformed: '${r}'`;
+  } else if (endpoint === "chat") {
+    ref = pickModelRefFromList(config.models, args.requestedModel);
+    noModelStatus = 404;
+    noModelMessage = args.requestedModel ? `model '${args.requestedModel}' is not in the endpoint's model list (see GET /v1/models)` : `request has no 'model'; pick one from GET /v1/models`;
+    malformedMessage = (r) => `endpoint 'chat' model ref is malformed: '${r}'`;
+  } else {
+    const picked = pickModelRefForRole(config, args.role ?? "default");
+    ref = picked.ref;
+    effectiveRole = picked.effectiveRole;
+    noModelMessage = `endpoint '${config.endpoint}' has no ${effectiveRole} model configured`;
+    malformedMessage = (r) => `endpoint '${config.endpoint}' ${effectiveRole} model ref is malformed: '${r}'`;
+  }
+  if (!ref || !ref.trim()) {
+    return { ok: false, error: { status: noModelStatus, message: noModelMessage } };
+  }
+  const parsed = parseModelRef(ref);
+  if (!parsed) {
+    return { ok: false, error: { status: 503, message: malformedMessage(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,
+        requestedModel,
+        apiKeyId: args.apiKeyId
+      });
+    }
+    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: args.apiKeyId ?? null }
+    };
+  }
+  const route = {
+    sessionId,
+    targetProviderFormat,
+    model: modelId,
+    ingressFormat,
+    authMode: "byo",
+    providerId,
+    // Passthrough gate: the client's ORIGINAL requested id (kind-mapped only).
+    requestedModel,
+    // Usage attribution: the verified named-key id (undefined for internal traffic).
+    apiKeyId: args.apiKeyId,
+    anthropicSdkHints
+  };
+  return { ok: true, route, usedRole: effectiveRole };
+}
+async function resolveSubscriptionRoute(args) {
+  const { config, providerId, modelId, ingressFormat, sessionId, effectiveRole } = args;
+  const { requestedModel, apiKeyId } = 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: apiKeyId ?? null }
+  };
+  const subscriptionConfig = providerId === "opencodego" ? await registry?.getOpenCodeGoConfig?.() : void 0;
+  const route = {
+    sessionId,
+    targetProviderFormat: "transform",
+    model: modelId,
+    ingressFormat,
+    authMode: "subscription",
+    providerId,
+    // Passthrough gate: the client's ORIGINAL requested id (kind-mapped only).
+    requestedModel,
+    // Usage attribution: the verified named-key id (undefined for internal traffic).
+    apiKeyId,
+    // 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" || ingressFormat === "openai-chat" ? 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,
+    // Per-request preferred account (provider/subscription duality); undefined ⇒ pool.
+    preferredAccountId: config.boundAccountId,
+    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 {
+  extractRequestedModel,
+  detectRequestRole,
+  endpointToIngressFormat,
+  isKindMappedEndpoint,
+  modelKindsForEndpoint,
+  detectModelKind,
+  validateEndpointModelConfig,
+  validateServerModelConfig,
+  classifyModelPrefix,
+  resolvePrefixTarget,
+  SUBSCRIPTION_PROVIDER_IDS,
+  isSubscriptionProviderId,
+  endpointSupportsSubscription,
+  parseModelRef,
+  pickModelRefFromList,
+  resolveRoute
+};

package/dist/chunk-UIBD2YY5.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/pipeline/webhookEmit.ts
+var sink = null;
+function setWebhookSink(fn) {
+  sink = fn;
+}
+function emitWebhookEvent(event) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(event);
+  } catch (e) {
+  }
+}
+function __resetWebhookSinkForTests() {
+  sink = null;
+}
+
+
+
+
+
+exports.setWebhookSink = setWebhookSink; exports.emitWebhookEvent = emitWebhookEvent; exports.__resetWebhookSinkForTests = __resetWebhookSinkForTests;

package/dist/chunk-UNEFIWXI.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/openrouter.ts
+function isOpenRouterProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("openrouter.ai");
+}
+var DEFAULT_APP_IDENTITY = {
+  referer: "https://github.com/Dumoedss/omnicross",
+  title: "Omnicross"
+};
+var OPENROUTER_APP_HEADERS = {
+  "HTTP-Referer": DEFAULT_APP_IDENTITY.referer,
+  "X-Title": DEFAULT_APP_IDENTITY.title
+};
+function setOpenRouterAppIdentity(identity) {
+  const referer = _optionalChain([identity, 'access', _ => _.referer, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+  const title = _optionalChain([identity, 'access', _4 => _4.title, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+  if (referer) OPENROUTER_APP_HEADERS["HTTP-Referer"] = referer;
+  if (title) OPENROUTER_APP_HEADERS["X-Title"] = title;
+}
+function getOpenRouterAppIdentity() {
+  return {
+    referer: OPENROUTER_APP_HEADERS["HTTP-Referer"],
+    title: OPENROUTER_APP_HEADERS["X-Title"]
+  };
+}
+
+
+
+
+
+
+exports.isOpenRouterProvider = isOpenRouterProvider; exports.OPENROUTER_APP_HEADERS = OPENROUTER_APP_HEADERS; exports.setOpenRouterAppIdentity = setOpenRouterAppIdentity; exports.getOpenRouterAppIdentity = getOpenRouterAppIdentity;