@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-FZ46M34D.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-G2FUJNA2.cjs

@@ -0,0 +1,193 @@
+"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');
+
+// 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', _ => _.getProfile, 'call', _2 => _2(providerId)]) != null;
+}
+var SUBSCRIPTION_SUPPORTED_ENDPOINTS = /* @__PURE__ */ new Set([
+  "messages",
+  "responses"
+]);
+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 };
+}
+function pickModelRefForRole(config, role) {
+  if (role === "vision") {
+    if (config.visionModel && config.visionModel.trim()) {
+      return { ref: config.visionModel, effectiveRole: "vision" };
+    }
+    return { ref: config.defaultModel, effectiveRole: "default" };
+  }
+  if (role === "background") {
+    return { ref: config.backgroundModel, effectiveRole: "background" };
+  }
+  return { ref: config.defaultModel, effectiveRole: "default" };
+}
+async function resolveRoute(args) {
+  const { config, role, ingressFormat, llmConfig } = args;
+  const sessionId = _nullishCoalesce(args.sessionId, () => ( null));
+  const { ref, effectiveRole } = pickModelRefForRole(config, role);
+  if (!ref || !ref.trim()) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `endpoint '${config.endpoint}' has no ${effectiveRole} model configured`
+      }
+    };
+  }
+  const parsed = parseModelRef(ref);
+  if (!parsed) {
+    return {
+      ok: false,
+      error: {
+        status: 503,
+        message: `endpoint '${config.endpoint}' ${effectiveRole} model ref is malformed: '${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
+      });
+    }
+    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: null }
+    };
+  }
+  const route = {
+    sessionId,
+    targetProviderFormat,
+    model: modelId,
+    ingressFormat,
+    authMode: "byo",
+    providerId,
+    anthropicSdkHints
+  };
+  return { ok: true, route, usedRole: effectiveRole };
+}
+async function resolveSubscriptionRoute(args) {
+  const { config, providerId, modelId, ingressFormat, sessionId, effectiveRole } = 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', _3 => _3.getProfile, 'call', _4 => _4(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: null }
+  };
+  const subscriptionConfig = providerId === "opencodego" ? await _optionalChain([registry, 'optionalAccess', _5 => _5.getOpenCodeGoConfig, 'optionalCall', _6 => _6()]) : void 0;
+  const route = {
+    sessionId,
+    targetProviderFormat: "transform",
+    model: modelId,
+    ingressFormat,
+    authMode: "subscription",
+    providerId,
+    // 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" ? 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.SUBSCRIPTION_PROVIDER_IDS = SUBSCRIPTION_PROVIDER_IDS; exports.isSubscriptionProviderId = isSubscriptionProviderId; exports.endpointSupportsSubscription = endpointSupportsSubscription; exports.parseModelRef = parseModelRef; exports.resolveRoute = resolveRoute;

package/dist/chunk-G2UTNSGU.js

@@ -0,0 +1,277 @@
+import {
+  injectExtendedContextBeta
+} from "./chunk-MZNPGW5Q.js";
+
+// src/transformer/TransformerChainExecutor.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[ChainExecutor] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[ChainExecutor] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[ChainExecutor] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[ChainExecutor] ${msg}`, ...args)
+};
+var TransformerChainExecutor = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? defaultLogger;
+  }
+  /**
+   * Execute the request transformation chain
+   *
+   * @param request - Original request body
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed request result
+   */
+  async executeRequestChain(request, provider, chain, options = {}) {
+    const { endpointTransformer, headers, extendedContext } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let requestBody = request;
+    let config = {};
+    let bypass = false;
+    bypass = this.shouldBypassTransformers(
+      chain,
+      endpointTransformer,
+      requestBody
+    );
+    if (bypass) {
+      if (headers) {
+        const cleanHeaders = this.cleanHeaders(headers);
+        config.headers = cleanHeaders;
+      }
+      this.logger.debug("Bypass mode enabled - skipping transformations");
+    }
+    if (!bypass && endpointTransformer?.transformRequestOut) {
+      this.logger.debug("Executing transformRequestOut");
+      try {
+        const transformOut = await endpointTransformer.transformRequestOut(requestBody, context);
+        if (transformOut && typeof transformOut === "object") {
+          if ("body" in transformOut) {
+            requestBody = transformOut.body;
+            config = transformOut.config ?? {};
+          } else {
+            requestBody = transformOut;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    if (!bypass && chain.providerTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
+      for (const transformer of chain.providerTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const transformIn = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            if (transformIn && typeof transformIn === "object") {
+              if ("body" in transformIn) {
+                requestBody = transformIn.body;
+                config = { ...config, ...transformIn.config };
+              } else {
+                requestBody = transformIn;
+              }
+            }
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (!bypass && chain.modelTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.modelTransformers.length} model transformers`);
+      for (const transformer of chain.modelTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const result = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            requestBody = result;
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (extendedContext?.enabled) {
+      if (!config.headers || typeof config.headers !== "object") {
+        config.headers = {};
+      }
+      injectExtendedContextBeta(
+        config.headers,
+        extendedContext.model,
+        true
+      );
+    }
+    return { requestBody, config, bypass };
+  }
+  /**
+   * Execute the response transformation chain
+   *
+   * @param request - Original request (for context)
+   * @param response - Response from provider
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed response
+   */
+  async executeResponseChain(request, response, provider, chain, options = {}) {
+    const { endpointTransformer } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let finalResponse = response;
+    const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);
+    if (bypass) {
+      this.logger.debug("Bypass mode - skipping response transformations");
+      return finalResponse;
+    }
+    if (chain.modelTransformers.length > 0) {
+      const reversedModelTransformers = [...chain.modelTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedModelTransformers.length} model response transformers (reversed)`
+      );
+      for (const transformer of reversedModelTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (chain.providerTransformers.length > 0) {
+      const reversedProviderTransformers = [...chain.providerTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedProviderTransformers.length} provider response transformers (reversed)`
+      );
+      for (const transformer of reversedProviderTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (endpointTransformer?.transformResponseIn) {
+      this.logger.debug("Executing transformResponseIn");
+      try {
+        finalResponse = await endpointTransformer.transformResponseIn(finalResponse, context);
+      } catch (error) {
+        this.logger.error(`transformResponseIn error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return finalResponse;
+  }
+  /**
+   * Execute authentication handler if available
+   *
+   * @param request - Request body
+   * @param provider - LLM provider
+   * @param endpointTransformer - Endpoint transformer with auth handler
+   * @param context - Transformer context
+   * @returns Auth result with potentially modified request and config
+   */
+  async executeAuth(request, provider, endpointTransformer, context) {
+    let requestBody = request;
+    let config = {};
+    if (endpointTransformer?.auth) {
+      this.logger.debug("Executing auth handler");
+      try {
+        const auth = await endpointTransformer.auth(requestBody, provider, context);
+        if (auth && typeof auth === "object") {
+          if ("body" in auth) {
+            requestBody = auth.body;
+            const authConfig = auth.config;
+            if (authConfig) {
+              const headers = { ...config.headers ?? {}, ...authConfig.headers ?? {} };
+              delete headers["host"];
+              config = { ...config, ...authConfig, headers };
+            }
+          } else {
+            requestBody = auth;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`Auth handler error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return { requestBody, config };
+  }
+  /**
+   * Check if transformers should be bypassed (optimization)
+   *
+   * Bypass is enabled when:
+   * - Provider has only one transformer that matches the endpoint transformer
+   * - Model has no specific transformers or only the same endpoint transformer
+   */
+  shouldBypassTransformers(chain, endpointTransformer, _request) {
+    if (!endpointTransformer?.name) {
+      return false;
+    }
+    const providerHasOnlyEndpoint = chain.providerTransformers.length === 1 && chain.providerTransformers[0]?.name === endpointTransformer.name;
+    const modelHasNoTransformers = chain.modelTransformers.length === 0;
+    const modelHasOnlyEndpoint = chain.modelTransformers.length === 1 && chain.modelTransformers[0]?.name === endpointTransformer.name;
+    return providerHasOnlyEndpoint && (modelHasNoTransformers || modelHasOnlyEndpoint);
+  }
+  /**
+   * Clean headers for pass-through
+   */
+  cleanHeaders(headers) {
+    const result = {};
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      });
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get error message from unknown error
+   */
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+};
+
+export {
+  TransformerChainExecutor
+};

package/dist/chunk-GBHYAGX3.cjs

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/transformer/anthropicBetaInject.ts
+var _extendedcontext = require('@omnicross/contracts/extended-context');
+var EXTENDED_CONTEXT_BETA = "context-1m-2025-08-07";
+var ANTHROPIC_BETA_HEADER = "anthropic-beta";
+function injectExtendedContextBeta(headers, model, useExtendedContext) {
+  if (!useExtendedContext) return;
+  if (!_extendedcontext.isExtendedContextCapable.call(void 0, model)) return;
+  let existingValue = "";
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === ANTHROPIC_BETA_HEADER) {
+      const v = headers[key];
+      if (typeof v === "string") existingValue = v;
+      if (key !== ANTHROPIC_BETA_HEADER) delete headers[key];
+    }
+  }
+  const parts = existingValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (!parts.includes(EXTENDED_CONTEXT_BETA)) {
+    parts.push(EXTENDED_CONTEXT_BETA);
+  }
+  headers[ANTHROPIC_BETA_HEADER] = parts.join(",");
+}
+
+
+
+
+exports.EXTENDED_CONTEXT_BETA = EXTENDED_CONTEXT_BETA; exports.injectExtendedContextBeta = injectExtendedContextBeta;

package/dist/chunk-GMMT7RVN.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/completion/native-search-types.ts
+var NATIVE_SEARCH_MODEL_PATTERNS = {
+  openai: [/^gpt-4/, /^o[134]/, /^gpt-5/],
+  // Claude 3.x: claude-3-opus-*, claude-3-5-sonnet-*, etc.
+  // Claude 4.x: claude-sonnet-4-*, claude-opus-4-*, claude-haiku-4-*, etc.
+  anthropic: [/^claude-/],
+  google: [/^gemini-(?:2|3|flash|pro)/],
+  xai: [/^grok/],
+  openrouter: []
+  // Detected via provider, not model pattern
+};
+var OPENAI_CHAT_COMPLETION_SEARCH_MODELS = [
+  "gpt-4o-search-preview",
+  "gpt-4o-mini-search-preview",
+  "gpt-5-search-api"
+];
+var NATIVE_SEARCH_EXCLUDED_MODELS = [
+  "gpt-4.1-nano"
+];
+var NATIVE_SEARCH_TOOL_NAMES = [
+  "web_search",
+  "web_search_20250305",
+  "web_search_20260209",
+  "google_search",
+  "googleSearchRetrieval"
+];
+var API_FORMAT_PROVIDER_MAP = {
+  "openai-response": "openai",
+  anthropic: "anthropic",
+  google: "google"
+};
+
+
+
+
+
+
+
+exports.NATIVE_SEARCH_MODEL_PATTERNS = NATIVE_SEARCH_MODEL_PATTERNS; exports.OPENAI_CHAT_COMPLETION_SEARCH_MODELS = OPENAI_CHAT_COMPLETION_SEARCH_MODELS; exports.NATIVE_SEARCH_EXCLUDED_MODELS = NATIVE_SEARCH_EXCLUDED_MODELS; exports.NATIVE_SEARCH_TOOL_NAMES = NATIVE_SEARCH_TOOL_NAMES; exports.API_FORMAT_PROVIDER_MAP = API_FORMAT_PROVIDER_MAP;

package/dist/chunk-H5JUT3KV.js

@@ -0,0 +1,105 @@
+// src/completion/url-builder.ts
+import { resolveProviderEndpoint as resolveProviderEndpointShared } from "@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 = resolveProviderEndpointShared;
+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);
+  }
+}
+
+export {
+  resolveApiFormat,
+  buildOpenAIApiUrl,
+  buildAnthropicApiUrl,
+  buildGeminiModelActionUrl,
+  buildGeminiApiUrl,
+  normalizeAzureEndpoint,
+  buildAzureOpenAIApiUrl,
+  buildOpenAIResponseApiUrl,
+  resolveProviderEndpoint,
+  buildProviderApiUrl
+};