mcp-proxy 6.5.4 → 6.5.5

package/README.md

@@ -55,6 +55,8 @@ options:
 - `--connectionTimeout`: Timeout in milliseconds for the initial connection to the MCP server (default: 60000, which is 60 seconds)
 - `--requestTimeout`: Timeout in milliseconds for requests to the MCP server (default: 300000, which is 5 minutes)
 - `--keepAliveTimeout`: HTTP keep-alive timeout in milliseconds for stateful stream sessions (default: 300000, which is 5 minutes)
+- `--eventStore`: Enable the streamable HTTP transport's resumability event store, which lets clients replay missed messages after a reconnect (default: `true`). Use `--no-eventStore` to disable it entirely for request/response-only deployments that don't need replay and would rather avoid the memory overhead. See [Resumability and memory use](#resumability-and-memory-use).
+- `--eventStoreMaxEvents`: Maximum number of buffered events the resumability event store retains per session before it evicts the oldest (default: 1000). Ignored when `--no-eventStore` is set.
 - `--debug`: Enable debug logging
 - `--shell`: Spawn the server via the user's shell
 - `--apiKey`: API key for authenticating requests (uses X-API-Key header)
@@ -417,7 +419,6 @@ const { close } = await startHTTPServer({
   createServer: async () => {
     return new Server();
   },
-  eventStore: new InMemoryEventStore(),
   port: 8080,
   stateless: false, // Optional: enable stateless mode for streamable HTTP transport
 });
@@ -428,7 +429,8 @@ close();
 Options:
 
 - `createServer`: Function that creates a new server instance for each connection
-- `eventStore`: Event store for streamable HTTP transport (optional)
+- `eventStore`: Event store for the streamable HTTP transport's resumability support (optional). Pass `false` to disable resumability entirely; omit to get a fresh, bounded `InMemoryEventStore` per session (see `eventStoreMaxEvents`); pass an `EventStore` instance to bring your own (e.g. persistent/cross-process), shared across all sessions. See [Resumability and memory use](#resumability-and-memory-use).
+- `eventStoreMaxEvents`: Caps how many events the auto-created per-session `InMemoryEventStore` retains before evicting the oldest (default: 1000). Only applies when `eventStore` is not explicitly provided.
 - `port`: Port number to listen on
 - `host`: Host to bind to (default: "::")
 - `keepAliveTimeout`: HTTP keep-alive timeout in milliseconds for stateful stream sessions (default: 300000)
@@ -441,6 +443,25 @@ Options:
 - `onClose`: Callback when a server disconnects (optional)
 - `onUnhandledRequest`: Callback for unhandled HTTP requests (optional)
 
+##### Resumability and memory use
+
+The streamable HTTP transport can retain server→client messages so a client
+that reconnects with a `Last-Event-ID` can resume where it left off. By
+default, `mcp-proxy` gives each session its own `InMemoryEventStore` capped at
+1000 buffered events (oldest evicted first via `--eventStoreMaxEvents` /
+`eventStoreMaxEvents`), so a long-lived session's memory use stays bounded
+instead of growing for as long as the process runs.
+
+If you don't need resume-after-reconnect - for example, a short-lived
+request/response deployment - disable the store entirely with
+`--no-eventStore` (CLI) or `eventStore: false` (library) to drop the
+resumability bookkeeping altogether.
+
+If you need resumability with a larger replay window or one backed by shared
+storage (e.g. Redis) across multiple proxy processes, pass your own
+`EventStore` implementation as `eventStore`; in that case you're responsible
+for bounding its size.
+
 #### `startStdioServer`
 
 Starts a proxy that listens on a `stdio`, and sends messages to the attached `sse` or `streamable` server.

package/dist/bin/mcp-proxy.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { D as __toESM, E as __commonJSMin, a as startHTTPServer, i as Client, n as serializeMessage, o as proxyServer, r as Server, t as ReadBuffer, w as InMemoryEventStore } from "../stdio-BQunCFor.mjs";
+import { D as __toESM, E as __commonJSMin, a as startHTTPServer, i as Client, n as serializeMessage, o as proxyServer, r as Server, t as ReadBuffer } from "../stdio-Be0Fx2iV.mjs";
 import { createRequire } from "node:module";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
 import { format, inspect } from "util";
@@ -5067,6 +5067,16 @@ const argv = await yargs_default(hideBin(process.argv)).scriptName("mcp-proxy").
 		describe: "The endpoint to listen on",
 		type: "string"
 	},
+	eventStore: {
+		default: true,
+		describe: "Enable the streamable HTTP transport's resumability event store, which lets clients replay missed messages after a reconnect. Use --no-eventStore to disable it entirely for request/response-only deployments that don't need this and would rather avoid the memory overhead",
+		type: "boolean"
+	},
+	eventStoreMaxEvents: {
+		default: 1e3,
+		describe: "Maximum number of buffered events the resumability event store retains (per session) before it evicts the oldest; bounds memory use. Ignored when --no-eventStore is set",
+		type: "number"
+	},
 	gracefulShutdownTimeout: {
 		default: 5e3,
 		describe: "The timeout (in milliseconds) for graceful shutdown",
@@ -5139,6 +5149,10 @@ const argv = await yargs_default(hideBin(process.argv)).scriptName("mcp-proxy").
 		type: "string"
 	}
 }).help().parseAsync();
+if (!(argv.eventStoreMaxEvents >= 1)) {
+	console.error(`Error: --eventStoreMaxEvents must be a number >= 1 (got ${String(argv.eventStoreMaxEvents)}). Use --no-eventStore to disable the event store instead.`);
+	process.exit(1);
+}
 const corsOption = argv.corsAddAllowedHeader && argv.corsAddAllowedHeader.length > 0 ? { allowedHeaders: [...[
 	"Content-Type",
 	"Authorization",
@@ -5200,7 +5214,8 @@ const proxy = async () => {
 		apiKey: argv.apiKey,
 		cors: corsOption,
 		createServer,
-		eventStore: new InMemoryEventStore(),
+		eventStore: argv.eventStore ? void 0 : false,
+		eventStoreMaxEvents: argv.eventStoreMaxEvents,
 		host: argv.host,
 		keepAliveTimeout: argv.keepAliveTimeout,
 		port: argv.port,