@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-XX6NQJMA.js

@@ -0,0 +1,92 @@
+// src/provider-proxy/identity/fingerprintHeaders.ts
+var STAINLESS_PREFIX = "x-stainless-";
+var FINGERPRINT_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "user-agent",
+  "anthropic-beta",
+  "anthropic-version",
+  "anthropic-dangerous-direct-browser-access",
+  "x-app"
+]);
+var EXCLUDED_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-api-key",
+  "cookie",
+  "proxy-authorization",
+  "set-cookie"
+]);
+var PROTECTED_OUTBOUND = /* @__PURE__ */ new Set(["authorization", "content-type"]);
+function isStainless(name) {
+  return name.toLowerCase().startsWith(STAINLESS_PREFIX);
+}
+function extractFingerprintHeaders(reqHeaders) {
+  const out = {};
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    if (rawVal === void 0) continue;
+    const key = rawKey.toLowerCase();
+    if (EXCLUDED_HEADER_NAMES.has(key)) continue;
+    const whitelisted = FINGERPRINT_HEADER_NAMES.has(key) || key.startsWith(STAINLESS_PREFIX);
+    if (!whitelisted) continue;
+    const value = Array.isArray(rawVal) ? rawVal.filter((v) => typeof v === "string").join(", ") : rawVal;
+    if (typeof value === "string" && value.length > 0) out[key] = value;
+  }
+  return out;
+}
+function captureCallerIdentity(store, reqHeaders) {
+  if (!store.isEnabled()) return void 0;
+  return extractFingerprintHeaders(reqHeaders);
+}
+function sanitizeFrozenHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (typeof v !== "string" || v.length === 0) continue;
+    const lower = k.toLowerCase();
+    if (EXCLUDED_HEADER_NAMES.has(lower) || PROTECTED_OUTBOUND.has(lower)) continue;
+    out[lower] = v;
+  }
+  return out;
+}
+function refreshNonStainless(frozen, incoming) {
+  const out = {};
+  for (const [k, v] of Object.entries(frozen)) {
+    if (isStainless(k)) out[k] = v;
+  }
+  const nonStainlessKeys = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(frozen)) if (!isStainless(k)) nonStainlessKeys.add(k);
+  for (const k of Object.keys(incoming)) if (!isStainless(k)) nonStainlessKeys.add(k);
+  for (const k of nonStainlessKeys) {
+    const v = incoming[k] ?? frozen[k];
+    if (typeof v === "string" && v.length > 0) out[k] = v;
+  }
+  return out;
+}
+function mergeFrozenIdentity(headers, identity) {
+  const present = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+  for (const [k, v] of Object.entries(identity)) {
+    const lower = k.toLowerCase();
+    if (PROTECTED_OUTBOUND.has(lower)) continue;
+    if (present.has(lower)) continue;
+    headers[k] = v;
+  }
+}
+function applyFingerprint(store, headers, providerId, accountId, callerIdentity, now) {
+  if (!store.isEnabled() || !accountId) return;
+  if (callerIdentity) store.capture(providerId, accountId, callerIdentity, now);
+  const identity = store.replay(providerId, accountId);
+  if (identity) {
+    mergeFrozenIdentity(headers, identity);
+    return;
+  }
+  const ua = store.uaBaseline();
+  if (ua) mergeFrozenIdentity(headers, { "user-agent": ua });
+}
+
+export {
+  STAINLESS_PREFIX,
+  isStainless,
+  extractFingerprintHeaders,
+  captureCallerIdentity,
+  sanitizeFrozenHeaders,
+  refreshNonStainless,
+  mergeFrozenIdentity,
+  applyFingerprint
+};

package/dist/chunk-Y6OM7EV7.cjs

@@ -0,0 +1,56 @@
+"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; }
+
+var _chunkSVNDB62Dcjs = require('./chunk-SVNDB62D.cjs');
+
+// src/pipeline/SubscriptionAuthSource.ts
+function stripAuthHeaders(headers) {
+  delete headers.authorization;
+  delete headers.Authorization;
+  delete headers["x-api-key"];
+  delete headers["X-Api-Key"];
+  delete headers["x-goog-api-key"];
+  delete headers["X-Goog-Api-Key"];
+}
+var SubscriptionAuthSource = class {
+  constructor(profile) {
+    this.profile = profile;
+  }
+  
+  /**
+   * Strip any transformer-set auth headers, then delegate to the bound
+   * strategy. Mirrors `SubscriptionDispatcher`'s
+   * `stripAuthHeaders(...)` + `applyHeadersWithRetry(...)` sequence, including
+   * the best-effort swallow-and-warn around a throwing `applyHeaders`.
+   *
+   * The strategy's looser `AuthApplyHints` (optional `upstreamUrl` /
+   * `resolvedModel`) is fed from the pipeline's required `{ upstreamUrl,
+   * model }` at the boundary.
+   */
+  async applyHeaders(headers, hints) {
+    stripAuthHeaders(headers);
+    try {
+      await this.profile.authStrategy.applyHeaders(headers, {
+        upstreamUrl: hints.upstreamUrl,
+        resolvedModel: hints.model,
+        sessionKey: hints.sessionKey,
+        reportSelection: hints.reportSelection
+      });
+    } catch (err) {
+      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", _chunkSVNDB62Dcjs.serializeError.call(void 0, err));
+    }
+  }
+  /** Delegate the 401-refresh decision to the bound strategy, threading the
+   *  session key so the account actually served is the one refreshed (D7). */
+  async onUnauthorized(sessionKey) {
+    return this.profile.authStrategy.onUnauthorized(sessionKey);
+  }
+  /** Resolve the upstream URL from the profile, when it provides one. */
+  resolveUpstreamUrl(model) {
+    return _optionalChain([this, 'access', _ => _.profile, 'access', _2 => _2.resolveUpstreamUrl, 'optionalCall', _3 => _3(model)]);
+  }
+};
+
+
+
+
+exports.stripAuthHeaders = stripAuthHeaders; exports.SubscriptionAuthSource = SubscriptionAuthSource;

package/dist/chunk-Y7FO65VT.js

@@ -0,0 +1,147 @@
+import {
+  API_FORMAT_PROVIDER_MAP,
+  NATIVE_SEARCH_EXCLUDED_MODELS,
+  NATIVE_SEARCH_MODEL_PATTERNS,
+  OPENAI_CHAT_COMPLETION_SEARCH_MODELS
+} from "./chunk-FMOBD2OQ.js";
+import {
+  isOpenRouterProvider
+} from "./chunk-HUZZZ3JL.js";
+
+// src/completion/NativeSearchInjector.ts
+function detectNativeSearch(modelId, apiFormat, provider, userExplicit) {
+  if (isOpenRouterProvider(provider)) {
+    return { supported: true, nativeProvider: "openrouter" };
+  }
+  if (isXaiProvider(provider)) {
+    return { supported: true, nativeProvider: "xai" };
+  }
+  if (apiFormat === "openai" && OPENAI_CHAT_COMPLETION_SEARCH_MODELS.some((m) => modelId.startsWith(m))) {
+    return { supported: true, nativeProvider: "openai" };
+  }
+  const formatProvider = API_FORMAT_PROVIDER_MAP[apiFormat];
+  if (formatProvider) {
+    const patterns = NATIVE_SEARCH_MODEL_PATTERNS[formatProvider];
+    if (patterns.some((re) => re.test(modelId))) {
+      if (!NATIVE_SEARCH_EXCLUDED_MODELS.some((m) => modelId.startsWith(m))) {
+        return { supported: true, nativeProvider: formatProvider };
+      }
+    }
+  }
+  if (userExplicit && formatProvider) {
+    return { supported: true, nativeProvider: formatProvider };
+  }
+  return { supported: false, nativeProvider: null };
+}
+function buildNativeSearchAugmentation(nativeProvider, config, _apiFormat, modelId) {
+  if (!config.enabled) return null;
+  switch (nativeProvider) {
+    case "openai":
+      return buildOpenAIAugmentation(config, modelId);
+    case "anthropic":
+      return buildAnthropicAugmentation(config);
+    case "google":
+      return buildGoogleAugmentation(modelId);
+    case "xai":
+      return buildXaiAugmentation(config);
+    case "openrouter":
+      return buildOpenRouterAugmentation(config);
+    default:
+      return null;
+  }
+}
+function applyAugmentation(requestBody, augmentation) {
+  if (augmentation.additionalTools?.length) {
+    const existing = requestBody.tools ?? [];
+    requestBody.tools = [...existing, ...augmentation.additionalTools];
+  }
+  if (augmentation.bodyFields) {
+    Object.assign(requestBody, augmentation.bodyFields);
+  }
+  return requestBody;
+}
+function buildOpenAIAugmentation(config, modelId) {
+  const isChatCompletionSearch = OPENAI_CHAT_COMPLETION_SEARCH_MODELS.some(
+    (m) => modelId.startsWith(m)
+  );
+  if (isChatCompletionSearch) {
+    return {
+      bodyFields: {
+        web_search_options: {
+          search_context_size: config.maxResults ? mapMaxResultsToContextSize(config.maxResults) : "medium"
+        }
+      }
+    };
+  }
+  return {
+    additionalTools: [
+      {
+        type: "web_search",
+        web_search: {
+          search_context_size: config.maxResults ? mapMaxResultsToContextSize(config.maxResults) : "medium"
+        }
+      }
+    ]
+  };
+}
+function buildAnthropicAugmentation(config) {
+  const toolDef = {
+    type: "web_search_20250305",
+    name: "web_search"
+  };
+  if (config.maxResults) {
+    toolDef.max_uses = config.maxResults;
+  }
+  if (config.blockedDomains?.length) {
+    toolDef.blocked_domains = config.blockedDomains;
+  }
+  return { additionalTools: [toolDef] };
+}
+function buildGoogleAugmentation(modelId) {
+  const isLegacy = /gemini-1[._]/.test(modelId);
+  if (isLegacy) {
+    return {
+      additionalTools: [
+        { googleSearchRetrieval: {} }
+      ]
+    };
+  }
+  return {
+    additionalTools: [
+      { google_search: {} }
+    ]
+  };
+}
+function buildXaiAugmentation(config) {
+  const searchParams = {
+    mode: config.searchMode ?? "auto",
+    return_citations: true,
+    max_search_results: config.maxResults ?? 5
+  };
+  if (config.sources?.length) {
+    searchParams.sources = config.sources;
+  }
+  return { bodyFields: { search_parameters: searchParams } };
+}
+function buildOpenRouterAugmentation(config) {
+  const plugin = { id: "web" };
+  if (config.maxResults) {
+    plugin.max_results = config.maxResults;
+  }
+  return { bodyFields: { plugins: [plugin] } };
+}
+function isXaiProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("x.ai") || baseUrl.includes("xai.com");
+}
+function mapMaxResultsToContextSize(maxResults) {
+  if (maxResults <= 2) return "low";
+  if (maxResults <= 5) return "medium";
+  return "high";
+}
+
+export {
+  detectNativeSearch,
+  buildNativeSearchAugmentation,
+  applyAugmentation
+};