fastmcp 4.13.0 → 4.14.0

package/dist/{chunk-HIIPZVNY.js → chunk-LMDMFMPI.js}

@@ -355,6 +355,8 @@ function assertToolSchemas(tool) {
     assertStandardSchema(tool.name, "outputSchema", tool.outputSchema);
   }
 }
+var STREAM_KEEPALIVE_LOGGER = "fastmcp-keepalive";
+var STREAM_KEEPALIVE_DEFAULT_INTERVAL_MS = 2e4;
 var TextContentZodSchema = z.object({
   /**
    * The text content of the message.
@@ -483,6 +485,7 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
    * instance — so capabilities can never be inferred here.
    */
   #stateless;
+  #streamKeepaliveConfig;
   /**
    * Resource URIs the connected client has subscribed to via
    * `resources/subscribe`. Used to scope `notifications/resources/updated`
@@ -503,6 +506,7 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
     roots,
     sessionId,
     stateless = false,
+    streamKeepalive,
     tools,
     transportType,
     utils,
@@ -516,6 +520,7 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
     this.#rootsConfig = roots;
     this.#sessionId = sessionId;
     this.#stateless = stateless;
+    this.#streamKeepaliveConfig = streamKeepalive;
     this.#needsEventLoopFlush = transportType === "httpStream";
     if (tools.length) {
       this.#capabilities.tools = {};
@@ -843,6 +848,44 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
       logLevel: pingConfig.logLevel || "debug"
     };
   }
+  /**
+   * Periodically writes to the response stream of an in-flight tool call, so an
+   * idle-connection timeout (proxy, load balancer) does not close it while a
+   * long-running tool produces no output of its own.
+   *
+   * The notification is related to the tool call, so it travels on that
+   * request's own stream, which is the only server-to-client route that exists
+   * when running stateless.
+   *
+   * @returns a function that stops the keepalive.
+   */
+  #startStreamKeepalive(extra, toolName) {
+    const config = this.#streamKeepaliveConfig;
+    if (!config?.enabled) {
+      return () => {
+      };
+    }
+    const intervalMs = config.intervalMs && config.intervalMs > 0 ? config.intervalMs : STREAM_KEEPALIVE_DEFAULT_INTERVAL_MS;
+    const timer = setInterval(() => {
+      extra.sendNotification({
+        method: "notifications/message",
+        params: {
+          data: { message: `keepalive while '${toolName}' is running` },
+          level: config.logLevel ?? "debug",
+          logger: STREAM_KEEPALIVE_LOGGER
+        }
+      }).catch((error) => {
+        this.#logger.debug(
+          `[FastMCP debug] stream keepalive for '${toolName}' failed:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      });
+    }, intervalMs);
+    timer.unref?.();
+    const stop = () => clearInterval(timer);
+    extra.signal?.addEventListener("abort", stop, { once: true });
+    return stop;
+  }
   async #validateStructuredContent(tool, value, toolName) {
     if (!tool.outputSchema) {
       return value;
@@ -1260,169 +1303,178 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
         tools: cachedToolsList
       };
     });
-    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const tool = toolsMap.get(request.params.name);
-      if (!tool) {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          `Unknown tool: ${request.params.name}`
-        );
-      }
-      let args = void 0;
-      if (tool.parameters) {
-        const parsed = await tool.parameters["~standard"].validate(
-          request.params.arguments
-        );
-        if (parsed.issues) {
-          const friendlyErrors = this.#formatSchemaIssues(parsed.issues);
+    this.#server.setRequestHandler(
+      CallToolRequestSchema,
+      async (request, extra) => {
+        const tool = toolsMap.get(request.params.name);
+        if (!tool) {
           throw new McpError(
-            ErrorCode.InvalidParams,
-            `Tool '${request.params.name}' parameter validation failed: ${friendlyErrors}. Please check the parameter types and values according to the tool's schema.`
+            ErrorCode.MethodNotFound,
+            `Unknown tool: ${request.params.name}`
           );
         }
-        args = parsed.value;
-      }
-      const progressToken = request.params?._meta?.progressToken;
-      let result;
-      try {
-        const reportProgress = async (progress) => {
-          if (progressToken === void 0) {
-            return;
+        let args = void 0;
+        if (tool.parameters) {
+          const parsed = await tool.parameters["~standard"].validate(
+            request.params.arguments
+          );
+          if (parsed.issues) {
+            const friendlyErrors = this.#formatSchemaIssues(parsed.issues);
+            throw new McpError(
+              ErrorCode.InvalidParams,
+              `Tool '${request.params.name}' parameter validation failed: ${friendlyErrors}. Please check the parameter types and values according to the tool's schema.`
+            );
           }
-          try {
-            await this.#server.notification({
-              method: "notifications/progress",
-              params: {
-                ...progress,
-                progressToken
+          args = parsed.value;
+        }
+        const progressToken = request.params?._meta?.progressToken;
+        let result;
+        try {
+          const reportProgress = async (progress) => {
+            if (progressToken === void 0) {
+              return;
+            }
+            try {
+              await this.#server.notification({
+                method: "notifications/progress",
+                params: {
+                  ...progress,
+                  progressToken
+                }
+              });
+              if (this.#needsEventLoopFlush) {
+                await new Promise((resolve) => setImmediate(resolve));
               }
-            });
-            if (this.#needsEventLoopFlush) {
-              await new Promise((resolve) => setImmediate(resolve));
+            } catch (progressError) {
+              this.#logger.warn(
+                `[FastMCP warning] Failed to report progress for tool '${request.params.name}':`,
+                progressError instanceof Error ? progressError.message : String(progressError)
+              );
             }
-          } catch (progressError) {
-            this.#logger.warn(
-              `[FastMCP warning] Failed to report progress for tool '${request.params.name}':`,
-              progressError instanceof Error ? progressError.message : String(progressError)
-            );
-          }
-        };
-        const log = this.#createLog();
-        const streamContent = async (content) => {
-          const contentArray = Array.isArray(content) ? content : [content];
-          try {
-            await this.#server.notification({
-              method: "notifications/tool/streamContent",
-              params: {
-                content: contentArray,
-                toolName: request.params.name
+          };
+          const log = this.#createLog();
+          const streamContent = async (content) => {
+            const contentArray = Array.isArray(content) ? content : [content];
+            try {
+              await this.#server.notification({
+                method: "notifications/tool/streamContent",
+                params: {
+                  content: contentArray,
+                  toolName: request.params.name
+                }
+              });
+              if (this.#needsEventLoopFlush) {
+                await new Promise((resolve) => setImmediate(resolve));
               }
-            });
-            if (this.#needsEventLoopFlush) {
-              await new Promise((resolve) => setImmediate(resolve));
+            } catch (streamError) {
+              this.#logger.warn(
+                `[FastMCP warning] Failed to stream content for tool '${request.params.name}':`,
+                streamError instanceof Error ? streamError.message : String(streamError)
+              );
             }
-          } catch (streamError) {
-            this.#logger.warn(
-              `[FastMCP warning] Failed to stream content for tool '${request.params.name}':`,
-              streamError instanceof Error ? streamError.message : String(streamError)
-            );
+          };
+          if (this.#onToolCall) {
+            await this.#onToolCall({
+              arguments: args ?? {},
+              toolName: request.params.name
+            });
           }
-        };
-        if (this.#onToolCall) {
-          await this.#onToolCall({
-            arguments: args ?? {},
-            toolName: request.params.name
-          });
-        }
-        const executeToolPromise = tool.execute(args, {
-          client: {
-            version: this.#server.getClientVersion()
-          },
-          elicit: (params, options) => this.#server.elicitInput(params, options),
-          log,
-          reportProgress,
-          requestId: typeof request.params?._meta?.requestId === "string" ? request.params._meta.requestId : void 0,
-          session: this.#auth,
-          sessionId: this.#sessionId,
-          streamContent
-        });
-        const maybeStringResult = await (tool.timeoutMs ? Promise.race([
-          executeToolPromise,
-          new Promise((_, reject) => {
-            const timeoutId = setTimeout(() => {
-              reject(
-                new UserError(
-                  `Tool '${request.params.name}' timed out after ${tool.timeoutMs}ms. Consider increasing timeoutMs or optimizing the tool implementation.`
-                )
+          const executeToolPromise = Promise.resolve(
+            tool.execute(args, {
+              client: {
+                version: this.#server.getClientVersion()
+              },
+              elicit: (params, options) => this.#server.elicitInput(params, options),
+              log,
+              reportProgress,
+              requestId: typeof request.params?._meta?.requestId === "string" ? request.params._meta.requestId : void 0,
+              session: this.#auth,
+              sessionId: this.#sessionId,
+              streamContent
+            })
+          );
+          const stopStreamKeepalive = this.#startStreamKeepalive(
+            extra,
+            request.params.name
+          );
+          const maybeStringResult = await (tool.timeoutMs ? Promise.race([
+            executeToolPromise,
+            new Promise((_, reject) => {
+              const timeoutId = setTimeout(() => {
+                reject(
+                  new UserError(
+                    `Tool '${request.params.name}' timed out after ${tool.timeoutMs}ms. Consider increasing timeoutMs or optimizing the tool implementation.`
+                  )
+                );
+              }, tool.timeoutMs);
+              executeToolPromise.then(
+                () => clearTimeout(timeoutId),
+                () => clearTimeout(timeoutId)
               );
-            }, tool.timeoutMs);
-            executeToolPromise.then(
-              () => clearTimeout(timeoutId),
-              () => clearTimeout(timeoutId)
-            );
-          })
-        ]) : executeToolPromise);
-        await delay(1);
-        if (maybeStringResult === void 0 || maybeStringResult === null) {
-          result = ContentResultZodSchema.parse({
-            content: []
-          });
-        } else if (typeof maybeStringResult === "string") {
-          result = ContentResultZodSchema.parse({
-            content: [{ text: maybeStringResult, type: "text" }]
-          });
-        } else if ("type" in maybeStringResult) {
-          result = ContentResultZodSchema.parse({
-            content: [maybeStringResult]
-          });
-        } else if ("content" in maybeStringResult) {
-          result = ContentResultZodSchema.parse(maybeStringResult);
-          if (result.structuredContent !== void 0 && tool.outputSchema) {
-            result.structuredContent = await this.#validateStructuredContent(
+            })
+          ]) : executeToolPromise).finally(stopStreamKeepalive);
+          await delay(1);
+          if (maybeStringResult === void 0 || maybeStringResult === null) {
+            result = ContentResultZodSchema.parse({
+              content: []
+            });
+          } else if (typeof maybeStringResult === "string") {
+            result = ContentResultZodSchema.parse({
+              content: [{ text: maybeStringResult, type: "text" }]
+            });
+          } else if ("type" in maybeStringResult) {
+            result = ContentResultZodSchema.parse({
+              content: [maybeStringResult]
+            });
+          } else if ("content" in maybeStringResult) {
+            result = ContentResultZodSchema.parse(maybeStringResult);
+            if (result.structuredContent !== void 0 && tool.outputSchema) {
+              result.structuredContent = await this.#validateStructuredContent(
+                tool,
+                result.structuredContent,
+                request.params.name
+              );
+            }
+          } else if (tool.outputSchema) {
+            const structuredContent = await this.#validateStructuredContent(
               tool,
-              result.structuredContent,
+              maybeStringResult,
               request.params.name
             );
+            result = ContentResultZodSchema.parse({
+              content: [
+                {
+                  text: JSON.stringify(structuredContent),
+                  type: "text"
+                }
+              ],
+              structuredContent
+            });
+          } else {
+            result = ContentResultZodSchema.parse(maybeStringResult);
           }
-        } else if (tool.outputSchema) {
-          const structuredContent = await this.#validateStructuredContent(
-            tool,
-            maybeStringResult,
-            request.params.name
-          );
-          result = ContentResultZodSchema.parse({
+        } catch (error) {
+          if (error instanceof UserError) {
+            return {
+              content: [{ text: error.message, type: "text" }],
+              isError: true,
+              ...error.extras ? { structuredContent: error.extras } : {}
+            };
+          }
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return {
             content: [
               {
-                text: JSON.stringify(structuredContent),
+                text: `Tool '${request.params.name}' execution failed: ${errorMessage}`,
                 type: "text"
               }
             ],
-            structuredContent
-          });
-        } else {
-          result = ContentResultZodSchema.parse(maybeStringResult);
-        }
-      } catch (error) {
-        if (error instanceof UserError) {
-          return {
-            content: [{ text: error.message, type: "text" }],
-            isError: true,
-            ...error.extras ? { structuredContent: error.extras } : {}
+            isError: true
           };
         }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-          content: [
-            {
-              text: `Tool '${request.params.name}' execution failed: ${errorMessage}`,
-              type: "text"
-            }
-          ],
-          isError: true
-        };
+        return result;
       }
-      return result;
-    });
+    );
   }
 };
 function camelToSnakeCase(str) {
@@ -1844,7 +1896,7 @@ var FastMCP = class extends FastMCPEventEmitter {
         try {
           auth = await this.#authenticate(
             void 0
-          );
+          ) ?? void 0;
         } catch (error) {
           this.#logger.error(
             "[FastMCP error] Authentication failed for stdio transport:",
@@ -1863,6 +1915,7 @@ var FastMCP = class extends FastMCPEventEmitter {
         resources: this.#resources,
         resourcesTemplates: this.#resourcesTemplates,
         roots: this.#options.roots,
+        streamKeepalive: this.#options.streamKeepalive,
         tools: this.#tools,
         transportType: "stdio",
         utils: this.#options.utils,
@@ -1922,12 +1975,9 @@ var FastMCP = class extends FastMCPEventEmitter {
           createServer: async (request) => {
             let auth;
             if (this.#authenticate) {
-              auth = await this.#authenticate(request);
-              if (auth === void 0 || auth === null) {
-                throw this.#createUnauthorizedResponse(
-                  "Authentication required"
-                );
-              }
+              auth = this.#requireAuthenticated(
+                await this.#authenticate(request)
+              );
             }
             const sessionId = Array.isArray(request.headers["mcp-session-id"]) ? request.headers["mcp-session-id"][0] : request.headers["mcp-session-id"];
             return this.#createSession(auth, sessionId, true);
@@ -1974,7 +2024,9 @@ var FastMCP = class extends FastMCPEventEmitter {
           createServer: async (request) => {
             let auth;
             if (this.#authenticate) {
-              auth = await this.#authenticate(request);
+              auth = this.#requireAuthenticated(
+                await this.#authenticate(request)
+              );
             }
             const sessionId = Array.isArray(request.headers["mcp-session-id"]) ? request.headers["mcp-session-id"][0] : request.headers["mcp-session-id"];
             return this.#createSession(auth, sessionId);
@@ -2063,6 +2115,7 @@ var FastMCP = class extends FastMCPEventEmitter {
       roots: this.#options.roots,
       sessionId,
       stateless,
+      streamKeepalive: this.#options.streamKeepalive,
       tools: allowedTools,
       transportType: "httpStream",
       utils: this.#options.utils,
@@ -2615,6 +2668,28 @@ 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.
+   *
+   * 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
+   * idiomatic way to signal failure, and is what the built-in OAuth
+   * `AuthProvider` does for a missing or invalid bearer token.
+   */
+  #requireAuthenticated(auth) {
+    if (!auth) {
+      throw this.#createUnauthorizedResponse("Authentication required");
+    }
+    return auth;
+  }
   /**
    * Notifies all sessions that the resources list has changed.
    */
@@ -2655,4 +2730,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-HIIPZVNY.js.map
+//# sourceMappingURL=chunk-LMDMFMPI.js.map