@omnicross/core 0.1.2 → 0.1.3

package/dist/chunk-RPII3E6Z.cjs

@@ -0,0 +1,145 @@
+"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;
+
+
+var _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
+
+// src/provider-proxy/identity/SubscriptionIdentityStore.ts
+var CC_HEADER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var KEY_SEP = "\0";
+function normalizeUa(ua) {
+  if (typeof ua !== "string") return void 0;
+  const trimmed = ua.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var SubscriptionIdentityStore = (_class = class {
+  __init() {this.identities = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  __init2() {this.persistence = null}
+  constructor(opts = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.now = _nullishCoalesce(opts.now, () => ( Date.now));
+    this.enabled = _nullishCoalesce(opts.enabled, () => ( false));
+    this.ua = normalizeUa(opts.ua);
+    this.ccHeaderTtlMs = _nullishCoalesce(opts.ccHeaderTtlMs, () => ( CC_HEADER_TTL_MS));
+  }
+  /** Whether capture/replay is engaged (config flag). */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** The operator UA baseline (piece 4), or undefined when unset. */
+  uaBaseline() {
+    return this.ua;
+  }
+  /**
+   * Re-apply config to the LIVE shared instance (bootstrap, mirroring the health
+   * tracker's `configure`). Only defined fields override; `ua: null` clears the
+   * baseline.
+   */
+  configure(opts) {
+    if (opts.enabled !== void 0) this.enabled = opts.enabled;
+    if (opts.ua !== void 0) this.ua = normalizeUa(_nullishCoalesce(opts.ua, () => ( void 0)));
+  }
+  /** Install (or clear) the write-through persistence port (P2). */
+  setPersistence(port) {
+    this.persistence = port;
+  }
+  /**
+   * Boot seed (P2, D5): install a PERSISTED identity for an account, but NEVER
+   * over a live in-memory capture (a re-captured identity from this session wins).
+   * A no-op for an empty/absent identity. Does NOT write back through the port.
+   */
+  seed(providerId, accountId, identity) {
+    if (!accountId || !identity) return;
+    const headers = _chunk6RPZADX3cjs.sanitizeFrozenHeaders.call(void 0, _nullishCoalesce(identity.headers, () => ( {})));
+    if (Object.keys(headers).length === 0) return;
+    const key = this.key(providerId, accountId);
+    if (this.identities.has(key)) return;
+    this.identities.set(key, {
+      headers,
+      capturedAt: typeof identity.capturedAt === "number" ? identity.capturedAt : this.now()
+    });
+  }
+  /**
+   * Capture a real client's fingerprint headers for an account. First-seen ⇒
+   * FREEZE the whole (sanitized) bag. Already-frozen ⇒ within the TTL, no change
+   * (stable identity); past the TTL, refresh the NON-stainless headers from the
+   * new observation while keeping stainless frozen-stable (P2). An empty/absent
+   * account id or an empty sanitized bag is a no-op (so an account with no
+   * fingerprint headers never freezes an empty identity → the caller falls back
+   * to the UA baseline). Fires the persistence port on a freeze/refresh.
+   */
+  capture(providerId, accountId, incoming, now = this.now()) {
+    if (!accountId) return;
+    const clean = _chunk6RPZADX3cjs.sanitizeFrozenHeaders.call(void 0, incoming);
+    if (Object.keys(clean).length === 0) return;
+    const key = this.key(providerId, accountId);
+    const existing = this.identities.get(key);
+    if (!existing) {
+      const frozen = { headers: clean, capturedAt: now };
+      this.identities.set(key, frozen);
+      this.emitPersist(providerId, accountId, frozen);
+      return;
+    }
+    if (now - existing.capturedAt < this.ccHeaderTtlMs) return;
+    const refreshed = {
+      headers: _chunk6RPZADX3cjs.refreshNonStainless.call(void 0, existing.headers, clean),
+      capturedAt: now
+    };
+    this.identities.set(key, refreshed);
+    this.emitPersist(providerId, accountId, refreshed);
+  }
+  /**
+   * The frozen identity headers for an account, or `undefined` when none is
+   * frozen (or the frozen set is empty). Returns a COPY (the caller merges it into
+   * a mutable outbound header bag).
+   */
+  replay(providerId, accountId) {
+    if (!accountId) return void 0;
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    if (!frozen || Object.keys(frozen.headers).length === 0) return void 0;
+    return { ...frozen.headers };
+  }
+  /** Whether an identity is frozen for an account (admin coarse status — D7). */
+  hasIdentity(providerId, accountId) {
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    return !!frozen && Object.keys(frozen.headers).length > 0;
+  }
+  /** The freeze/refresh time for an account's identity (admin coarse status). */
+  capturedAt(providerId, accountId) {
+    return _optionalChain([this, 'access', _ => _.identities, 'access', _2 => _2.get, 'call', _3 => _3(this.key(providerId, accountId)), 'optionalAccess', _4 => _4.capturedAt]);
+  }
+  emitPersist(providerId, accountId, identity) {
+    if (!this.persistence) return;
+    try {
+      this.persistence.persist(providerId, accountId, {
+        headers: { ...identity.headers },
+        capturedAt: identity.capturedAt
+      });
+    } catch (e) {
+    }
+  }
+  key(providerId, accountId) {
+    return `${providerId}${KEY_SEP}${accountId}`;
+  }
+}, _class);
+var _shared = null;
+function getSharedIdentityStore() {
+  if (!_shared) _shared = new SubscriptionIdentityStore();
+  return _shared;
+}
+function setSharedIdentityStore(instance) {
+  _shared = instance;
+}
+function __resetSharedIdentityStoreForTests() {
+  _shared = null;
+}
+
+
+
+
+
+
+
+exports.CC_HEADER_TTL_MS = CC_HEADER_TTL_MS; exports.SubscriptionIdentityStore = SubscriptionIdentityStore; exports.getSharedIdentityStore = getSharedIdentityStore; exports.setSharedIdentityStore = setSharedIdentityStore; exports.__resetSharedIdentityStoreForTests = __resetSharedIdentityStoreForTests;

package/dist/chunk-S6JGLF3G.cjs

@@ -0,0 +1,89 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/upstreamFetch.ts
+var _undici = require('undici');
+var _socks = require('socks');
+var resolver = null;
+var generation = 0;
+var cache = /* @__PURE__ */ new Map();
+function normalizeProxy(cfg) {
+  if ("url" in cfg) {
+    let u;
+    try {
+      u = new URL(cfg.url);
+    } catch (e) {
+      return void 0;
+    }
+    const proto = u.protocol.replace(/:$/, "").toLowerCase();
+    const kind2 = proto === "socks5" || proto === "socks" ? "socks5" : proto === "https" ? "https" : "http";
+    const port = u.port ? Number(u.port) : kind2 === "https" ? 443 : kind2 === "socks5" ? 1080 : 80;
+    if (!u.hostname || !Number.isFinite(port)) return void 0;
+    return {
+      kind: kind2,
+      host: u.hostname,
+      port,
+      username: u.username ? decodeURIComponent(u.username) : void 0,
+      password: u.password ? decodeURIComponent(u.password) : void 0
+    };
+  }
+  const kind = cfg.type === "socks5" ? "socks5" : cfg.type === "https" ? "https" : "http";
+  if (!cfg.host || !Number.isFinite(cfg.port)) return void 0;
+  return {
+    kind,
+    host: cfg.host,
+    port: cfg.port,
+    username: cfg.username || void 0,
+    password: cfg.password || void 0
+  };
+}
+function proxyKey(p) {
+  return `${p.kind}://${_nullishCoalesce(p.username, () => ( ""))}:${_nullishCoalesce(p.password, () => ( ""))}@${p.host}:${p.port}`;
+}
+function socksConnector(p) {
+  const base = _undici.buildConnector.call(void 0, {});
+  return ((options, callback) => {
+    const destPort = Number(options.port) || (options.protocol === "https:" ? 443 : 80);
+    _socks.SocksClient.createConnection({
+      proxy: { host: p.host, port: p.port, type: 5, userId: p.username, password: p.password },
+      command: "connect",
+      destination: { host: options.hostname, port: destPort }
+    }).then(({ socket }) => {
+      base({ ...options, httpSocket: socket }, callback);
+    }).catch((err) => callback(err, null));
+  });
+}
+function buildDispatcher(p) {
+  if (p.kind === "socks5") {
+    return new (0, _undici.Agent)({ connect: socksConnector(p) });
+  }
+  const auth = p.username != null ? `${encodeURIComponent(p.username)}:${encodeURIComponent(_nullishCoalesce(p.password, () => ( "")))}@` : "";
+  const uri = `${p.kind}://${auth}${p.host}:${p.port}`;
+  return new (0, _undici.ProxyAgent)({ uri });
+}
+function resolveUpstreamDispatcher(ctx) {
+  const active = resolver;
+  if (!active) return void 0;
+  let cfg;
+  try {
+    cfg = active(ctx);
+  } catch (e2) {
+    return void 0;
+  }
+  if (!cfg) return void 0;
+  const norm = normalizeProxy(cfg);
+  if (!norm) return void 0;
+  const key = `${generation}\0${proxyKey(norm)}`;
+  let dispatcher = cache.get(key);
+  if (!dispatcher) {
+    dispatcher = buildDispatcher(norm);
+    cache.set(key, dispatcher);
+  }
+  return dispatcher;
+}
+function fetchUpstream(url, init, ctx) {
+  const dispatcher = resolveUpstreamDispatcher({ ..._nullishCoalesce(ctx, () => ( {})), url });
+  if (!dispatcher) return fetch(url, init);
+  return fetch(url, { ...init, dispatcher });
+}
+
+
+
+exports.fetchUpstream = fetchUpstream;

package/dist/chunk-SVXC36MU.cjs

@@ -0,0 +1,383 @@
+"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 _chunkQBZJ7P2Tcjs = require('./chunk-QBZJ7P2T.cjs');
+
+
+var _chunk4IH4EL7Mcjs = require('./chunk-4IH4EL7M.cjs');
+
+// src/outbound-api/kindDetection.ts
+var _canonicalmodels = require('@omnicross/contracts/canonical-models');
+
+// src/outbound-api/roleDetection.ts
+
+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(_canonicalmodels.normalizeModelId.call(void 0, 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 = _optionalChain([options, 'optionalAccess', _ => _.backgroundModelIds]);
+    if (overrides && overrides.length > 0) {
+      const reqNorm = _canonicalmodels.normalizeModelId.call(void 0, requestedModel);
+      const inOverride = overrides.some((id) => {
+        if (!id) return false;
+        const candidate = id.includes(",") ? id.slice(id.indexOf(",") + 1) : id;
+        return _canonicalmodels.normalizeModelId.call(void 0, 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(_chunk4IH4EL7Mcjs.ENDPOINT_MODEL_KINDS, endpoint);
+}
+function modelKindsForEndpoint(endpoint) {
+  return _chunk4IH4EL7Mcjs.ENDPOINT_MODEL_KINDS[endpoint];
+}
+function detectModelKind(endpoint, requestedModelId) {
+  if (!requestedModelId || requestedModelId.trim() === "") return void 0;
+  if (endpoint === "messages") {
+    const declared = _chunk4IH4EL7Mcjs.ENDPOINT_MODEL_KINDS.messages;
+    for (const tok of modelTokens(_canonicalmodels.normalizeModelId.call(void 0, 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 = _nullishCoalesce(config.modelMap, () => ( {}));
+  return modelKindsForEndpoint(config.endpoint).filter(
+    (kind) => !isNonBlankRef(map[kind])
+  );
+}
+function validateServerModelConfig(config) {
+  const errors = [];
+  for (const endpoint of Object.keys(_chunk4IH4EL7Mcjs.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 = _optionalChain([targets, 'optionalAccess', _2 => _2[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 = _chunkQBZJ7P2Tcjs.getSubscriptionRegistryForOutbound.call(void 0, );
+  return _optionalChain([registry, 'optionalAccess', _3 => _3.getProfile, 'call', _4 => _4(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 = _nullishCoalesce(config.modelMap, () => ( {}));
+  const detected = detectModelKind(endpoint, requestedModel);
+  const kind = _nullishCoalesce(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 = _nullishCoalesce(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 = _optionalChain([resolvePrefixTarget, 'call', _5 => _5(config.prefixTargets, args.requestedModel), 'optionalAccess', _6 => _6.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, _nullishCoalesce(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: _nullishCoalesce(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 = _chunkQBZJ7P2Tcjs.getSubscriptionRegistryForOutbound.call(void 0, );
+  const profile = _nullishCoalesce(_optionalChain([registry, 'optionalAccess', _7 => _7.getProfile, 'call', _8 => _8(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: _nullishCoalesce(apiKeyId, () => ( null)) }
+  };
+  const subscriptionConfig = providerId === "opencodego" ? await _optionalChain([registry, 'optionalAccess', _9 => _9.getOpenCodeGoConfig, 'optionalCall', _10 => _10()]) : 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,
+    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;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.extractRequestedModel = extractRequestedModel; exports.detectRequestRole = detectRequestRole; exports.endpointToIngressFormat = endpointToIngressFormat; exports.isKindMappedEndpoint = isKindMappedEndpoint; exports.modelKindsForEndpoint = modelKindsForEndpoint; exports.detectModelKind = detectModelKind; exports.validateEndpointModelConfig = validateEndpointModelConfig; exports.validateServerModelConfig = validateServerModelConfig; exports.classifyModelPrefix = classifyModelPrefix; exports.resolvePrefixTarget = resolvePrefixTarget; exports.SUBSCRIPTION_PROVIDER_IDS = SUBSCRIPTION_PROVIDER_IDS; exports.isSubscriptionProviderId = isSubscriptionProviderId; exports.endpointSupportsSubscription = endpointSupportsSubscription; exports.parseModelRef = parseModelRef; exports.pickModelRefFromList = pickModelRefFromList; exports.resolveRoute = resolveRoute;

package/dist/chunk-TKJMZBAH.js

@@ -0,0 +1,32 @@
+// src/pipeline/billingEmit.ts
+var sink = null;
+var captureConfig = null;
+function setBillingSink(fn) {
+  sink = fn;
+}
+function setBillingCaptureConfig(config) {
+  captureConfig = config && config.enabled ? config : null;
+}
+function getBillingCaptureConfig() {
+  return captureConfig;
+}
+function publishBillingEvent(event) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(event);
+  } catch {
+  }
+}
+function __resetBillingSinkForTests() {
+  sink = null;
+  captureConfig = null;
+}
+
+export {
+  setBillingSink,
+  setBillingCaptureConfig,
+  getBillingCaptureConfig,
+  publishBillingEvent,
+  __resetBillingSinkForTests
+};

package/dist/{chunk-ZSVQT3PW.js → chunk-UBWEBKRC.js}

@@ -1,7 +1,9 @@
+import {
+  OPENROUTER_APP_HEADERS
+} from "./chunk-HUZZZ3JL.js";
+
 // src/completion/openrouter-headers.ts
 var OPENROUTER_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
-var OPENROUTER_HTTP_REFERER = "https://omnicross.dev";
-var OPENROUTER_X_TITLE = "Omnicross";
 function buildOpenRouterHeaders(credentials, options = {}) {
   const apiKey = credentials.apiKey?.trim();
   if (!apiKey) {
@@ -9,8 +11,7 @@ function buildOpenRouterHeaders(credentials, options = {}) {
   }
   const headers = {
     Authorization: `Bearer ${apiKey}`,
-    "HTTP-Referer": OPENROUTER_HTTP_REFERER,
-    "X-Title": OPENROUTER_X_TITLE
+    ...OPENROUTER_APP_HEADERS
   };
   if (options.contentType !== false) {
     headers["Content-Type"] = options.contentType ?? "application/json";
@@ -35,8 +36,6 @@ function buildOpenRouterUrl(endpoint, path) {
 
 export {
   OPENROUTER_DEFAULT_BASE_URL,
-  OPENROUTER_HTTP_REFERER,
-  OPENROUTER_X_TITLE,
   buildOpenRouterHeaders,
   resolveOpenRouterBaseUrl,
   buildOpenRouterUrl