Pass props to do streamable

.changeset/fair-kings-grab.md

@@ -0,0 +1,5 @@
+---
+"agents": patch
+---
+
+Ensure we are passing ctx.props to McpAgent for the Streamable transport

packages/agents/src/mcp/index.ts

@@ -949,6 +949,7 @@ export abstract class McpAgent<
           const isInitialized = await doStub.isInitialized();
 
           if (isInitializationRequest) {
+            await doStub._init(ctx.props);
             await doStub.setInitialized();
           } else if (!isInitialized) {
             // if we have gotten here, then a session id that was never initialized

packages/agents/src/tests/mcp-sse.test.ts

@@ -76,7 +76,7 @@ describe("test", () => {
     expect(jsonResponse.jsonrpc).toBe("2.0");
     expect(jsonResponse.id).toBe("1");
     expect(jsonResponse.result.tools).toBeDefined();
-    expect(jsonResponse.result.tools.length).toBe(1);
+    expect(jsonResponse.result.tools.length).toBe(2);
     expect(jsonResponse.result.tools[0]).toEqual({
       name: "greet",
       description: "A simple greeting tool",
@@ -110,7 +110,7 @@ describe("test", () => {
     const sessionId = lines[1].split("=")[1];
     expect(sessionId).toBeDefined();
 
-    // send a message to the session to list the tools
+    // send a message to the session to invoke the greet tool
     const toolsRequest = new Request(
       `http://example.com/sse/message?sessionId=${sessionId}`,
       {
@@ -156,4 +156,66 @@ describe("test", () => {
       },
     });
   });
+
+  it("should pass props to the agent", async () => {
+    const ctx = createExecutionContext();
+
+    const request = new Request("http://example.com/sse");
+    const sseStream = await worker.fetch(request, env, ctx);
+
+    const reader = sseStream.body?.getReader();
+    let { done, value } = await reader!.read();
+    const event = new TextDecoder().decode(value);
+
+    // parse the session id from the event
+    const lines = event.split("\n");
+    const sessionId = lines[1].split("=")[1];
+    expect(sessionId).toBeDefined();
+
+    // send a message to the session to invoke the getPropsTestValue tool
+    const toolsRequest = new Request(
+      `http://example.com/sse/message?sessionId=${sessionId}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          method: "tools/call",
+          id: "2",
+          params: {
+            name: "getPropsTestValue",
+            arguments: {},
+          },
+        }),
+      }
+    );
+
+    const toolsResponse = await worker.fetch(toolsRequest, env, ctx);
+    expect(toolsResponse.status).toBe(202);
+    expect(toolsResponse.headers.get("Content-Type")).toBe("text/event-stream");
+    expect(await toolsResponse.text()).toBe("Accepted");
+
+    ({ done, value } = await reader!.read());
+
+    expect(done).toBe(false);
+    const toolsEvent = new TextDecoder().decode(value);
+    const jsonResponse = JSON.parse(
+      toolsEvent.split("\n")[1].replace("data: ", "")
+    );
+
+    expect(jsonResponse).toEqual({
+      jsonrpc: "2.0",
+      id: "2",
+      result: {
+        content: [
+          {
+            type: "text",
+            text: "123",
+          },
+        ],
+      },
+    });
+  });
 });

packages/agents/src/tests/mcp-streamable-http.test.ts

@@ -477,4 +477,46 @@ describe("McpAgent Streamable HTTP Transport", () => {
     expect(text2).toContain('"id":"req-2"');
     expect(text2).toContain("Hello, Connection2"); // tools/call result
   });
+
+  it("should pass props to the agent", async () => {
+    const ctx = createExecutionContext();
+    const sessionId = await initializeServer(ctx);
+
+    const toolCallMessage: JSONRPCMessage = {
+      jsonrpc: "2.0",
+      method: "tools/call",
+      params: {
+        name: "getPropsTestValue",
+        arguments: {},
+      },
+      id: "call-1",
+    };
+
+    const response = await sendPostRequest(
+      ctx,
+      baseUrl,
+      toolCallMessage,
+      sessionId
+    );
+    expect(response.status).toBe(200);
+
+    const text = await readSSEEvent(response);
+    const eventLines = text.split("\n");
+    const dataLine = eventLines.find((line) => line.startsWith("data:"));
+    expect(dataLine).toBeDefined();
+
+    const eventData = JSON.parse(dataLine!.substring(5));
+    expect(eventData).toMatchObject({
+      jsonrpc: "2.0",
+      result: {
+        content: [
+          {
+            type: "text",
+            text: "123",
+          },
+        ],
+      },
+      id: "call-1",
+    });
+  });
 });

packages/agents/src/tests/worker.ts

@@ -7,7 +7,13 @@ export type Env = {
   MCP_OBJECT: DurableObjectNamespace<McpAgent>;
 };
 
-export class TestMcpAgent extends McpAgent {
+type State = unknown;
+
+type Props = {
+  testValue: string;
+};
+
+export class TestMcpAgent extends McpAgent<Env, State, Props> {
   server = new McpServer(
     { name: "test-server", version: "1.0.0" },
     { capabilities: { logging: {} } }
@@ -22,13 +28,28 @@ export class TestMcpAgent extends McpAgent {
         return { content: [{ type: "text", text: `Hello, ${name}!` }] };
       }
     );
+
+    this.server.tool(
+      "getPropsTestValue",
+      {},
+      async (): Promise<CallToolResult> => {
+        return {
+          content: [{ type: "text", text: this.props.testValue }],
+        };
+      }
+    );
   }
 }
 
 export default {
   fetch(request: Request, env: Env, ctx: ExecutionContext) {
     const url = new URL(request.url);
 
+    // set some props that should be passed init
+    ctx.props = {
+      testValue: "123",
+    };
+
     if (url.pathname === "/sse" || url.pathname === "/sse/message") {
       return TestMcpAgent.serveSSE("/sse").fetch(request, env, ctx);
     }