Mock Tooling Server crashes on standard MCP protocol methods sent by Python/Node.js agents

[pratapladhani]

Problem

The Mock Tooling Server (a365 develop start-mock-tooling-server) crashes or returns incorrect errors when used with Python and Node.js Agent Framework samples. These agents send standard MCP protocol methods that the mock server doesn't handle, causing the agent to fail during tool discovery and become non-functional.

The .NET Meeting Assistant sample works because its MCP client implementation happens to not send these methods, but the Python (microsoft/Agent365-Samples/python/) and Node.js (microsoft/Agent365-Samples/nodejs/openai/) samples use MCP client libraries that follow the full MCP Streamable HTTP specification.

Root Cause

The mock server's JSON-RPC handler at /agents/servers/{mcpServerName} only handles tools/list and tools/call methods. Any other method hits the catch-all -32601 Method not found error. Six specific gaps were identified:

1. notifications/initialized and other notifications - 500 error

Symptom: After MCP handshake, the Python MCP client sends notifications/initialized (a standard MCP lifecycle notification). The server returns a JSON-RPC error response instead of the MCP-spec-required 202 Accepted with no body. The MCP client then fails to parse the unexpected response and disconnects.

Expected: Return 202 Accepted with no body for any method starting with notifications/, per the MCP Streamable HTTP transport spec.

2. ping method - -32601 Method not found

Symptom: MCP clients send ping requests to verify connection health during tool discovery. The server returns a method-not-found error, causing the client to consider the connection unhealthy and retry/fail.

Expected: Return { "jsonrpc": "2.0", "id": ..., "result": {} } - a standard empty-result success response.

3. prompts/list - -32601 Method not found

Symptom: MCP clients enumerate server capabilities by calling prompts/list. The error response causes capability discovery to fail.

Expected: Return { "result": { "prompts": [] } } - the mock server has no prompts, which is valid.

4. resources/list - -32601 Method not found

Symptom: Same as above - MCP clients call resources/list during capability discovery.

Expected: Return { "result": { "resources": [] } } - the mock server has no resources, which is valid.

5. Unknown MCP server names - unhandled ArgumentException crash

Symptom: When an agent registers MCP servers like mcp_KnowledgeTools that have no mock implementation, ListToolsAsync() throws ArgumentException. The exception propagates to the global catch handler, returning a -32603 Internal Error. The agent interprets this as a fatal server error and stops tool discovery entirely.

Expected: For tools/list, return an empty tools array (graceful degradation). For tools/call, return a JSON-RPC error with code -32602 (invalid params) and a descriptive message.

6. Error responses lose the JSON-RPC id field

Symptom: The idValue variable is declared inside the try block, so the catch handler can't access it and returns "id": null. Per JSON-RPC 2.0 spec, the response id must match the request id. When it doesn't match, the MCP client can't correlate the error to the original request.

Expected: Move idValue declaration before the try block so it's accessible in the catch handler.

Impact

Without these fixes, local testing with a365 develop start-mock-tooling-server is completely non-functional for Python and Node.js Agent Framework samples. Developers must either:

• Use real M365 MCP servers (requires a published blueprint + active Teams instance)
• Skip local testing entirely

These are all standard MCP protocol methods that any spec-compliant MCP client will send.

Reproduction Steps

1. Clone microsoft/Agent365-Samples Python sample
2. Configure .env with Azure OpenAI credentials
3. Run a365 develop start-mock-tooling-server --port 5309
4. Start the Python agent pointing at the mock server
5. Send any chat message via Agents Playground
6. Result: Agent fails during MCP tool discovery - mock server returns errors for notifications/initialized, ping, prompts/list, resources/list

Affected File

src/Microsoft.Agents.A365.DevTools.MockToolingServer/Server.cs

All 6 fixes are localized to the /agents/servers/{mcpServerName} endpoint handler.

[github-actions]

[AUTO-TRIAGE] Team Assistant Triage

This issue has been automatically analyzed and triaged.

AI Decision Reasoning: Type: Classified as 'bug' because the issue describes unexpected crashes and incorrect behavior of the mock server when handling standard MCP protocol methods, which prevents its intended functionality.
Priority: Assigned P1 because the issue renders the mock server completely non-functional for Python and Node.js agents, blocking local testing and development workflows for these agents.
Copilot: This issue involves implementing support for multiple MCP protocol methods in a mock server, which requires understanding the MCP Streamable HTTP specification and correctly handling protocol-specific behaviors. It also involves handling JSON-RPC and HTTP responses in a way that aligns with the specification. These tasks are beyond Copilot's capability as they require deep understanding of the protocol and careful testing to ensure compliance.
Assignment: High priority (P1) issue assigned to tech lead
Labels: Applied labels bug, P1 based on issue type and priority

Labels and assignee have been applied based on this analysis.

[github-actions]

[AUTO-TRIAGE] Results

Classification: bug
Priority: P1
Confidence: 100.0%

Recommended Assignee: @sellakumaran

Analysis:
type rationale: Classified as 'bug' because the issue describes unexpected crashes and incorrect behavior of the mock server when handling standard MCP protocol methods, which prevents its intended functionality.

priority rationale: Assigned P1 because the issue renders the mock server completely non-functional for Python and Node.js agents, blocking local testing and development workflows for these agents.

copilot rationale: This issue involves implementing support for multiple MCP protocol methods in a mock server, which requires understanding the MCP Streamable HTTP specification and correctly handling protocol-specific behaviors. It also involves handling JSON-RPC and HTTP responses in a way that aligns with the specification. These tasks are beyond Copilot's capability as they require deep understanding of the protocol and careful testing to ensure compliance.

assignment rationale: High priority (P1) issue assigned to tech lead

labels rationale: Applied labels bug, P1 based on issue type and priority

[SUGGESTION] Suggested Approach

1. Update the JSON-RPC handler in src/Services/MockToolingServer.cs to include support for the notifications/initialized method. Implement logic to return a 202 Accepted response with no body for any method starting with notifications/ as specified in the MCP Streamable HTTP transport spec.
2. Add handling for the ping method in the JSON-RPC handler within src/Services/MockToolingServer.cs. Ensure the server responds with a standard empty-result success response ({ "jsonrpc": "2.0", "id": ..., "result": {} }) to maintain connection health during tool discovery.
3. Extend the JSON-RPC handler to support the prompts/list method in src/Services/MockToolingServer.cs. Implement the necessary logic to return the list of available prompts or an appropriate empty response if no prompts are defined.
4. Create unit tests for the newly implemented methods (notifications/initialized, ping, prompts/list) in src/Tests/Microsoft.Agents.A365.DevTools.Cli.Tests/Services/MockToolingServerTests.cs. Ensure the tests cover both expected success responses and edge cases, such as invalid method formats or missing parameters.
5. Update the documentation in the docs directory to reflect the changes made to the mock server. Include examples of the expected JSON-RPC requests and responses for the newly supported methods, and reference the MCP Streamable HTTP transport specification for developers integrating with the mock server.

---

Generated by TeamAssistant Auto-Triage powered by GitHub Models