@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-SVNDB62D.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/serializeError.ts
+function serializeError(err) {
+  if (err == null) return "Unknown error (null)";
+  if (err instanceof Error) {
+    let msg = err.message || err.name || "Error";
+    if (err.cause) {
+      msg += ` [cause: ${serializeError(err.cause)}]`;
+    }
+    const anyErr = err;
+    if (anyErr.status != null) msg += ` (status: ${anyErr.status})`;
+    else if (anyErr.code != null) msg += ` (code: ${anyErr.code})`;
+    return msg;
+  }
+  if (typeof err === "string") return err || "Empty error string";
+  if (typeof err !== "object") return String(err);
+  const obj = err;
+  if (typeof obj.message === "string" && obj.message) {
+    let msg = obj.message;
+    if (obj.status != null) msg += ` (status: ${obj.status})`;
+    else if (obj.code != null) msg += ` (code: ${obj.code})`;
+    if (typeof obj.type === "string") msg += ` [type: ${obj.type}]`;
+    return msg;
+  }
+  if (typeof obj.error === "string" && obj.error) {
+    return obj.error;
+  }
+  if (obj.error && typeof obj.error === "object") {
+    const inner = obj.error;
+    if (typeof inner.message === "string" && inner.message) {
+      let msg = inner.message;
+      if (typeof inner.type === "string") msg += ` [type: ${inner.type}]`;
+      return msg;
+    }
+  }
+  try {
+    const json = JSON.stringify(err, getCircularReplacer(), 2);
+    if (json && json.length > 1e3) {
+      return json.slice(0, 1e3) + "... (truncated)";
+    }
+    return json || "Unserializable error";
+  } catch (e) {
+    return `Unserializable error: ${Object.prototype.toString.call(err)}`;
+  }
+}
+function getCircularReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+
+
+
+exports.serializeError = serializeError;

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-UBWEBKRC.js

@@ -0,0 +1,42 @@
+import {
+  OPENROUTER_APP_HEADERS
+} from "./chunk-HUZZZ3JL.js";
+
+// src/completion/openrouter-headers.ts
+var OPENROUTER_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+function buildOpenRouterHeaders(credentials, options = {}) {
+  const apiKey = credentials.apiKey?.trim();
+  if (!apiKey) {
+    throw new Error("OpenRouter API key is required");
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    ...OPENROUTER_APP_HEADERS
+  };
+  if (options.contentType !== false) {
+    headers["Content-Type"] = 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 = endpoint?.trim();
+  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}`;
+}
+
+export {
+  OPENROUTER_DEFAULT_BASE_URL,
+  buildOpenRouterHeaders,
+  resolveOpenRouterBaseUrl,
+  buildOpenRouterUrl
+};

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;