Document relatedRequestId routing for bidirectional MCP streams

Add comprehensive documentation for the relatedRequestId routing feature
that enables proper server-to-client request routing in Streamable HTTP
transport. This feature is essential for bidirectional communication
patterns like elicitation where the server needs to send requests back
to the client while maintaining proper request-response pairing.

Related: cloudflare/agents#654

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

Co-Authored-By: Claude <[email protected]>

Author: github-actions[bot]

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

@@ -109,3 +109,68 @@ With these few changes, your MCP server will support both transport methods, mak
 While most MCP clients have not yet adopted the new Streamable HTTP transport, you can start testing it today using [`mcp-remote`](https://www.npmjs.com/package/mcp-remote), an adapter that lets MCP clients that otherwise only support local connections work with remote MCP servers.
 
 Follow [this guide](/agents/guides/test-remote-mcp-server/) for instructions on how to connect to your remote MCP server from Claude Desktop, Cursor, Windsurf, and other local MCP clients, using the [`mcp-remote` local proxy](https://www.npmjs.com/package/mcp-remote).
+
+## Bidirectional streams with relatedRequestId
+
+The Streamable HTTP transport enables true bidirectional communication between MCP clients and servers, allowing servers to initiate requests back to clients while maintaining the correct request-response pairing. This is essential for features like [elicitation](/agents/concepts/human-in-the-loop/), where the server needs to request input from the user during tool execution.
+
+### How relatedRequestId routing works
+
+When a client sends a request to an MCP server over Streamable HTTP, the server maintains a mapping between the request ID and the HTTP stream. If the server needs to send a server-to-client request (such as `elicitation/create`) while processing the original request, it can use the `relatedRequestId` option to route that message through the same stream.
+
+The `WorkerTransport` class automatically handles this routing by:
+
+1. Mapping each client request ID to its originating HTTP stream
+2. Using the `relatedRequestId` option from `TransportSendOptions` to determine which stream should receive server-initiated requests
+3. Falling back to a standalone GET stream for messages without a `relatedRequestId`
+
+### When to use relatedRequestId
+
+Use `relatedRequestId` when your MCP server needs to:
+
+- Request user input during tool execution (elicitation)
+- Send progress updates related to a specific client request
+- Make callbacks to the client in response to an ongoing operation
+
+Without `relatedRequestId`, server-initiated messages are sent through a separate standalone stream, which may not maintain the proper context for request-response pairing.
+
+### Implementation example
+
+The Agents SDK handles `relatedRequestId` routing automatically when using `McpAgent`. Here is how the transport layer routes messages:
+
+<TypeScriptExample>
+
+```ts title="Transport routing implementation"
+import type {
+  Transport,
+  TransportSendOptions
+} from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+
+// Simplified example of relatedRequestId routing
+async send(
+  message: JSONRPCMessage,
+  options?: TransportSendOptions
+): Promise<void> {
+  // Check relatedRequestId first to route server-to-client requests
+  // through the same stream as the originating client request
+  let requestId = options?.relatedRequestId;
+
+  // Then override with message.id for responses/errors
+  if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+    requestId = message.id;
+  }
+
+  // Route to the appropriate stream based on requestId
+  const stream = this.getStreamForRequest(requestId);
+  await stream.send(message);
+}
+```
+
+</TypeScriptExample>
+
+This routing mechanism ensures that server-initiated requests maintain the proper context and are delivered through the correct bidirectional stream, enabling seamless request-response flows for complex interactions like elicitation.
+
+:::note
+The `relatedRequestId` routing feature is specific to Streamable HTTP transport and is handled automatically by the `WorkerTransport` class in the Agents SDK. SSE transport does not support this bidirectional routing pattern.
+:::