@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-CDHS2QDC.js

@@ -0,0 +1,179 @@
+// src/completion/BuiltinToolExecutor.ts
+var DEFAULT_SEARCH_COUNT = 5;
+var DEFAULT_FETCH_MAX_CHARS = 2e4;
+var FALLBACK_ORDER = [
+  "tavily",
+  "jina",
+  "searxng",
+  "zhipu",
+  "z.ai",
+  "bocha",
+  "grok",
+  "local-google",
+  "local-bing",
+  "local-baidu",
+  "local-duckduckgo"
+];
+var IMPLICIT_LOCAL_FALLBACK = "local-google";
+var WEB_SEARCH_TOOL = {
+  id: "builtin__web_search",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_search",
+  description: "Search the web for current information. Returns a list of results with title, URL, and snippet. Use web_fetch afterwards to get full page content if snippets are insufficient.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query." },
+      count: { type: "integer", description: "Maximum number of results (1-10).", default: DEFAULT_SEARCH_COUNT }
+    },
+    required: ["query"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var WEB_FETCH_TOOL = {
+  id: "builtin__web_fetch",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_fetch",
+  description: "Fetch and extract the main content of a web page as clean Markdown. Use this to read the full content of a URL found via web_search.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "The URL to fetch (http or https)." },
+      maxChars: { type: "integer", description: "Maximum characters to return.", default: DEFAULT_FETCH_MAX_CHARS }
+    },
+    required: ["url"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var BuiltinToolExecutor = class {
+  constructor(webSearch) {
+    this.webSearch = webSearch;
+  }
+  webSearch;
+  async execute(toolName, args) {
+    switch (toolName) {
+      case "web_search":
+        return this.executeWebSearch(args);
+      case "web_fetch":
+        return this.executeWebFetch(args);
+      default:
+        return { isError: true, content: [{ type: "text", text: `Unknown built-in tool: ${toolName}` }] };
+    }
+  }
+  // -----------------------------------------------------------------------
+  // web_search
+  // -----------------------------------------------------------------------
+  async executeWebSearch(args) {
+    const query = String(args.query ?? "").trim();
+    if (!query) {
+      return { isError: true, content: [{ type: "text", text: "Error: query parameter is required." }] };
+    }
+    const count = Math.min(Math.max(Number(args.count ?? DEFAULT_SEARCH_COUNT), 1), 10);
+    const chain = this.resolveProviderChain();
+    let lastError = "";
+    for (const providerId of chain) {
+      try {
+        const result = await this.webSearch.search(query, providerId, { maxResults: count });
+        if (!result.success) {
+          lastError = result.error || "Unknown error";
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} failed: ${lastError}, trying next...`);
+          continue;
+        }
+        const items = result.results.slice(0, count);
+        if (items.length === 0) {
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} returned 0 results, trying next...`);
+          continue;
+        }
+        const text = items.map((r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}
+   ${r.content || ""}`).join("\n\n");
+        return { isError: false, content: [{ type: "text", text }] };
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+        console.log(`[BuiltinToolExecutor] Search provider ${providerId} threw: ${lastError}, trying next...`);
+        continue;
+      }
+    }
+    return {
+      isError: false,
+      content: [{ type: "text", text: lastError ? `Search failed after trying ${chain.length} provider(s). Last error: ${lastError}` : `No results found for "${query}" after trying ${chain.length} provider(s). Try rephrasing your search.` }]
+    };
+  }
+  resolveProviderChain() {
+    const chain = [];
+    for (const id of FALLBACK_ORDER) {
+      if (this.webSearch.isProviderEnabled(id)) {
+        chain.push(id);
+      }
+    }
+    if (!chain.includes(IMPLICIT_LOCAL_FALLBACK)) {
+      chain.push(IMPLICIT_LOCAL_FALLBACK);
+    }
+    return chain;
+  }
+  // -----------------------------------------------------------------------
+  // web_fetch
+  // -----------------------------------------------------------------------
+  async executeWebFetch(args) {
+    const url = String(args.url ?? "").trim();
+    if (!url) {
+      return { isError: true, content: [{ type: "text", text: "Error: url parameter is required." }] };
+    }
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return { isError: true, content: [{ type: "text", text: "Error: only http and https URLs are supported." }] };
+      }
+    } catch {
+      return { isError: true, content: [{ type: "text", text: `Error: invalid URL "${url}".` }] };
+    }
+    const maxChars = Number(args.maxChars ?? DEFAULT_FETCH_MAX_CHARS);
+    try {
+      const jinaResult = await this.webSearch.readUrl(url, { timeout: 15e3 });
+      if (jinaResult.success && jinaResult.content) {
+        const content = jinaResult.content.length > maxChars ? jinaResult.content.slice(0, maxChars) + "\n\n[Content truncated]" : jinaResult.content;
+        const header = jinaResult.title ? `# ${jinaResult.title}
+
+` : "";
+        return { isError: false, content: [{ type: "text", text: header + content }] };
+      }
+      const { fetchAndExtractUrl } = await import("./builtin-web-fetch-IGLBX2XY.js");
+      const text = await fetchAndExtractUrl(url, maxChars);
+      return { isError: false, content: [{ type: "text", text }] };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { isError: true, content: [{ type: "text", text: `Fetch error: ${message}` }] };
+    }
+  }
+};
+function getBuiltinSearchTools() {
+  return [WEB_SEARCH_TOOL, WEB_FETCH_TOOL];
+}
+function convertBuiltinToolsToOpenAI(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.id,
+      description: t.description || t.name,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function convertBuiltinToolsToAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.id,
+    description: t.description || t.name,
+    input_schema: t.inputSchema
+  }));
+}
+
+export {
+  BuiltinToolExecutor,
+  getBuiltinSearchTools,
+  convertBuiltinToolsToOpenAI,
+  convertBuiltinToolsToAnthropic
+};

package/dist/chunk-CWM2ZDU5.js

@@ -0,0 +1,130 @@
+// src/pipeline/auditUsageStash.ts
+var stash = /* @__PURE__ */ new WeakMap();
+function stashAuditUsage(key, detail) {
+  const existing = stash.get(key);
+  stash.set(key, existing ? { ...existing, ...detail } : { ...detail });
+}
+function readAuditUsage(key) {
+  return stash.get(key);
+}
+
+// src/usage/usage-recorder.ts
+var UsageRecorder = class {
+  constructor(store, pricing, logger, options = {}) {
+    this.store = store;
+    this.pricing = pricing;
+    this.logger = logger;
+    this.defer = options.defer ?? ((fn) => setTimeout(fn, 0));
+    this.onRecord = options.onRecord;
+  }
+  store;
+  pricing;
+  logger;
+  defer;
+  onRecord;
+  /**
+   * Record one LLM request. Returns immediately — the actual store insert is
+   * deferred so the caller's response path is unblocked.
+   *
+   * Errors during the insert are logged but never thrown.
+   */
+  record(input) {
+    if (input.auditResponse) {
+      stashAuditUsage(input.auditResponse, {
+        inputTokens: input.usage.inputTokens,
+        outputTokens: input.usage.outputTokens,
+        model: input.model,
+        provider: input.providerId
+      });
+    }
+    this.defer(() => {
+      void this.recordAsync(input).catch((err) => {
+        this.logger.warn("[UsageRecorder] failed to persist usage event", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    });
+  }
+  /**
+   * Same as `record()` but awaitable — preferred in tests so they can assert
+   * after the row exists.
+   */
+  async recordAsync(input) {
+    const { costUsd, costSavedByCacheUsd } = await this.pricing.calculateCost(
+      input.providerId,
+      input.model,
+      input.usage
+    );
+    if (input.auditResponse) {
+      try {
+        stashAuditUsage(input.auditResponse, { costUsd });
+      } catch {
+      }
+    }
+    if (this.onRecord && input.apiKeyId) {
+      try {
+        this.onRecord(input.apiKeyId, costUsd, Date.now());
+      } catch {
+      }
+    }
+    const row = {
+      messageId: input.messageId ?? null,
+      parentMessageId: input.parentMessageId ?? null,
+      sessionId: input.sessionId ?? null,
+      providerId: input.providerId,
+      model: input.model,
+      apiKeyId: input.apiKeyId ?? null,
+      engineOrigin: input.engineOrigin,
+      inputTokens: input.usage.inputTokens,
+      outputTokens: input.usage.outputTokens,
+      cacheReadTokens: input.usage.cacheReadTokens,
+      cacheCreationTokens: input.usage.cacheCreationTokens,
+      reasoningTokens: input.usage.reasoningTokens,
+      costUsd,
+      costSavedByCacheUsd,
+      rawUsage: input.rawUsage != null ? safeStringify(input.rawUsage) : null,
+      runId: input.runId ?? null,
+      eventId: input.eventId ?? null
+    };
+    try {
+      return await this.store.insert(row);
+    } catch (err) {
+      this.logger.warn("[UsageRecorder] store insert failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  // ===== Query delegates =====
+  getTotals(range) {
+    return this.store.getTotals(range);
+  }
+  getByModel(range) {
+    return this.store.getByModel(range);
+  }
+  getByApiKey(range) {
+    return this.store.getByApiKey(range);
+  }
+  getTimeSeries(range, bucket) {
+    return this.store.getTimeSeries(range, bucket);
+  }
+  getMessagesForSession(sessionId) {
+    return this.store.getMessagesForSession(sessionId);
+  }
+  /** Cumulative cache hit/miss stats for one session. */
+  getSessionCacheStats(sessionId) {
+    return this.store.getSessionCacheStats(sessionId);
+  }
+};
+var safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+};
+
+export {
+  readAuditUsage,
+  UsageRecorder
+};

package/dist/chunk-CZHZGRU7.js

@@ -0,0 +1,383 @@
+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,
+    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
+};