docs: Add MCP SDK v1.25.1 documentation

Document the MCP SDK upgrade from v1.23.0 to v1.25.1 with the following updates:

- Add new section on using MCP SDK directly without Agents SDK
- Document the new mcp-server example using WebStandardStreamableHTTPServerTransport
- Add documentation for new WorkerTransport options:
  - onsessionclosed callback for session cleanup
  - eventStore for connection resumability support
  - retryInterval for SSE polling behavior control

Related to cloudflare/agents#752

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: github-actions[bot]

src/content/docs/agents/model-context-protocol/mcp-handler-api.mdx

@@ -115,6 +115,99 @@ const handler = createMcpHandler(server, { transport });
 
 </TypeScriptExample>
 
+#### sessionIdGenerator
+
+A function that generates a unique session ID for each transport connection. Return `undefined` to disable session management and run in stateless mode.
+
+**Default:** Generates a cryptographically secure random UUID
+
+#### enableJsonResponse
+
+Enable traditional Request/Response mode, disabling streaming. When enabled, responses are returned as JSON instead of using Server-Sent Events.
+
+**Default:** `false`
+
+#### onsessioninitialized
+
+Callback fired when a new session is initialized. Receives the session ID as a parameter.
+
+<TypeScriptExample>
+
+```ts
+const handler = createMcpHandler(server, {
+	onsessioninitialized: (sessionId) => {
+		console.log(`New session started: ${sessionId}`);
+	},
+});
+```
+
+</TypeScriptExample>
+
+#### onsessionclosed
+
+Callback fired when a session is closed via DELETE request. Receives the session ID as a parameter.
+
+<TypeScriptExample>
+
+```ts
+const handler = createMcpHandler(server, {
+	onsessionclosed: (sessionId) => {
+		console.log(`Session closed: ${sessionId}`);
+	},
+});
+```
+
+</TypeScriptExample>
+
+#### eventStore
+
+Event store for resumability support. When provided, enables clients to reconnect and resume messages using Last-Event-ID. This allows clients to recover from connection interruptions without losing messages.
+
+<TypeScriptExample>
+
+```ts
+import { createMcpHandler, type EventStore } from "agents/mcp";
+
+const eventStore: EventStore = {
+	storeEvent: async (streamId, message) => {
+		// Store event and return unique event ID
+		const eventId = crypto.randomUUID();
+		await myStorage.put(`event:${eventId}`, { streamId, message });
+		return eventId;
+	},
+	replayEventsAfter: async (lastEventId, sender) => {
+		// Replay events after the given event ID
+		const events = await myStorage.getEventsAfter(lastEventId);
+		for (const { eventId, message } of events) {
+			await sender.send(eventId, message);
+		}
+		return streamId;
+	},
+	getStreamIdForEventId: async (eventId) => {
+		const event = await myStorage.get(`event:${eventId}`);
+		return event?.streamId;
+	},
+};
+
+const handler = createMcpHandler(server, { eventStore });
+```
+
+</TypeScriptExample>
+
+#### retryInterval
+
+Retry interval in milliseconds to suggest to clients in SSE retry field. Controls client reconnection timing for polling behavior.
+
+<TypeScriptExample>
+
+```ts
+const handler = createMcpHandler(server, {
+	retryInterval: 5000, // Suggest clients retry every 5 seconds
+});
+```
+
+</TypeScriptExample>
+
 ## Stateless MCP Servers
 
 Many MCP Servers are stateless, meaning they don't maintain any session state between requests. The `createMcpHandler` function is a lightweight alternative to the `McpAgent` class that can be used to serve an MCP server straight from a Worker. View the [complete example on GitHub](https://github.com/cloudflare/agents/tree/main/examples/mcp-worker).

src/content/docs/agents/model-context-protocol/transport.mdx

@@ -150,6 +150,56 @@ If you have an existing MCP server using the `McpAgent` class:
 - **Using state?** Use `createMcpHandler` with a `WorkerTransport` inside an [Agent](/agents/) class. See [Stateful MCP Servers](/agents/model-context-protocol/mcp-handler-api#stateful-mcp-servers) for details.
 - **Need SSE support?** Continue using `McpAgent` with `serveSSE()` for legacy client compatibility. See the [McpAgent API reference](/agents/model-context-protocol/mcp-agent-api/).
 
+## Using MCP SDK directly (without Agents SDK)
+
+For the simplest possible MCP server setup, you can use the `@modelcontextprotocol/sdk` package directly without the Agents SDK. This approach uses `WebStandardStreamableHTTPServerTransport` which works natively on Cloudflare Workers.
+
+View the [complete example on GitHub](https://github.com/cloudflare/agents/tree/main/examples/mcp-server).
+
+<TypeScriptExample>
+
+```ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { z } from "zod";
+
+const server = new McpServer({
+	name: "Hello MCP Server",
+	version: "1.0.0",
+});
+
+server.registerTool(
+	"hello",
+	{
+		description: "Returns a greeting message",
+		inputSchema: { name: z.string().optional() },
+	},
+	async ({ name }) => {
+		return {
+			content: [
+				{
+					text: `Hello, ${name ?? "World"}!`,
+					type: "text",
+				},
+			],
+		};
+	},
+);
+
+const transport = new WebStandardStreamableHTTPServerTransport();
+server.connect(transport);
+
+export default {
+	fetch: async (request: Request, _env: Env, _ctx: ExecutionContext) => {
+		return transport.handleRequest(request);
+	},
+};
+```
+
+</TypeScriptExample>
+
+This approach creates a stateless MCP server without session management. Each request is handled independently. If you need to add state management or use advanced features like elicitation, use an [Agent](/agents/) class with the [Agents SDK](/agents/) instead.
+
 ### Testing with MCP clients
 
 You can test your MCP server using an MCP client that supports remote connections, or use [`mcp-remote`](https://www.npmjs.com/package/mcp-remote), an adapter that lets MCP clients that only support local connections work with remote MCP servers.