@ai-sdk/mcp 1.0.89 → 1.0.91

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/mcp
 
+## 1.0.91
+
+### Patch Changes
+
+- 5267a7a: Preserve stored OAuth credentials when an authorization-code exchange returns `invalid_grant`, without retrying the rejected code.
+
+  Add optional token context to `OAuthClientProvider.invalidateCredentials` so providers sharing storage can atomically delete only the rejected token generation and preserve tokens saved by a concurrent refresh.
+
+## 1.0.90
+
+### Patch Changes
+
+- a9cea74: Keep default Node.js downloads protected by DNS validation and connection pinning when frameworks or instrumentation wrap global fetch before or after the SDK loads.
+- a9cea74: fix(mcp): prevent SSRF in OAuth metadata discovery
+- Updated dependencies [a9cea74]
+- Updated dependencies [a9cea74]
+- Updated dependencies [a9cea74]
+  - @ai-sdk/provider-utils@4.0.57
+
 ## 1.0.89
 
 ### Patch Changes

package/dist/index.d.mts

@@ -184,8 +184,15 @@ interface OAuthClientProvider {
      * If implemented, provides a way for the client to invalidate (e.g. delete) the specified
      * credentials, in the case where the server has indicated that they are no longer valid.
      * This avoids requiring the user to intervene manually.
+     *
+     * For token invalidation, context identifies the token generation being invalidated
+     * when available. Providers sharing storage must atomically compare and delete
+     * that generation so a concurrent refresh's tokens are preserved. Omitting or
+     * ignoring context retains unconditional invalidation.
      */
-    invalidateCredentials?(scope: 'all' | 'client' | 'tokens' | 'verifier'): void | Promise<void>;
+    invalidateCredentials?(scope: 'all' | 'client' | 'tokens' | 'verifier', context?: {
+        tokens: OAuthTokens;
+    }): void | Promise<void>;
     get redirectUrl(): string | URL;
     get clientMetadata(): OAuthClientMetadata;
     clientInformation(): OAuthClientInformation | undefined | Promise<OAuthClientInformation | undefined>;

package/dist/index.d.ts

@@ -184,8 +184,15 @@ interface OAuthClientProvider {
      * If implemented, provides a way for the client to invalidate (e.g. delete) the specified
      * credentials, in the case where the server has indicated that they are no longer valid.
      * This avoids requiring the user to intervene manually.
+     *
+     * For token invalidation, context identifies the token generation being invalidated
+     * when available. Providers sharing storage must atomically compare and delete
+     * that generation so a concurrent refresh's tokens are preserved. Omitting or
+     * ignoring context retains unconditional invalidation.
      */
-    invalidateCredentials?(scope: 'all' | 'client' | 'tokens' | 'verifier'): void | Promise<void>;
+    invalidateCredentials?(scope: 'all' | 'client' | 'tokens' | 'verifier', context?: {
+        tokens: OAuthTokens;
+    }): void | Promise<void>;
     get redirectUrl(): string | URL;
     get clientMetadata(): OAuthClientMetadata;
     clientInformation(): OAuthClientInformation | undefined | Promise<OAuthClientInformation | undefined>;

package/dist/index.js

@@ -572,8 +572,8 @@ function isOAuthLoopbackHost(hostname) {
   const normalized = hostname.toLowerCase().replace(/\.+$/, "");
   return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "127.0.0.1" || normalized === "[::1]" || normalized === "::1";
 }
-function assertSafeOAuthEndpoint(endpointUrl) {
-  if ((endpointUrl.protocol === "http:" || endpointUrl.protocol === "https:") && isOAuthLoopbackHost(endpointUrl.hostname)) {
+function assertSafeOAuthEndpoint(endpointUrl, { allowLoopback = false } = {}) {
+  if (allowLoopback && (endpointUrl.protocol === "http:" || endpointUrl.protocol === "https:") && isOAuthLoopbackHost(endpointUrl.hostname)) {
     return;
   }
   try {
@@ -585,6 +585,10 @@ function assertSafeOAuthEndpoint(endpointUrl) {
     });
   }
 }
+function getTrustedLoopbackOrigin(authorizationServerUrl) {
+  const url = new URL(authorizationServerUrl);
+  return isOAuthLoopbackHost(url.hostname) ? url.origin : void 0;
+}
 function createAuthorizationServerInformation(authorizationServerUrl, metadata) {
   return {
     authorizationServerUrl: normalizeUrl(authorizationServerUrl),
@@ -724,13 +728,27 @@ function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
   }
   return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
 }
-async function fetchWithCorsRetry(url, headers, fetchFn = fetch) {
+async function fetchWithCorsRetry(url, headers, fetchFn = fetch, trustedOrigin) {
   try {
-    return await fetchFn(url, { headers });
+    return await (0, import_provider_utils2.fetchWithValidatedRedirects)({
+      url: url.href,
+      fetch: async (input, init) => (0, import_provider_utils2.fetchWithValidatedEndpoint)({
+        url: input,
+        init: {
+          ...init,
+          headers: new Headers(init == null ? void 0 : init.headers).has("MCP-Protocol-Version") ? headers : void 0
+        },
+        fetch: fetchFn,
+        trustedOrigin,
+        redirect: "manual"
+      }),
+      headers,
+      trustedOrigin
+    });
   } catch (error) {
     if (error instanceof TypeError) {
       if (headers) {
-        return fetchWithCorsRetry(url, void 0, fetchFn);
+        return fetchWithCorsRetry(url, void 0, fetchFn, trustedOrigin);
       } else {
         return void 0;
       }
@@ -738,11 +756,11 @@ async function fetchWithCorsRetry(url, headers, fetchFn = fetch) {
     throw error;
   }
 }
-async function tryMetadataDiscovery(url, protocolVersion, fetchFn = fetch) {
+async function tryMetadataDiscovery(url, protocolVersion, fetchFn = fetch, trustedOrigin) {
   const headers = {
     "MCP-Protocol-Version": protocolVersion
   };
-  return await fetchWithCorsRetry(url, headers, fetchFn);
+  return await fetchWithCorsRetry(url, headers, fetchFn, trustedOrigin);
 }
 function shouldAttemptFallback(response, pathname) {
   return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
@@ -759,10 +777,20 @@ async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, o
     url = new URL(wellKnownPath, (_b3 = opts == null ? void 0 : opts.metadataServerUrl) != null ? _b3 : issuer);
     url.search = issuer.search;
   }
-  let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
+  let response = await tryMetadataDiscovery(
+    url,
+    protocolVersion,
+    fetchFn,
+    opts == null ? void 0 : opts.trustedOrigin
+  );
   if (!(opts == null ? void 0 : opts.metadataUrl) && shouldAttemptFallback(response, issuer.pathname)) {
     const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
-    response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+    response = await tryMetadataDiscovery(
+      rootUrl,
+      protocolVersion,
+      fetchFn,
+      opts == null ? void 0 : opts.trustedOrigin
+    );
   }
   return response;
 }
@@ -773,7 +801,10 @@ async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn =
     fetchFn,
     {
       protocolVersion: opts == null ? void 0 : opts.protocolVersion,
-      metadataUrl: opts == null ? void 0 : opts.resourceMetadataUrl
+      metadataUrl: opts == null ? void 0 : opts.resourceMetadataUrl,
+      // The configured MCP server is trusted as a request target. Redirects
+      // crossing its origin are still validated before they are followed.
+      trustedOrigin: new URL(serverUrl).origin
     }
   );
   if (!response || response.status === 404) {
@@ -846,13 +877,19 @@ function assertMetadataIssuerMatches(metadata, expectedIssuer) {
 }
 async function discoverAuthorizationServerMetadata(authorizationServerUrl, {
   fetchFn = fetch,
-  protocolVersion = LATEST_PROTOCOL_VERSION
+  protocolVersion = LATEST_PROTOCOL_VERSION,
+  trustedOrigin
 } = {}) {
   var _a3;
   const headers = { "MCP-Protocol-Version": protocolVersion };
   const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
   for (const { url: endpointUrl, type, expectedIssuer } of urlsToTry) {
-    const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    const response = await fetchWithCorsRetry(
+      endpointUrl,
+      headers,
+      fetchFn,
+      trustedOrigin
+    );
     if (!response) {
       continue;
     }
@@ -1018,7 +1055,10 @@ async function exchangeAuthorization(authorizationServerUrl, {
   var _a3;
   const grantType = "authorization_code";
   const tokenUrl = (metadata == null ? void 0 : metadata.token_endpoint) ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
-  assertSafeOAuthEndpoint(tokenUrl);
+  const trustedOrigin = getTrustedLoopbackOrigin(authorizationServerUrl);
+  assertSafeOAuthEndpoint(tokenUrl, {
+    allowLoopback: tokenUrl.origin === trustedOrigin
+  });
   if ((metadata == null ? void 0 : metadata.grant_types_supported) && !metadata.grant_types_supported.includes(grantType)) {
     throw new Error(
       `Incompatible auth server: does not support grant type ${grantType}`
@@ -1052,11 +1092,15 @@ async function exchangeAuthorization(authorizationServerUrl, {
   if (resource) {
     params.set("resource", resourceUrlStripSlash(resource));
   }
-  const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
-    method: "POST",
-    headers,
-    body: params,
-    redirect: "error"
+  const response = await (0, import_provider_utils2.fetchWithValidatedEndpoint)({
+    url: tokenUrl,
+    init: {
+      method: "POST",
+      headers,
+      body: params
+    },
+    fetch: fetchFn,
+    trustedOrigin
   });
   if (!response.ok) {
     throw await parseErrorResponse(response);
@@ -1084,7 +1128,10 @@ async function refreshAuthorization(authorizationServerUrl, {
   } else {
     tokenUrl = new URL("/token", authorizationServerUrl);
   }
-  assertSafeOAuthEndpoint(tokenUrl);
+  const trustedOrigin = getTrustedLoopbackOrigin(authorizationServerUrl);
+  assertSafeOAuthEndpoint(tokenUrl, {
+    allowLoopback: tokenUrl.origin === trustedOrigin
+  });
   const headers = new Headers({
     "Content-Type": "application/x-www-form-urlencoded",
     Accept: "application/json"
@@ -1111,11 +1158,15 @@ async function refreshAuthorization(authorizationServerUrl, {
   if (resource) {
     params.set("resource", resourceUrlStripSlash(resource));
   }
-  const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
-    method: "POST",
-    headers,
-    body: params,
-    redirect: "error"
+  const response = await (0, import_provider_utils2.fetchWithValidatedEndpoint)({
+    url: tokenUrl,
+    init: {
+      method: "POST",
+      headers,
+      body: params
+    },
+    fetch: fetchFn,
+    trustedOrigin
   });
   if (!response.ok) {
     throw await parseErrorResponse(response);
@@ -1141,14 +1192,21 @@ async function registerClient(authorizationServerUrl, {
   } else {
     registrationUrl = new URL("/register", authorizationServerUrl);
   }
-  assertSafeOAuthEndpoint(registrationUrl);
-  const response = await (fetchFn != null ? fetchFn : fetch)(registrationUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+  const trustedOrigin = getTrustedLoopbackOrigin(authorizationServerUrl);
+  assertSafeOAuthEndpoint(registrationUrl, {
+    allowLoopback: registrationUrl.origin === trustedOrigin
+  });
+  const response = await (0, import_provider_utils2.fetchWithValidatedEndpoint)({
+    url: registrationUrl,
+    init: {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(clientMetadata)
     },
-    body: JSON.stringify(clientMetadata),
-    redirect: "error"
+    fetch: fetchFn,
+    trustedOrigin
   });
   if (!response.ok) {
     throw await parseErrorResponse(response);
@@ -1157,8 +1215,9 @@ async function registerClient(authorizationServerUrl, {
 }
 async function auth(provider, options) {
   var _a3, _b3, _c;
+  const refreshAttempt = {};
   try {
-    return await authInternal(provider, options);
+    return await authInternal(provider, options, refreshAttempt);
   } catch (error) {
     if (error instanceof InvalidClientError || error instanceof UnauthorizedClientError) {
       if (options.authorizationCode !== void 0 || !await ((_a3 = provider.isClientInformationDynamicallyRegistered) == null ? void 0 : _a3.call(provider))) {
@@ -1166,8 +1225,10 @@ async function auth(provider, options) {
       }
       await ((_b3 = provider.invalidateCredentials) == null ? void 0 : _b3.call(provider, "all"));
       return await authInternal(provider, options);
-    } else if (error instanceof InvalidGrantError) {
-      await ((_c = provider.invalidateCredentials) == null ? void 0 : _c.call(provider, "tokens"));
+    } else if (error instanceof InvalidGrantError && refreshAttempt.tokens) {
+      await ((_c = provider.invalidateCredentials) == null ? void 0 : _c.call(provider, "tokens", {
+        tokens: refreshAttempt.tokens
+      }));
       return await authInternal(provider, options);
     }
     throw error;
@@ -1201,7 +1262,7 @@ async function authInternal(provider, {
   scope,
   resourceMetadataUrl,
   fetchFn
-}) {
+}, refreshAttempt) {
   var _a3, _b3, _c;
   let resourceMetadata;
   let authorizationServerUrl;
@@ -1231,6 +1292,14 @@ async function authInternal(provider, {
   if (!authorizationServerUrl) {
     authorizationServerUrl = (_a3 = callbackAuthorizationServerInformation == null ? void 0 : callbackAuthorizationServerInformation.authorizationServerUrl) != null ? _a3 : serverUrl;
   }
+  const parsedServerUrl = new URL(serverUrl);
+  const parsedAuthorizationServerUrl = new URL(authorizationServerUrl);
+  const serverOrigin = parsedServerUrl.origin;
+  const authorizationServerOrigin = parsedAuthorizationServerUrl.origin;
+  const trustedAuthorizationServerOrigin = authorizationServerOrigin === serverOrigin || isOAuthLoopbackHost(parsedServerUrl.hostname) && isOAuthLoopbackHost(parsedAuthorizationServerUrl.hostname) ? authorizationServerOrigin : void 0;
+  if (!trustedAuthorizationServerOrigin) {
+    assertSafeOAuthEndpoint(new URL(authorizationServerUrl));
+  }
   const resource = await selectResourceURL(
     serverUrl,
     provider,
@@ -1244,7 +1313,8 @@ async function authInternal(provider, {
   const metadata = await discoverAuthorizationServerMetadata(
     authorizationServerUrl,
     {
-      fetchFn
+      fetchFn,
+      trustedOrigin: trustedAuthorizationServerOrigin
     }
   );
   const currentAuthorizationServerInformation = createAuthorizationServerInformation(authorizationServerUrl, metadata);
@@ -1336,10 +1406,15 @@ async function authInternal(provider, {
         currentAuthorizationServerInformation
       });
     } else {
-      await ((_c = provider.invalidateCredentials) == null ? void 0 : _c.call(provider, "tokens"));
+      await ((_c = provider.invalidateCredentials) == null ? void 0 : _c.call(provider, "tokens", {
+        tokens: { ...tokens }
+      }));
     }
     try {
       if (storedAuthorizationServerInformation) {
+        if (refreshAttempt) {
+          refreshAttempt.tokens = { ...tokens };
+        }
         const newTokens = await refreshAuthorization(authorizationServerUrl, {
           metadata,
           clientInformation,