fastmcp 4.13.1 → 4.14.0

package/README.md

@@ -903,6 +903,52 @@ By default, ping behavior is optimized for each transport type:
 
 This configurable approach helps reduce log verbosity and optimize performance for different usage scenarios.
 
+#### Keeping Long Tool Calls Alive (`streamKeepalive`)
+
+Pings travel on the standalone server-to-client stream, so they never keep an
+individual tool call's connection open — and in `stateless` mode that stream does
+not exist at all. A tool that runs for minutes without producing output leaves
+its response connection silent, and an idle-connection timeout in front of the
+server (AWS ALB defaults to 60 seconds) closes it before the result is written.
+
+This applies to **both** session modes. A stateful deployment keeps its
+standalone stream warm with pings while the connection carrying the tool call
+goes idle and is closed anyway; stateless has no standalone stream to begin
+with.
+
+`streamKeepalive` writes periodically to the in-flight tool call's own response
+stream, which is the connection that would otherwise be closed. It is opt-in:
+
+```ts
+const server = new FastMCP({
+  name: "My Server",
+  version: "1.0.0",
+  streamKeepalive: {
+    // Opt in; disabled by default
+    enabled: true,
+    // Keep comfortably below the shortest idle timeout on the path
+    intervalMs: 20000,
+  },
+});
+```
+
+Each keepalive is a `notifications/message` (level configurable via `logLevel`,
+default `debug`) tagged with the logger `fastmcp-keepalive`, related to the tool
+call being served. Keepalives start when a tool begins executing and stop when
+the request stops waiting for it — on success, error, timeout, or client
+cancellation — so idle connections stay quiet. Because the messages are related
+to the request, this works in stateful and `stateless` mode alike, and needs no
+client support beyond the standard logging notification.
+
+Limits worth knowing:
+
+- It has no effect with `httpStream.enableJsonResponse`, which buffers a single
+  JSON reply instead of streaming, so there is no open stream to write to.
+- It only covers tool calls. Other long-running requests (`resources/read`,
+  `prompts/get`) still write nothing until they finish.
+- On `stdio` there is no proxy to keep alive, so enabling it there only adds
+  notification traffic.
+
 ### Health-check Endpoint
 
 When you run FastMCP with the `httpStream` transport you can optionally expose a

package/dist/FastMCP.cjs

@@ -11,7 +11,7 @@
 
 
 
-var _chunkO72VCMGVcjs = require('./chunk-O72VCMGV.cjs');
+var _chunkXK5NJ5W2cjs = require('./chunk-XK5NJ5W2.cjs');
 
 
 
@@ -49,5 +49,5 @@ var _chunk5FVNY65Mcjs = require('./chunk-5FVNY65M.cjs');
 
 
 
-exports.AuthProvider = _chunk5FVNY65Mcjs.AuthProvider; exports.AzureProvider = _chunk5FVNY65Mcjs.AzureProvider; exports.DiscoveryDocumentCache = _chunkO72VCMGVcjs.DiscoveryDocumentCache; exports.FastMCP = _chunkO72VCMGVcjs.FastMCP; exports.FastMCPError = _chunkO72VCMGVcjs.FastMCPError; exports.FastMCPSession = _chunkO72VCMGVcjs.FastMCPSession; exports.GitHubProvider = _chunk5FVNY65Mcjs.GitHubProvider; exports.GoogleProvider = _chunk5FVNY65Mcjs.GoogleProvider; exports.MEDIA_FETCH_TIMEOUT_MS = _chunkO72VCMGVcjs.MEDIA_FETCH_TIMEOUT_MS; exports.OAuthProvider = _chunk5FVNY65Mcjs.OAuthProvider; exports.ServerState = _chunkO72VCMGVcjs.ServerState; exports.SessionError = _chunkO72VCMGVcjs.SessionError; exports.UnexpectedStateError = _chunkO72VCMGVcjs.UnexpectedStateError; exports.UserError = _chunkO72VCMGVcjs.UserError; exports.audioContent = _chunkO72VCMGVcjs.audioContent; exports.getAuthSession = _chunk5FVNY65Mcjs.getAuthSession; exports.imageContent = _chunkO72VCMGVcjs.imageContent; exports.jsonSchemaAdapter = _chunkO72VCMGVcjs.jsonSchemaAdapter; exports.requireAll = _chunk5FVNY65Mcjs.requireAll; exports.requireAny = _chunk5FVNY65Mcjs.requireAny; exports.requireAuth = _chunk5FVNY65Mcjs.requireAuth; exports.requireRole = _chunk5FVNY65Mcjs.requireRole; exports.requireScopes = _chunk5FVNY65Mcjs.requireScopes;
+exports.AuthProvider = _chunk5FVNY65Mcjs.AuthProvider; exports.AzureProvider = _chunk5FVNY65Mcjs.AzureProvider; exports.DiscoveryDocumentCache = _chunkXK5NJ5W2cjs.DiscoveryDocumentCache; exports.FastMCP = _chunkXK5NJ5W2cjs.FastMCP; exports.FastMCPError = _chunkXK5NJ5W2cjs.FastMCPError; exports.FastMCPSession = _chunkXK5NJ5W2cjs.FastMCPSession; exports.GitHubProvider = _chunk5FVNY65Mcjs.GitHubProvider; exports.GoogleProvider = _chunk5FVNY65Mcjs.GoogleProvider; exports.MEDIA_FETCH_TIMEOUT_MS = _chunkXK5NJ5W2cjs.MEDIA_FETCH_TIMEOUT_MS; exports.OAuthProvider = _chunk5FVNY65Mcjs.OAuthProvider; exports.ServerState = _chunkXK5NJ5W2cjs.ServerState; exports.SessionError = _chunkXK5NJ5W2cjs.SessionError; exports.UnexpectedStateError = _chunkXK5NJ5W2cjs.UnexpectedStateError; exports.UserError = _chunkXK5NJ5W2cjs.UserError; exports.audioContent = _chunkXK5NJ5W2cjs.audioContent; exports.getAuthSession = _chunk5FVNY65Mcjs.getAuthSession; exports.imageContent = _chunkXK5NJ5W2cjs.imageContent; exports.jsonSchemaAdapter = _chunkXK5NJ5W2cjs.jsonSchemaAdapter; exports.requireAll = _chunk5FVNY65Mcjs.requireAll; exports.requireAny = _chunk5FVNY65Mcjs.requireAny; exports.requireAuth = _chunk5FVNY65Mcjs.requireAuth; exports.requireRole = _chunk5FVNY65Mcjs.requireRole; exports.requireScopes = _chunk5FVNY65Mcjs.requireScopes;
 //# sourceMappingURL=FastMCP.cjs.map

package/dist/FastMCP.d.cts

@@ -697,6 +697,36 @@ type ServerOptions<T extends FastMCPSessionAuth> = {
          */
         enabled?: boolean;
     };
+    /**
+     * Writes periodically to an in-flight tool call's own response stream, so a
+     * proxy or load balancer does not close the connection as idle while a
+     * long-running tool produces no output.
+     *
+     * Unlike {@link ServerOptions.ping}, these messages are related to the
+     * request being served, so they travel on that request's stream instead of
+     * the standalone server-to-client stream. That makes them the only option
+     * that works with `httpStream.stateless`, where no standing server-to-client
+     * stream exists.
+     */
+    streamKeepalive?: {
+        /**
+         * Whether to write keepalives. Opt-in.
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Interval between keepalives. Keep it comfortably below the shortest idle
+         * timeout on the path (AWS ALB defaults to 60s). Values below 1ms fall back
+         * to the default.
+         * @default 20000 (20s)
+         */
+        intervalMs?: number;
+        /**
+         * Level reported on the keepalive notification.
+         * @default 'debug'
+         */
+        logLevel?: LoggingLevel;
+    };
     /**
      * General utilities
      */
@@ -840,7 +870,7 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
     get server(): Server;
     get sessionId(): string | undefined;
     set sessionId(value: string | undefined);
-    constructor({ auth, instructions, logger, name, onToolCall, ping, prompts, resources, resourcesTemplates, roots, sessionId, stateless, tools, transportType, utils, version, }: {
+    constructor({ auth, instructions, logger, name, onToolCall, ping, prompts, resources, resourcesTemplates, roots, sessionId, stateless, streamKeepalive, tools, transportType, utils, version, }: {
         auth?: T;
         instructions?: string;
         logger: Logger;
@@ -853,6 +883,7 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
         roots?: ServerOptions<T>["roots"];
         sessionId?: string;
         stateless?: boolean;
+        streamKeepalive?: ServerOptions<T>["streamKeepalive"];
         tools: Tool<T>[];
         transportType?: "httpStream" | "stdio";
         utils?: ServerOptions<T>["utils"];

package/dist/FastMCP.d.ts

@@ -697,6 +697,36 @@ type ServerOptions<T extends FastMCPSessionAuth> = {
          */
         enabled?: boolean;
     };
+    /**
+     * Writes periodically to an in-flight tool call's own response stream, so a
+     * proxy or load balancer does not close the connection as idle while a
+     * long-running tool produces no output.
+     *
+     * Unlike {@link ServerOptions.ping}, these messages are related to the
+     * request being served, so they travel on that request's stream instead of
+     * the standalone server-to-client stream. That makes them the only option
+     * that works with `httpStream.stateless`, where no standing server-to-client
+     * stream exists.
+     */
+    streamKeepalive?: {
+        /**
+         * Whether to write keepalives. Opt-in.
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Interval between keepalives. Keep it comfortably below the shortest idle
+         * timeout on the path (AWS ALB defaults to 60s). Values below 1ms fall back
+         * to the default.
+         * @default 20000 (20s)
+         */
+        intervalMs?: number;
+        /**
+         * Level reported on the keepalive notification.
+         * @default 'debug'
+         */
+        logLevel?: LoggingLevel;
+    };
     /**
      * General utilities
      */
@@ -840,7 +870,7 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
     get server(): Server;
     get sessionId(): string | undefined;
     set sessionId(value: string | undefined);
-    constructor({ auth, instructions, logger, name, onToolCall, ping, prompts, resources, resourcesTemplates, roots, sessionId, stateless, tools, transportType, utils, version, }: {
+    constructor({ auth, instructions, logger, name, onToolCall, ping, prompts, resources, resourcesTemplates, roots, sessionId, stateless, streamKeepalive, tools, transportType, utils, version, }: {
         auth?: T;
         instructions?: string;
         logger: Logger;
@@ -853,6 +883,7 @@ declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth>
         roots?: ServerOptions<T>["roots"];
         sessionId?: string;
         stateless?: boolean;
+        streamKeepalive?: ServerOptions<T>["streamKeepalive"];
         tools: Tool<T>[];
         transportType?: "httpStream" | "stdio";
         utils?: ServerOptions<T>["utils"];

package/dist/FastMCP.js

@@ -11,7 +11,7 @@ import {
   audioContent,
   imageContent,
   jsonSchemaAdapter
-} from "./chunk-3BMGHXXY.js";
+} from "./chunk-LMDMFMPI.js";
 import {
   AuthProvider,
   AzureProvider,

package/dist/{chunk-3BMGHXXY.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) {
@@ -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,
@@ -2062,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,
@@ -2676,4 +2730,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-3BMGHXXY.js.map
+//# sourceMappingURL=chunk-LMDMFMPI.js.map