@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-6VIXXLMX.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/openrouter.ts
+function isOpenRouterProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("openrouter.ai");
+}
+var OPENROUTER_APP_HEADERS = {
+  "HTTP-Referer": "https://omnicross.dev",
+  "X-Title": "omnicross"
+};
+
+
+
+
+exports.isOpenRouterProvider = isOpenRouterProvider; exports.OPENROUTER_APP_HEADERS = OPENROUTER_APP_HEADERS;

package/dist/chunk-745DV5FL.js

@@ -0,0 +1,147 @@
+import {
+  isOpenRouterProvider
+} from "./chunk-E3WHL7CO.js";
+import {
+  API_FORMAT_PROVIDER_MAP,
+  NATIVE_SEARCH_EXCLUDED_MODELS,
+  NATIVE_SEARCH_MODEL_PATTERNS,
+  OPENAI_CHAT_COMPLETION_SEARCH_MODELS
+} from "./chunk-FMOBD2OQ.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
+};

package/dist/chunk-74TMJA7Z.js

@@ -0,0 +1,53 @@
+import {
+  serializeError
+} from "./chunk-AVYJ4YBN.js";
+
+// 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;
+  }
+  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
+      });
+    } catch (err) {
+      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", serializeError(err));
+    }
+  }
+  /** Delegate the 401-refresh decision to the bound strategy. */
+  async onUnauthorized() {
+    return this.profile.authStrategy.onUnauthorized();
+  }
+  /** Resolve the upstream URL from the profile, when it provides one. */
+  resolveUpstreamUrl(model) {
+    return this.profile.resolveUpstreamUrl?.(model);
+  }
+};
+
+export {
+  stripAuthHeaders,
+  SubscriptionAuthSource
+};

package/dist/chunk-7YN22L2H.cjs

@@ -0,0 +1,87 @@
+"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 _chunkYGXJGRFIcjs = require('./chunk-YGXJGRFI.cjs');
+
+// src/transformer/transformers/GeminiTransformer.ts
+var GeminiTransformer = (_class = class {
+  static __initStatic() {this.TransformerName = "gemini"}
+  __init() {this.name = "gemini"}
+  
+  /**
+   * API endpoint pattern for Gemini
+   * :modelAndAction will be replaced with actual model and action
+   */
+  __init2() {this.endPoint = "/v1beta/models/:modelAndAction"}
+  /** Use Bearer token instead of x-goog-api-key (for relay providers) */
+  
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.useBearer = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.UseBearer]), () => ( false));
+  }
+  /**
+   * Handle authentication
+   * - Official Gemini: x-goog-api-key header
+   * - Relay providers: Authorization: Bearer header
+   */
+  async auth(request, provider, _context) {
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["authorization"] = void 0;
+    }
+    return {
+      body: request,
+      config: { headers }
+    };
+  }
+  /**
+   * Transform request from unified format to Gemini format
+   * Also builds the correct URL for the Gemini API
+   */
+  async transformRequestIn(request, provider, _context) {
+    const body = _chunkYGXJGRFIcjs.buildRequestBody.call(void 0, request);
+    const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["Authorization"] = void 0;
+    }
+    return {
+      body,
+      config: { url, headers }
+    };
+  }
+  /**
+   * Transform incoming request to unified format
+   * (For requests coming into the Gemini endpoint)
+   */
+  async transformRequestOut(request, _context) {
+    return _chunkYGXJGRFIcjs.transformRequestOut.call(void 0, request);
+  }
+  /**
+   * Transform Gemini response to OpenAI-compatible format
+   */
+  async transformResponseOut(response, _context) {
+    return _chunkYGXJGRFIcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
+  }
+  /**
+   * Transform OpenAI-compatible response back to Gemini format
+   * (For endpoint mode — returning Gemini-format responses to the client)
+   */
+  async transformResponseIn(response, _context) {
+    return _chunkYGXJGRFIcjs.transformResponseIn.call(void 0, response, this.logger);
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.GeminiTransformer = GeminiTransformer;

package/dist/chunk-A2YMUCBT.cjs

@@ -0,0 +1,105 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/completion/url-builder.ts
+var _endpointresolver = require('@omnicross/contracts/endpoint-resolver');
+function resolveApiFormat(provider) {
+  if (provider.apiFormat) {
+    return provider.apiFormat;
+  }
+  if (provider.chatApiFormat) {
+    return provider.chatApiFormat;
+  }
+  if (provider.apiType === "claudecode" || provider.apiType === "anthropic") {
+    return "anthropic";
+  }
+  if (provider.apiType === "google") {
+    return "google";
+  }
+  return "openai";
+}
+function buildOpenAIApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/chat/completions")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/chat/completions";
+  }
+  if (url.includes("/chat/completions")) {
+    return url;
+  }
+  return url + "/v1/chat/completions";
+}
+function buildAnthropicApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/messages")) {
+    return url;
+  }
+  if (url.includes("/messages")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/messages";
+  }
+  return url + "/v1/messages";
+}
+function buildGeminiModelActionUrl(baseUrl, model, action) {
+  let url = baseUrl.replace(/\/+$/, "");
+  if (url.includes("/models/")) {
+    return url;
+  }
+  if (!/\/v\d+(?:beta)?(?:$|\/)/.test(url)) {
+    url += "/v1beta";
+  }
+  return `${url}/models/${model}:${action}`;
+}
+function buildGeminiApiUrl(baseUrl, model, stream) {
+  const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  return buildGeminiModelActionUrl(baseUrl, model, action);
+}
+function normalizeAzureEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "").replace(/\/openai(\/v\d+)?$/, "");
+}
+function buildAzureOpenAIApiUrl(baseUrl, model, apiVersion) {
+  const endpoint = normalizeAzureEndpoint(baseUrl);
+  return `${endpoint}/openai/deployments/${model}/chat/completions?api-version=${apiVersion}`;
+}
+function buildOpenAIResponseApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/responses")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/responses";
+  }
+  return url + "/v1/responses";
+}
+var resolveProviderEndpoint = _endpointresolver.resolveProviderEndpoint;
+function buildProviderApiUrl(provider, options = {}) {
+  const format = resolveApiFormat(provider);
+  const { baseUrl } = resolveProviderEndpoint(provider);
+  switch (format) {
+    case "anthropic":
+      return buildAnthropicApiUrl(baseUrl);
+    case "google":
+      return buildGeminiApiUrl(baseUrl, options.model || "", options.stream || false);
+    case "azure-openai":
+      return buildAzureOpenAIApiUrl(baseUrl, options.model || "", provider.apiVersion || "2024-08-01-preview");
+    case "openai-response":
+      return buildOpenAIResponseApiUrl(baseUrl);
+    case "openai":
+    default:
+      return buildOpenAIApiUrl(baseUrl);
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.resolveApiFormat = resolveApiFormat; exports.buildOpenAIApiUrl = buildOpenAIApiUrl; exports.buildAnthropicApiUrl = buildAnthropicApiUrl; exports.buildGeminiModelActionUrl = buildGeminiModelActionUrl; exports.buildGeminiApiUrl = buildGeminiApiUrl; exports.normalizeAzureEndpoint = normalizeAzureEndpoint; exports.buildAzureOpenAIApiUrl = buildAzureOpenAIApiUrl; exports.buildOpenAIResponseApiUrl = buildOpenAIResponseApiUrl; exports.resolveProviderEndpoint = resolveProviderEndpoint; exports.buildProviderApiUrl = buildProviderApiUrl;

package/dist/chunk-AQ5TNQB7.js

@@ -0,0 +1,13 @@
+// src/outbound-api/subscriptionRegistryPort.ts
+var _registry = null;
+function setSubscriptionRegistryForOutbound(registry) {
+  _registry = registry;
+}
+function getSubscriptionRegistryForOutbound() {
+  return _registry;
+}
+
+export {
+  setSubscriptionRegistryForOutbound,
+  getSubscriptionRegistryForOutbound
+};

package/dist/chunk-AVYJ4YBN.js

@@ -0,0 +1,58 @@
+// 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 {
+    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;
+  };
+}
+
+export {
+  serializeError
+};

package/dist/chunk-C72S6TTV.cjs

@@ -0,0 +1,49 @@
+"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 _class;// src/transformer/transformers/OpenCodeGoTransformer.ts
+var OpenCodeGoTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "opencodego"}
+  __init() {this.name = "opencodego"}
+  __init2() {this.endPoint = "/v1/chat/completions"}
+  
+  async auth(request, _provider, _context) {
+    return { body: request, config: { headers: {} } };
+  }
+  /**
+   * Unified → OpenAI Chat Completions.
+   * Unified IS chat completions shape; this is mostly stripping `meta` and
+   * normalizing string-content single-block messages.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const messages = request.messages.map((m) => {
+      const content = m.content;
+      if (Array.isArray(content) && content.length === 1 && _optionalChain([content, 'access', _ => _[0], 'optionalAccess', _2 => _2.type]) === "text") {
+        return { ...m, content: content[0].text };
+      }
+      return m;
+    });
+    const out = {
+      model: request.model,
+      messages,
+      stream: request.stream
+    };
+    if (request.temperature !== void 0) out.temperature = request.temperature;
+    if (request.max_tokens !== void 0) out.max_tokens = request.max_tokens;
+    if (request.tools && request.tools.length > 0) out.tools = request.tools;
+    if (request.tool_choice !== void 0) out.tool_choice = request.tool_choice;
+    if (_optionalChain([request, 'access', _3 => _3.reasoning, 'optionalAccess', _4 => _4.effort]) && request.reasoning.effort !== "none") {
+      out.reasoning_effort = request.reasoning.effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions response → Unified.
+   * The upstream's response shape already matches Unified — pass through.
+   * The endpoint AnthropicTransformer re-encodes to Anthropic for the SDK.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.OpenCodeGoTransformer = OpenCodeGoTransformer;

package/dist/chunk-C7PSERMH.js

@@ -0,0 +1,87 @@
+import {
+  buildRequestBody,
+  transformRequestOut,
+  transformResponseIn,
+  transformResponseOut
+} from "./chunk-S4WBV25P.js";
+
+// src/transformer/transformers/GeminiTransformer.ts
+var GeminiTransformer = class {
+  static TransformerName = "gemini";
+  name = "gemini";
+  logger;
+  /**
+   * API endpoint pattern for Gemini
+   * :modelAndAction will be replaced with actual model and action
+   */
+  endPoint = "/v1beta/models/:modelAndAction";
+  /** Use Bearer token instead of x-goog-api-key (for relay providers) */
+  useBearer;
+  constructor(options) {
+    this.useBearer = options?.UseBearer ?? false;
+  }
+  /**
+   * Handle authentication
+   * - Official Gemini: x-goog-api-key header
+   * - Relay providers: Authorization: Bearer header
+   */
+  async auth(request, provider, _context) {
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["authorization"] = void 0;
+    }
+    return {
+      body: request,
+      config: { headers }
+    };
+  }
+  /**
+   * Transform request from unified format to Gemini format
+   * Also builds the correct URL for the Gemini API
+   */
+  async transformRequestIn(request, provider, _context) {
+    const body = buildRequestBody(request);
+    const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["Authorization"] = void 0;
+    }
+    return {
+      body,
+      config: { url, headers }
+    };
+  }
+  /**
+   * Transform incoming request to unified format
+   * (For requests coming into the Gemini endpoint)
+   */
+  async transformRequestOut(request, _context) {
+    return transformRequestOut(request);
+  }
+  /**
+   * Transform Gemini response to OpenAI-compatible format
+   */
+  async transformResponseOut(response, _context) {
+    return transformResponseOut(response, this.name, this.logger);
+  }
+  /**
+   * Transform OpenAI-compatible response back to Gemini format
+   * (For endpoint mode — returning Gemini-format responses to the client)
+   */
+  async transformResponseIn(response, _context) {
+    return transformResponseIn(response, this.logger);
+  }
+};
+
+export {
+  GeminiTransformer
+};