mcp-use 2.0.0-beta.35 → 2.0.0-beta.37

package/dist/chunk-QKJJ6DWK.js

@@ -1,184 +0,0 @@
-import {
-  getOAuthProviderOptions,
-  wrapOAuthTokenVerifier
-} from "./chunk-YF5X7FYF.js";
-
-// src/oauth/index.ts
-import {
-  OAuthError,
-  OAuthErrorCode,
-  bearerAuthChallengeResponse,
-  getOAuthProtectedResourceMetadataUrl as getOAuthProtectedResourceMetadataUrl2,
-  oauthMetadataResponse as oauthMetadataResponse2,
-  requireBearerAuth as requireBearerAuth2,
-  verifyBearerToken
-} from "@modelcontextprotocol/server";
-
-// src/oauth/adapters.ts
-import {
-  getOAuthProtectedResourceMetadataUrl,
-  oauthMetadataResponse,
-  requireBearerAuth
-} from "@modelcontextprotocol/server";
-
-// src/fetch-app.ts
-import {
-  hostHeaderValidationResponse,
-  originValidationResponse
-} from "@modelcontextprotocol/server";
-var requestBags = /* @__PURE__ */ new WeakMap();
-function getRequestBag(request) {
-  let bag = requestBags.get(request);
-  if (bag === void 0) {
-    bag = {};
-    requestBags.set(request, bag);
-  }
-  return bag;
-}
-function composeFetch(terminal, ...middlewares) {
-  return async (request) => {
-    let index = 0;
-    const dispatch = async () => {
-      if (index < middlewares.length) {
-        const middleware = middlewares[index];
-        index += 1;
-        return middleware(request, dispatch);
-      }
-      return terminal(request);
-    };
-    return dispatch();
-  };
-}
-function pathnameOf(request) {
-  return new URL(request.url).pathname;
-}
-function matchesPath(request, path) {
-  return pathnameOf(request) === path;
-}
-function matchesPathPrefix(request, prefix) {
-  const pathname = pathnameOf(request);
-  return pathname === prefix || pathname.startsWith(`${prefix}/`);
-}
-function pathUnderBase(basePath, childPath) {
-  const child = childPath.replace(/^\/+/, "");
-  return basePath === "/" ? `/${child}` : `${basePath}/${child}`;
-}
-function isHtmlNavigationRequest(request) {
-  if (request.method !== "GET" && request.method !== "HEAD") {
-    return false;
-  }
-  const accept = request.headers.get("accept");
-  if (accept === null) {
-    return false;
-  }
-  return accept.split(",").some((range) => {
-    const [mediaType, ...parameters] = range.split(";");
-    if (mediaType?.trim().toLowerCase() !== "text/html") {
-      return false;
-    }
-    return !parameters.some((parameter) => {
-      const [name, value] = parameter.trim().toLowerCase().split("=");
-      return name === "q" && Number(value) === 0;
-    });
-  });
-}
-function jsonBodyMiddleware() {
-  return async (request, next) => {
-    const bag = getRequestBag(request);
-    if (bag.parsedBody !== void 0) {
-      return next();
-    }
-    if (!(request.headers.get("content-type") ?? "").includes("application/json")) {
-      return next();
-    }
-    try {
-      bag.parsedBody = await request.clone().json();
-    } catch {
-      return new Response("Invalid JSON", { status: 400 });
-    }
-    return next();
-  };
-}
-function hostValidationMiddleware(hosts) {
-  return async (request, next) => {
-    const rejected = hostHeaderValidationResponse(request, hosts);
-    return rejected ?? next();
-  };
-}
-function originValidationMiddleware(origins, skipSafeMethods = true) {
-  return async (request, next) => {
-    if (skipSafeMethods && (request.method === "GET" || request.method === "HEAD")) {
-      return next();
-    }
-    const rejected = originValidationResponse(request, origins);
-    return rejected ?? next();
-  };
-}
-
-// src/oauth/adapters.ts
-function bearerAuth(provider, resource) {
-  const options = getOAuthProviderOptions(provider);
-  const gate = requireBearerAuth({
-    verifier: wrapOAuthTokenVerifier(provider, resource),
-    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource),
-    ...options.requiredScopes !== void 0 && {
-      requiredScopes: [...options.requiredScopes]
-    }
-  });
-  return async (request, next) => {
-    const result = await gate(request);
-    if (result instanceof Response) {
-      return result;
-    }
-    getRequestBag(request).authInfo = result;
-    return next();
-  };
-}
-function oauthMetadata(provider, resource) {
-  const options = getOAuthProviderOptions(provider);
-  return async (request, next) => {
-    const response = oauthMetadataResponse(request, {
-      oauthMetadata: options.oauthMetadata,
-      resourceServerUrl: resource,
-      ...options.scopesSupported !== void 0 && {
-        scopesSupported: [...options.scopesSupported]
-      },
-      ...options.resourceName !== void 0 && {
-        resourceName: options.resourceName
-      },
-      ...options.serviceDocumentationUrl !== void 0 && {
-        serviceDocumentationUrl: options.serviceDocumentationUrl
-      }
-    });
-    if (response !== void 0) {
-      return response;
-    }
-    return next();
-  };
-}
-function authInfoFromRequest(request) {
-  return getRequestBag(request).authInfo;
-}
-
-export {
-  getRequestBag,
-  composeFetch,
-  pathnameOf,
-  matchesPath,
-  matchesPathPrefix,
-  pathUnderBase,
-  isHtmlNavigationRequest,
-  jsonBodyMiddleware,
-  hostValidationMiddleware,
-  originValidationMiddleware,
-  bearerAuth,
-  oauthMetadata,
-  authInfoFromRequest,
-  OAuthError,
-  OAuthErrorCode,
-  bearerAuthChallengeResponse,
-  getOAuthProtectedResourceMetadataUrl2 as getOAuthProtectedResourceMetadataUrl,
-  oauthMetadataResponse2 as oauthMetadataResponse,
-  requireBearerAuth2 as requireBearerAuth,
-  verifyBearerToken
-};

package/dist/chunk-YF5X7FYF.js

@@ -1,517 +0,0 @@
-// src/oauth/guards.ts
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isLocalhost(url) {
-  const hostname = url.hostname.toLowerCase();
-  return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
-}
-function parseAbsoluteUrl(value, name) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error(`${name} must be an absolute URL`);
-  }
-  if (url.origin === "null" || url.username !== "" || url.password !== "") {
-    throw new Error(`${name} must be an absolute URL without credentials`);
-  }
-  return url;
-}
-function assertSecureHttpUrl(url, name) {
-  if (url.protocol === "https:") {
-    return;
-  }
-  if (url.protocol === "http:" && isLocalhost(url)) {
-    return;
-  }
-  throw new Error(`${name} must use HTTPS, or HTTP for localhost`);
-}
-
-// src/oauth/jwt.ts
-import {
-  OAuthError,
-  OAuthErrorCode
-} from "@modelcontextprotocol/server";
-import {
-  createRemoteJWKSet,
-  jwtVerify,
-  errors
-} from "jose";
-function createJwtVerifier(options) {
-  const key = options.key ?? createRemoteJWKSet(options.jwksUrl);
-  const configuredResource = canonicalUrl(options.resource);
-  return {
-    async verifyAccessToken(token) {
-      try {
-        const { payload } = await jwtVerify(token, key, {
-          issuer: options.issuer,
-          ...options.algorithms !== void 0 && {
-            algorithms: [...options.algorithms]
-          },
-          requiredClaims: ["exp", "sub"]
-        });
-        const claims = { ...payload };
-        const clientId = requiredString(claims, "client_id") ?? requiredString(claims, "azp");
-        const expiresAt = requiredFutureNumber(claims, "exp");
-        const resource = verifiedResource(claims, configuredResource);
-        return {
-          token,
-          clientId: clientId ?? "",
-          scopes: normalizedStrings(claims["scope"]),
-          expiresAt,
-          extra: { payload: claims },
-          resource
-        };
-      } catch (error) {
-        if (error instanceof OAuthError) {
-          throw error;
-        }
-        if (isCredentialFailure(error)) {
-          if (process.env["MCP_USE_OAUTH_DEBUG"]) {
-            logJwtFailure(token, error);
-          }
-          throw invalidToken("JWT verification failed", error);
-        }
-        throw error;
-      }
-    }
-  };
-}
-function normalizedProviderUrl(value, name) {
-  const raw = typeof value === "string" && !value.includes("://") ? `https://${value}` : value;
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    throw new TypeError(`${name} must be an absolute HTTP(S) URL`);
-  }
-  if (!isAllowedHttpUrl(url)) {
-    throw new TypeError(
-      `${name} must use HTTPS, or HTTP for localhost, without credentials, query, or fragment`
-    );
-  }
-  url.pathname = url.pathname.replace(/\/+$/, "") || "/";
-  return url;
-}
-function providerEndpoint(issuer, path) {
-  const base = new URL(issuer);
-  base.pathname = `${base.pathname.replace(/\/+$/, "")}/`;
-  return new URL(path.replace(/^\/+/, ""), base).href;
-}
-function payloadFromAuthInfo(authInfo) {
-  const payload = authInfo.extra?.["payload"];
-  if (!isRecord(payload)) {
-    throw invalidToken("Verified token payload is missing");
-  }
-  return payload;
-}
-function requiredString(claims, name) {
-  const value = claims[name];
-  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
-}
-function stringValue(claims, name) {
-  const value = claims[name];
-  return typeof value === "string" ? value : void 0;
-}
-function booleanValue(claims, name) {
-  const value = claims[name];
-  return typeof value === "boolean" ? value : void 0;
-}
-function numberValue(claims, name) {
-  const value = claims[name];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function recordValue(claims, name) {
-  const value = claims[name];
-  return isRecord(value) ? value : void 0;
-}
-function normalizedStrings(value) {
-  if (typeof value === "string") {
-    return value.split(/\s+/).filter(Boolean);
-  }
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.filter(
-    (item) => typeof item === "string" && item.length > 0
-  );
-}
-function requiredFutureNumber(claims, name) {
-  const value = numberValue(claims, name);
-  if (value === void 0 || value <= Date.now() / 1e3) {
-    throw invalidToken(`Missing or expired ${name} claim`);
-  }
-  return value;
-}
-function invalidToken(message, cause) {
-  const error = new OAuthError(OAuthErrorCode.InvalidToken, message);
-  if (cause !== void 0) {
-    error.cause = cause;
-  }
-  return error;
-}
-function verifiedResource(claims, configuredResource) {
-  const value = claims["resource"];
-  if (value !== void 0) {
-    if (typeof value !== "string") {
-      throw invalidToken("Token resource claim must be an absolute URL");
-    }
-    const resource = canonicalUrl(value);
-    if (resource.href !== configuredResource.href) {
-      throw invalidToken(
-        "Token resource claim does not match protected resource"
-      );
-    }
-    return configuredResource;
-  }
-  const audience = claims["aud"];
-  if (!validAudience(audience)) {
-    throw invalidToken("Token audience claim must be a string or string array");
-  }
-  const audiences = typeof audience === "string" ? [audience] : audience;
-  if (!audiences.includes(configuredResource.href)) {
-    throw invalidToken(
-      "Token audience does not include the protected resource"
-    );
-  }
-  return configuredResource;
-}
-function validAudience(value) {
-  return typeof value === "string" || Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string");
-}
-function canonicalUrl(value) {
-  try {
-    const url = new URL(value);
-    if (!isAllowedHttpUrl(url)) {
-      throw new TypeError();
-    }
-    url.pathname = url.pathname === "/" ? "/" : url.pathname.replace(/\/+$/, "");
-    return url;
-  } catch {
-    throw invalidToken(
-      "Token resource claim must be an absolute HTTPS URL, or HTTP URL for localhost"
-    );
-  }
-}
-function isAllowedHttpUrl(url) {
-  return /^https?:$/.test(url.protocol) && !url.username && !url.password && !url.search && !url.hash && (url.protocol !== "http:" || isLocalhost(url));
-}
-function isCredentialFailure(error) {
-  return error instanceof errors.JWTClaimValidationFailed || error instanceof errors.JWTExpired || error instanceof errors.JOSEAlgNotAllowed || error instanceof errors.JOSENotSupported || error instanceof errors.JWSInvalid || error instanceof errors.JWTInvalid || error instanceof errors.JWSSignatureVerificationFailed || error instanceof errors.JWKSNoMatchingKey;
-}
-var JWT_DEBUG_CLAIMS = [
-  "iss",
-  "aud",
-  "azp",
-  "sub",
-  "exp",
-  "iat",
-  "nbf",
-  "client_id",
-  "scope",
-  "typ",
-  "jti"
-];
-function debugErrorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function logJwtFailure(token, error) {
-  try {
-    let decodeSegment2 = function(segment, label) {
-      try {
-        return Buffer.from(segment, "base64url").toString("utf8");
-      } catch (decodeError) {
-        console.error(
-          `[oauth-debug] ${label} decode failed: ${debugErrorText(decodeError)}`
-        );
-        return void 0;
-      }
-    };
-    var decodeSegment = decodeSegment2;
-    const name = error instanceof Error ? error.constructor.name : typeof error;
-    console.error(
-      `[oauth-debug] JWT verify failed: ${name}: ${debugErrorText(error)}`
-    );
-    if (error instanceof errors.JWTClaimValidationFailed) {
-      console.error(
-        `[oauth-debug] claim=${error.claim} reason=${error.reason}`
-      );
-    }
-    const segments = token.split(".");
-    console.error(`[oauth-debug] token segments: ${segments.length}`);
-    if (segments.length !== 3) {
-      const preview = token.length > 12 ? `${token.slice(0, 12)}\u2026` : token;
-      console.error(
-        `[oauth-debug] non-JWT token preview=${preview} length=${token.length}`
-      );
-      return;
-    }
-    const headerJson = decodeSegment2(segments[0], "header");
-    if (headerJson !== void 0) {
-      console.error(`[oauth-debug] header=${headerJson}`);
-    }
-    const payloadJson = decodeSegment2(segments[1], "payload");
-    if (payloadJson === void 0) {
-      return;
-    }
-    try {
-      const payload = JSON.parse(payloadJson);
-      const selected = {};
-      for (const claim of JWT_DEBUG_CLAIMS) {
-        if (claim in payload) {
-          selected[claim] = payload[claim];
-        }
-      }
-      selected["now"] = Math.floor(Date.now() / 1e3);
-      console.error(`[oauth-debug] payload=${JSON.stringify(selected)}`);
-    } catch (decodeError) {
-      console.error(
-        `[oauth-debug] payload decode failed: ${debugErrorText(decodeError)}`
-      );
-    }
-  } catch {
-  }
-}
-
-// src/oauth/internal.ts
-function resolveConfiguredOAuthResource(options) {
-  const provider = options.provider;
-  const basePath = normalizeBasePath(options.basePath);
-  if (provider.resource !== void 0) {
-    return validateOAuthResource(provider.resource, basePath);
-  }
-  if (options.mcpUrl !== void 0) {
-    return validateOAuthResource(
-      appendBasePath(
-        requireAbsoluteOrigin(options.mcpUrl, "MCP_URL"),
-        basePath
-      ),
-      basePath
-    );
-  }
-  return void 0;
-}
-function resolveLocalOAuthResource(listenOrigin, basePath) {
-  const listenOriginUrl = requireAbsoluteOrigin(listenOrigin, "listen origin");
-  if (!isLocalhost(listenOriginUrl)) {
-    throw new Error(
-      "OAuth listen origin must be localhost or a loopback address"
-    );
-  }
-  return validateOAuthResource(
-    appendBasePath(listenOriginUrl, normalizeBasePath(basePath)),
-    basePath
-  );
-}
-function validateOAuthResource(resource, basePath) {
-  const normalizedBasePath = normalizeBasePath(basePath);
-  const url = parseAbsoluteUrl(resource, "OAuth resource");
-  if (url.search !== "" || url.hash !== "") {
-    throw new Error(
-      "OAuth resource must not include a query string or fragment"
-    );
-  }
-  assertSecureHttpUrl(url, "OAuth resource");
-  if (normalizePathname(url.pathname) !== normalizedBasePath) {
-    throw new Error(
-      `OAuth resource path must exactly match basePath (${normalizedBasePath})`
-    );
-  }
-  url.pathname = normalizedBasePath;
-  return url;
-}
-function wrapOAuthTokenVerifier(provider, expectedResource) {
-  const canonicalResource = normalizeResourceUrl(expectedResource);
-  const tokenVerifier = provider.createTokenVerifier(
-    new URL(canonicalResource.href)
-  );
-  if (tokenVerifier === null || typeof tokenVerifier !== "object" || typeof tokenVerifier.verifyAccessToken !== "function") {
-    throw new TypeError(
-      "OAuth provider createTokenVerifier must return an OAuthTokenVerifier"
-    );
-  }
-  return {
-    async verifyAccessToken(token) {
-      const authInfo = await tokenVerifier.verifyAccessToken(token);
-      assertVerifiedAuthInfo(authInfo);
-      assertResourceBinding(authInfo, canonicalResource);
-      let mapped;
-      try {
-        mapped = provider.mapAuthInfo(authInfo);
-      } catch (error) {
-        throw invalidToken("Token identity mapping failed", error);
-      }
-      assertMappedExtra(mapped);
-      return {
-        ...authInfo,
-        scopes: [...authInfo.scopes],
-        extra: { ...authInfo.extra, ...mapped }
-      };
-    }
-  };
-}
-function assertResourceBinding(authInfo, expectedResource) {
-  if (authInfo.resource === void 0) {
-    throw invalidToken(
-      "Token verifier did not return a validated protected resource"
-    );
-  }
-  const resource = parseTokenResource(authInfo.resource);
-  if (resource.href !== normalizeResourceUrl(expectedResource).href) {
-    throw invalidToken("Token resource does not match the protected resource");
-  }
-}
-function parseTokenResource(value) {
-  if (!(value instanceof URL)) {
-    throw invalidToken(
-      "Token resource must be an absolute HTTPS URL, or HTTP URL for localhost"
-    );
-  }
-  const resource = value;
-  if (!/^https?:$/.test(resource.protocol) || resource.username !== "" || resource.password !== "" || resource.search !== "" || resource.hash !== "" || resource.protocol === "http:" && !isLocalhost(resource)) {
-    throw invalidToken(
-      "Token resource must be an absolute HTTPS URL, or HTTP URL for localhost"
-    );
-  }
-  return normalizeResourceUrl(resource);
-}
-function normalizeResourceUrl(resource) {
-  const normalized = new URL(resource);
-  normalized.pathname = normalized.pathname === "/" ? "/" : normalized.pathname.replace(/\/+$/, "");
-  return normalized;
-}
-function getOAuthProviderOptions(provider) {
-  return {
-    oauthMetadata: provider.oauthMetadata,
-    ...provider.requiredScopes !== void 0 && {
-      requiredScopes: [...provider.requiredScopes]
-    },
-    ...provider.scopesSupported !== void 0 && {
-      scopesSupported: [...provider.scopesSupported]
-    },
-    ...provider.resourceName !== void 0 && {
-      resourceName: provider.resourceName
-    },
-    ...provider.serviceDocumentationUrl !== void 0 && {
-      serviceDocumentationUrl: provider.serviceDocumentationUrl
-    }
-  };
-}
-function assertVerifiedAuthInfo(authInfo) {
-  if (authInfo === null || typeof authInfo !== "object" || typeof authInfo.token !== "string" || authInfo.token.length === 0 || typeof authInfo.clientId !== "string" || !Array.isArray(authInfo.scopes) || !authInfo.scopes.every((scope) => typeof scope === "string") || typeof authInfo.expiresAt !== "number" || !Number.isFinite(authInfo.expiresAt) || authInfo.expiresAt <= Date.now() / 1e3) {
-    throw invalidToken(
-      "Token verifier returned invalid authentication information"
-    );
-  }
-}
-function assertMappedExtra(mapped) {
-  if (mapped === null || typeof mapped !== "object" || !("user" in mapped) || mapped.user === void 0 || !isRecord(mapped.payload) || !Array.isArray(mapped.permissions) || !mapped.permissions.every((permission) => typeof permission === "string")) {
-    throw invalidToken(
-      "Token identity mapping must return user, payload, and string permissions"
-    );
-  }
-}
-function requireAbsoluteOrigin(value, name) {
-  const url = parseAbsoluteUrl(value, name);
-  if (url.pathname !== "/" || url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "") {
-    throw new Error(`${name} must be an absolute origin without a path`);
-  }
-  return url;
-}
-function appendBasePath(origin, basePath) {
-  const resource = new URL(origin.origin);
-  resource.pathname = basePath;
-  return resource;
-}
-function normalizeBasePath(basePath) {
-  if (!basePath.startsWith("/") || basePath.includes("?") || basePath.includes("#")) {
-    throw new Error("basePath must be an absolute URL pathname");
-  }
-  return normalizePathname(basePath);
-}
-function normalizePathname(pathname) {
-  return pathname === "/" ? "/" : pathname.replace(/\/+$/, "");
-}
-
-// src/oauth/provider.ts
-function oauthCustomProvider(options) {
-  if (options === null || typeof options !== "object" || typeof options.createTokenVerifier !== "function" || typeof options.mapAuthInfo !== "function") {
-    throw new TypeError(
-      "oauthCustomProvider requires createTokenVerifier, oauthMetadata, and mapAuthInfo"
-    );
-  }
-  assertOAuthMetadata(options.oauthMetadata);
-  if (options.resource !== void 0) {
-    assertResourceUrl(options.resource);
-  }
-  assertStringArray(options.requiredScopes, "requiredScopes");
-  assertStringArray(options.scopesSupported, "scopesSupported");
-  if (options.resourceName !== void 0 && (typeof options.resourceName !== "string" || options.resourceName.trim().length === 0)) {
-    throw new TypeError("resourceName must be a non-empty string");
-  }
-  if (options.serviceDocumentationUrl !== void 0) {
-    if (!(options.serviceDocumentationUrl instanceof URL)) {
-      throw new TypeError("serviceDocumentationUrl must be a URL");
-    }
-    assertSecureHttpUrl(
-      options.serviceDocumentationUrl,
-      "serviceDocumentationUrl"
-    );
-  }
-  const provider = {
-    createTokenVerifier: options.createTokenVerifier,
-    oauthMetadata: options.oauthMetadata,
-    mapAuthInfo: options.mapAuthInfo,
-    ...options.resource !== void 0 && { resource: options.resource },
-    ...options.requiredScopes !== void 0 && {
-      requiredScopes: [...options.requiredScopes]
-    },
-    ...options.scopesSupported !== void 0 && {
-      scopesSupported: [...options.scopesSupported]
-    },
-    ...options.resourceName !== void 0 && {
-      resourceName: options.resourceName
-    },
-    ...options.serviceDocumentationUrl !== void 0 && {
-      serviceDocumentationUrl: options.serviceDocumentationUrl
-    }
-  };
-  return provider;
-}
-function assertOAuthMetadata(metadata) {
-  if (metadata === null || typeof metadata !== "object" || !("issuer" in metadata) || typeof metadata.issuer !== "string") {
-    throw new TypeError("oauthMetadata must include a string issuer");
-  }
-  assertSecureHttpUrl(
-    parseAbsoluteUrl(metadata.issuer, "oauthMetadata.issuer"),
-    "oauthMetadata.issuer"
-  );
-}
-function assertResourceUrl(resource) {
-  assertSecureHttpUrl(parseAbsoluteUrl(resource, "resource"), "resource");
-}
-function assertStringArray(value, name) {
-  if (value !== void 0 && (!Array.isArray(value) || !value.every((item) => typeof item === "string"))) {
-    throw new TypeError(`${name} must be an array of strings`);
-  }
-}
-
-export {
-  isRecord,
-  createJwtVerifier,
-  normalizedProviderUrl,
-  providerEndpoint,
-  payloadFromAuthInfo,
-  requiredString,
-  stringValue,
-  booleanValue,
-  recordValue,
-  normalizedStrings,
-  invalidToken,
-  resolveConfiguredOAuthResource,
-  resolveLocalOAuthResource,
-  wrapOAuthTokenVerifier,
-  getOAuthProviderOptions,
-  oauthCustomProvider
-};