fastmcp 4.23.13 → 4.24.0

package/README.md

@@ -757,6 +757,38 @@ session sees every tool. With one, a session that still ends up without auth —
 on stdio, where the server carries on when `authenticate` throws or returns
 nothing — sees none of the tools that have `canAccess`.
 
+##### Scope challenges
+
+To keep a tool listed but require OAuth scopes to call it, list them in
+`scopes`. FastMCP reads the scopes a session was granted from `auth.scopes`, an
+array or a `Set`, the same way `requireScopes()` does.
+
+```typescript
+server.addTool({
+  name: "write-file",
+  description: "Writes a file",
+  scopes: ["files:write"],
+  execute: async () => "Written",
+});
+```
+
+A call without those scopes never runs. Over HTTP it gets MCP's
+[scope challenge](https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization#scope-challenge-handling),
+a `403` with:
+
+```http
+WWW-Authenticate: Bearer error="insufficient_scope", scope="files:read files:write", resource_metadata="…"
+```
+
+`scope` lists the scopes the session already has plus the ones the tool needs,
+so the client can get a token with all of them and retry. `resource_metadata`
+is included when `oauth.enabled` is set. On stdio and other transports without
+HTTP, the call fails with a JSON-RPC error (code `-32001`) instead.
+
+To hide the tool from sessions without the scopes, use
+`canAccess: requireScopes(...)` instead. Like `canAccess`, `scopes` is not
+enforced on a server without an `authenticate` function.
+
 #### Returning a string
 
 `execute` can return a string:
@@ -2003,7 +2035,8 @@ server.addTool({
   // ...
 });
 
-// Require specific OAuth scopes
+// Require specific OAuth scopes (hides the tool; see "Scope challenges" to
+// keep it listed and answer calls with a 403 instead)
 server.addTool({
   canAccess: requireScopes("read:user", "write:data"),
   name: "scoped-tool",

package/dist/FastMCP.cjs

@@ -11,7 +11,7 @@
 
 
 
-var _chunk4P2GDM7Wcjs = require('./chunk-4P2GDM7W.cjs');
+var _chunkJMH7WDO2cjs = require('./chunk-JMH7WDO2.cjs');
 
 
 
@@ -50,5 +50,5 @@ require('./chunk-6TDYSPLC.cjs');
 
 
 
-exports.AuthProvider = _chunkBV4PWTT6cjs.AuthProvider; exports.AzureProvider = _chunkBV4PWTT6cjs.AzureProvider; exports.DiscoveryDocumentCache = _chunk4P2GDM7Wcjs.DiscoveryDocumentCache; exports.FastMCP = _chunk4P2GDM7Wcjs.FastMCP; exports.FastMCPError = _chunk4P2GDM7Wcjs.FastMCPError; exports.FastMCPSession = _chunk4P2GDM7Wcjs.FastMCPSession; exports.GitHubProvider = _chunkBV4PWTT6cjs.GitHubProvider; exports.GoogleProvider = _chunkBV4PWTT6cjs.GoogleProvider; exports.MEDIA_FETCH_TIMEOUT_MS = _chunk4P2GDM7Wcjs.MEDIA_FETCH_TIMEOUT_MS; exports.OAuthProvider = _chunkBV4PWTT6cjs.OAuthProvider; exports.ServerState = _chunk4P2GDM7Wcjs.ServerState; exports.SessionError = _chunk4P2GDM7Wcjs.SessionError; exports.UnexpectedStateError = _chunk4P2GDM7Wcjs.UnexpectedStateError; exports.UserError = _chunk4P2GDM7Wcjs.UserError; exports.audioContent = _chunk4P2GDM7Wcjs.audioContent; exports.getAuthSession = _chunkBV4PWTT6cjs.getAuthSession; exports.imageContent = _chunk4P2GDM7Wcjs.imageContent; exports.jsonSchemaAdapter = _chunk4P2GDM7Wcjs.jsonSchemaAdapter; exports.requireAll = _chunkBV4PWTT6cjs.requireAll; exports.requireAny = _chunkBV4PWTT6cjs.requireAny; exports.requireAuth = _chunkBV4PWTT6cjs.requireAuth; exports.requireRole = _chunkBV4PWTT6cjs.requireRole; exports.requireScopes = _chunkBV4PWTT6cjs.requireScopes;
+exports.AuthProvider = _chunkBV4PWTT6cjs.AuthProvider; exports.AzureProvider = _chunkBV4PWTT6cjs.AzureProvider; exports.DiscoveryDocumentCache = _chunkJMH7WDO2cjs.DiscoveryDocumentCache; exports.FastMCP = _chunkJMH7WDO2cjs.FastMCP; exports.FastMCPError = _chunkJMH7WDO2cjs.FastMCPError; exports.FastMCPSession = _chunkJMH7WDO2cjs.FastMCPSession; exports.GitHubProvider = _chunkBV4PWTT6cjs.GitHubProvider; exports.GoogleProvider = _chunkBV4PWTT6cjs.GoogleProvider; exports.MEDIA_FETCH_TIMEOUT_MS = _chunkJMH7WDO2cjs.MEDIA_FETCH_TIMEOUT_MS; exports.OAuthProvider = _chunkBV4PWTT6cjs.OAuthProvider; exports.ServerState = _chunkJMH7WDO2cjs.ServerState; exports.SessionError = _chunkJMH7WDO2cjs.SessionError; exports.UnexpectedStateError = _chunkJMH7WDO2cjs.UnexpectedStateError; exports.UserError = _chunkJMH7WDO2cjs.UserError; exports.audioContent = _chunkJMH7WDO2cjs.audioContent; exports.getAuthSession = _chunkBV4PWTT6cjs.getAuthSession; exports.imageContent = _chunkJMH7WDO2cjs.imageContent; exports.jsonSchemaAdapter = _chunkJMH7WDO2cjs.jsonSchemaAdapter; exports.requireAll = _chunkBV4PWTT6cjs.requireAll; exports.requireAny = _chunkBV4PWTT6cjs.requireAny; exports.requireAuth = _chunkBV4PWTT6cjs.requireAuth; exports.requireRole = _chunkBV4PWTT6cjs.requireRole; exports.requireScopes = _chunkBV4PWTT6cjs.requireScopes;
 //# sourceMappingURL=FastMCP.cjs.map

package/dist/FastMCP.d.cts

@@ -354,6 +354,16 @@ type InputResourceTemplateArgument<T extends FastMCPSessionAuth = FastMCPSession
     required?: boolean;
 }>;
 type LoggingLevel = "alert" | "critical" | "debug" | "emergency" | "error" | "info" | "notice" | "warning";
+/**
+ * Why a tool call may not run with the session's token, and the scopes the
+ * client should re-authorize for: the ones the session already has plus the
+ * ones the tool needs, so that the new token does not drop any (the approach
+ * MCP recommends for scope challenges).
+ */
+type ScopeChallenge = {
+    description: string;
+    scopes: string[];
+};
 type Prompt<T extends FastMCPSessionAuth = FastMCPSessionAuth, Arguments extends PromptArgument<T>[] = PromptArgument<T>[], Args = PromptArgumentsToObject<Arguments>> = {
     arguments?: PromptArgument<T>[];
     complete?: (name: string, value: string, auth?: T) => Promise<Completion>;
@@ -808,6 +818,19 @@ type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolPara
     name: string;
     outputSchema?: OutputParams;
     parameters?: Params;
+    /**
+     * OAuth scopes a caller needs to call this tool, checked on every call
+     * against `auth.scopes` (an array or a `Set`, read as `requireScopes()`
+     * reads it). Unlike `canAccess`, this does not hide the tool. A call without
+     * them never runs: over HTTP it is answered with MCP's 403
+     * `insufficient_scope` challenge, which tells the client which scopes to
+     * re-authorize for, and on other transports with a JSON-RPC error.
+     *
+     * Enforced on the same terms as `canAccess`: not at all on a server without
+     * `authenticate`, and as if nothing were granted for a session that ends up
+     * without auth on one that has it.
+     */
+    scopes?: string[];
     timeoutMs?: number;
 };
 /**
@@ -967,6 +990,13 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
     requestSampling(message: z.infer<typeof CreateMessageRequestSchema>["params"], options?: RequestOptions): Promise<SamplingResponse>;
     resourcesListChanged(resources: Resource<T>[]): void;
     resourceTemplatesListChanged(resourceTemplates: ResourceTemplate<T>[]): void;
+    /**
+     * The scope challenge one message a client sent would get, or `undefined` to
+     * let it through. FastMCP's HTTP transports ask before mcp-proxy dispatches
+     * each message, the last point at which the answer can still be a 403; the
+     * `tools/call` handler applies the same check on every transport.
+     */
+    scopeChallengeFor(message: unknown): ScopeChallenge | undefined;
     /**
      * Notifies the connected client that the contents of a resource have changed.
      *
@@ -1166,4 +1196,4 @@ declare class FastMCP<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends
     stop(): Promise<void>;
 }
 
-export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, FastMCPError, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, MEDIA_FETCH_TIMEOUT_MS, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, SessionError, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };
+export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, FastMCPError, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, MEDIA_FETCH_TIMEOUT_MS, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type ScopeChallenge, type SerializableValue, type ServerOptions, ServerState, SessionError, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };

package/dist/FastMCP.d.ts

@@ -354,6 +354,16 @@ type InputResourceTemplateArgument<T extends FastMCPSessionAuth = FastMCPSession
     required?: boolean;
 }>;
 type LoggingLevel = "alert" | "critical" | "debug" | "emergency" | "error" | "info" | "notice" | "warning";
+/**
+ * Why a tool call may not run with the session's token, and the scopes the
+ * client should re-authorize for: the ones the session already has plus the
+ * ones the tool needs, so that the new token does not drop any (the approach
+ * MCP recommends for scope challenges).
+ */
+type ScopeChallenge = {
+    description: string;
+    scopes: string[];
+};
 type Prompt<T extends FastMCPSessionAuth = FastMCPSessionAuth, Arguments extends PromptArgument<T>[] = PromptArgument<T>[], Args = PromptArgumentsToObject<Arguments>> = {
     arguments?: PromptArgument<T>[];
     complete?: (name: string, value: string, auth?: T) => Promise<Completion>;
@@ -808,6 +818,19 @@ type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolPara
     name: string;
     outputSchema?: OutputParams;
     parameters?: Params;
+    /**
+     * OAuth scopes a caller needs to call this tool, checked on every call
+     * against `auth.scopes` (an array or a `Set`, read as `requireScopes()`
+     * reads it). Unlike `canAccess`, this does not hide the tool. A call without
+     * them never runs: over HTTP it is answered with MCP's 403
+     * `insufficient_scope` challenge, which tells the client which scopes to
+     * re-authorize for, and on other transports with a JSON-RPC error.
+     *
+     * Enforced on the same terms as `canAccess`: not at all on a server without
+     * `authenticate`, and as if nothing were granted for a session that ends up
+     * without auth on one that has it.
+     */
+    scopes?: string[];
     timeoutMs?: number;
 };
 /**
@@ -967,6 +990,13 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
     requestSampling(message: z.infer<typeof CreateMessageRequestSchema>["params"], options?: RequestOptions): Promise<SamplingResponse>;
     resourcesListChanged(resources: Resource<T>[]): void;
     resourceTemplatesListChanged(resourceTemplates: ResourceTemplate<T>[]): void;
+    /**
+     * The scope challenge one message a client sent would get, or `undefined` to
+     * let it through. FastMCP's HTTP transports ask before mcp-proxy dispatches
+     * each message, the last point at which the answer can still be a 403; the
+     * `tools/call` handler applies the same check on every transport.
+     */
+    scopeChallengeFor(message: unknown): ScopeChallenge | undefined;
     /**
      * Notifies the connected client that the contents of a resource have changed.
      *
@@ -1166,4 +1196,4 @@ declare class FastMCP<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends
     stop(): Promise<void>;
 }
 
-export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, FastMCPError, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, MEDIA_FETCH_TIMEOUT_MS, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, SessionError, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };
+export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, FastMCPError, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, MEDIA_FETCH_TIMEOUT_MS, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type ScopeChallenge, type SerializableValue, type ServerOptions, ServerState, SessionError, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };

package/dist/FastMCP.js

@@ -11,7 +11,7 @@ import {
   audioContent,
   imageContent,
   jsonSchemaAdapter
-} from "./chunk-ULNQF5KG.js";
+} from "./chunk-5JRRZ7MN.js";
 import {
   AuthProvider,
   AzureProvider,

package/dist/{chunk-ULNQF5KG.js → chunk-5JRRZ7MN.js}

@@ -490,6 +490,8 @@ var LOGGING_LEVEL_SEVERITY = {
   notice: 2,
   warning: 3
 };
+var INSUFFICIENT_SCOPE_ERROR_CODE = -32001;
+var SCOPE_TOKEN = /^[\x21\x23-\x5B\x5D-\x7E]+$/;
 var FastMCPSessionEventEmitterBase = EventEmitter;
 var ServerState = /* @__PURE__ */ ((ServerState2) => {
   ServerState2["Error"] = "error";
@@ -792,6 +794,24 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
     this.setupResourceTemplateHandlers();
     this.triggerListChangedNotification("notifications/resources/list_changed");
   }
+  /**
+   * The scope challenge one message a client sent would get, or `undefined` to
+   * let it through. FastMCP's HTTP transports ask before mcp-proxy dispatches
+   * each message, the last point at which the answer can still be a 403; the
+   * `tools/call` handler applies the same check on every transport.
+   */
+  scopeChallengeFor(message) {
+    if (typeof message !== "object" || message === null) {
+      return void 0;
+    }
+    const { method, params } = message;
+    if (method !== "tools/call" || typeof params !== "object" || !params) {
+      return void 0;
+    }
+    const { name } = params;
+    const tool = this.#visibleTools.find((visible) => visible.name === name);
+    return tool ? this.#scopeChallenge(tool) : void 0;
+  }
   /**
    * Notifies the connected client that the contents of a resource have changed.
    *
@@ -1030,6 +1050,27 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`
       }
     }
   }
+  /**
+   * The challenge a call to `tool` gets while the session's token lacks the
+   * tool's `scopes`, or `undefined` when it may run. Applied on the same terms
+   * as `canAccess` (see `toolsVisibleTo`): never without auth on a server that
+   * does not authenticate, and with nothing granted when a server that does
+   * has no auth for this session.
+   */
+  #scopeChallenge(tool) {
+    if (!tool.scopes?.length || !this.#auth && !this.#authRequired) {
+      return void 0;
+    }
+    const granted = grantedScopes(this.#auth);
+    const missing = tool.scopes.filter((scope) => !granted.includes(scope));
+    if (missing.length === 0) {
+      return void 0;
+    }
+    return {
+      description: `Insufficient scope for tool '${tool.name}': requires ${missing.join(" ")}`,
+      scopes: [.../* @__PURE__ */ new Set([...granted, ...tool.scopes])]
+    };
+  }
   /**
    * Sending rejects once the client has hung up, and these four
    * callers are synchronous, so the rejection has nowhere to go. Swallow it the
@@ -1636,6 +1677,14 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
             `Unknown tool: ${request.params.name}`
           );
         }
+        const challenge = this.#scopeChallenge(tool);
+        if (challenge) {
+          throw new McpError(
+            INSUFFICIENT_SCOPE_ERROR_CODE,
+            challenge.description,
+            { error: "insufficient_scope", required_scopes: challenge.scopes }
+          );
+        }
         let args = void 0;
         if (tool.parameters) {
           const parsed = await tool.parameters["~standard"].validate(
@@ -1980,6 +2029,11 @@ var OAUTH_INVALID_CLIENT_RESPONSE_HEADERS = {
   ...OAUTH_CREDENTIAL_RESPONSE_HEADERS,
   "WWW-Authenticate": 'Basic realm="oauth", charset="UTF-8"'
 };
+function grantedScopes(auth) {
+  const scopes = auth?.scopes;
+  const values = Array.isArray(scopes) ? scopes : scopes instanceof Set ? [...scopes] : [];
+  return values.filter((scope) => typeof scope === "string");
+}
 function stripBasePath(path, basePath) {
   if (!basePath) {
     return path;
@@ -2464,6 +2518,7 @@ var FastMCP = class extends FastMCPEventEmitter {
         const authenticate = this.#authenticate ? this.#memoizedAuthenticate() : void 0;
         this.#httpStreamServer = await startHTTPServer({
           ...authenticate ? { authenticate } : {},
+          beforeDispatch: ({ message, server }) => this.#answerScopeChallenge(message, server),
           cors: httpConfig.cors,
           createServer: async (request) => {
             let auth;
@@ -2511,6 +2566,7 @@ var FastMCP = class extends FastMCPEventEmitter {
         const authenticate = this.#authenticate ? this.#memoizedAuthenticate() : void 0;
         this.#httpStreamServer = await startHTTPServer({
           ...authenticate ? { authenticate } : {},
+          beforeDispatch: ({ message, server }) => this.#answerScopeChallenge(message, server),
           cors: httpConfig.cors,
           createServer: async (request) => {
             let auth;
@@ -2583,6 +2639,23 @@ var FastMCP = class extends FastMCPEventEmitter {
     }
     this.#serverState = "stopped" /* Stopped */;
   }
+  /**
+   * mcp-proxy's `beforeDispatch`: answers a `tools/call` the session's token
+   * lacks scopes for with MCP's 403 scope challenge. It runs for every message
+   * POSTed over HTTP, after `authenticate` and `updateAuth`, because once a
+   * message is dispatched the SDK answers it on a 200.
+   */
+  #answerScopeChallenge(message, session) {
+    const challenge = session.scopeChallengeFor(message);
+    if (!challenge) {
+      return void 0;
+    }
+    const { id } = message;
+    return this.#createInsufficientScopeResponse(
+      challenge,
+      typeof id === "number" || typeof id === "string" ? id : null
+    );
+  }
   /**
    * Connects `session` to `transport` and lists it in `sessions` until the
    * transport closes. The close is watched from before the session connects,
@@ -2609,6 +2682,54 @@ var FastMCP = class extends FastMCPEventEmitter {
       session
     });
   }
+  /**
+   * Builds MCP's 403 `insufficient_scope` challenge (2025-11-25, Scope
+   * Challenge Handling). `scope` lists what the client should re-authorize
+   * for, and `resource_metadata` is added on the same terms as on the 401 (see
+   * `#createUnauthorizedResponse`).
+   *
+   * Clients such as the MCP SDK pick each parameter out with a simple pattern:
+   * the first match wins and a quoted value ends at the first quote. So the
+   * parameters come first, the description comes last, and it keeps only the
+   * characters RFC 6750 allows in it.
+   */
+  #createInsufficientScopeResponse(challenge, id) {
+    const oauth = this.#options.oauth;
+    const resource = oauth?.enabled ? oauth.protectedResource?.resource : void 0;
+    const wwwAuthenticateParts = [
+      'error="insufficient_scope"',
+      `scope="${challenge.scopes.filter((scope) => SCOPE_TOKEN.test(scope)).join(" ")}"`
+    ];
+    if (resource) {
+      wwwAuthenticateParts.push(
+        `resource_metadata="${protectedResourceMetadataUrl(resource)}"`
+      );
+    }
+    wwwAuthenticateParts.push(
+      `error_description="${challenge.description.replace(/[^\x20\x21\x23-\x5B\x5D-\x7E]/g, "")}"`
+    );
+    return new Response(
+      JSON.stringify({
+        error: {
+          code: INSUFFICIENT_SCOPE_ERROR_CODE,
+          data: {
+            error: "insufficient_scope",
+            required_scopes: challenge.scopes
+          },
+          message: challenge.description
+        },
+        id,
+        jsonrpc: "2.0"
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "WWW-Authenticate": `Bearer ${wwwAuthenticateParts.join(", ")}`
+        },
+        status: 403
+      }
+    );
+  }
   /**
    * Creates a new FastMCPSession instance with the current configuration.
    * Used both for regular sessions and stateless requests.
@@ -3314,12 +3435,11 @@ var FastMCP = class extends FastMCPEventEmitter {
    * Rejects a failed authentication result before it can become a session.
    *
    * Authentication is REQUIRED whenever an `authenticate` function is
-   * configured. mcp-proxy gates the HTTP Stream endpoint before `createServer`
-   * runs, but it does not gate the SSE endpoint it serves at `/sse` by default:
-   * `handleSSERequest` never receives `authenticate`. Throwing here is what
-   * stops `/sse` from handing out a session — with access to every tool, since
-   * `#createSession` skips `canAccess` filtering when `auth` is falsy — to a
-   * client that `/mcp` would have answered with a 401.
+   * configured. mcp-proxy answers a failed `authenticate` with a 401 before
+   * `createServer` runs: on the HTTP Stream endpoint, and since 6.8.0 on the
+   * SSE endpoint's `GET /sse` and every `POST /messages` too. This is the
+   * second gate, so a client that `/mcp` would answer with a 401 never gets a
+   * session, whichever endpoint it uses.
    *
    * The falsy test matches mcp-proxy's own check so that both endpoints agree
    * on what counts as a failed authentication. Returning a nullish value is the
@@ -3394,4 +3514,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-ULNQF5KG.js.map
+//# sourceMappingURL=chunk-5JRRZ7MN.js.map