Response ID-value not matching request value, due to default int

[sProdz]

Initial Checks

• I confirm that I'm using the latest version of MCP Python SDK
• I confirm that I searched for my issue in https://github.com/modelcontextprotocol/python-sdk/issues before opening this issue

Description

When the client sends a request with id field value of type string, the server MUST respond with exactly the same value. When the #851 was accepted to version 1.9.4 it broke this standard causing errors for example in Microsoft Copilot Studio, because of the mismatch in the response id value.

"id
This member is REQUIRED.
It MUST be the same as the value of the id member in the Request Object.
If there was an error in detecting the id in the Request object (e.g. Parse error/Invalid Request), it MUST be Null.
" JSON-RPC 2.0 spec.

Example Code

curl -N \
  -X POST http://localhost:8000/mcp/ \                    
  -H "Accept: application/json, text/event-stream" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":"1","method":"tools/list","params":{}}' # String

Response:

{
    "jsonrpc": "2.0",
    "id": 1,  # Int
    "result": {
        "tools": [
            {
                "name": "query",
                "description": "Ask an LLM agent to answer the query using internal documents",
                "inputSchema": {
                    "properties": {
                        "query": {
                            "title": "Query",
                            "type": "string"
                        }
                    },
                    "required": [
                        "query"
                    ],
                    "title": "query_toolArguments",
                    "type": "object"
                },
                "annotations": {
                    "title": "Internal Docs Query",
                    "readOnlyHint": true,
                    "destructiveHint": false,
                    "idempotentHint": true,
                    "openWorldHint": false
                }
            }
        ]
    }
}

Python & MCP Python SDK

Python 3.11
MCP Python SDK 1.9.4

[falcowinkler]

We observed the issue that, when an initialize message is sent to a server using python SDK, it always returns a message id of integer type, even though the initial request had the type of this id be of string type. this is an example request/response pair for the integration with MS Copilot Studio.

Request:

{
    "id": "1",
    "jsonrpc": "2.0",
    "method": "initialize",
    "params": {
        "capabilities": {},
        "clientInfo": {
            "agentName": "Test agent python",
            "appId": "d1296152-0c7a-4e79-8112-c1c87d5287e8",
            "channelId": "pva-studio",
            "name": "mcs",
            "version": "1.0.0"
        },
        "protocolVersion": "2024-11-05",
        "sessionContext": {}
    }
}

Response:

id: 5e70c917-c5d7-416e-9daa-23bf521b7b82
event: message
data: {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2024-11-05","capabilities":{"experimental":{},"tools":{"listChanged":false}},"serverInfo":{"name":"
mcp-streamable-http-demo","version":"1.9.5.dev14+d0443a1"}}}

The flow then stops from microsoft side, likely because of a missing connection associated with this request id.

From the spec: https://modelcontextprotocol.io/specification/2025-06-18/basic#responses

Responses MUST include the same ID as the request they correspond to.

You could argue it's not explicitly mentioning the type here, but it seems to cause an issue even in the MCP inspector. If i hack the server to to return a id with a string type, even though the initialize call from the inspector is of integer type, i see the following message in the inspector logs:

Error from inspector client: Error: No connection established for request ID: 0

[falcowinkler]

This is the fix we used.

import os
import re
import sys
import json

from starlette.concurrency import iterate_in_threadpool
from starlette.middleware.base import _StreamingResponse

sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

from fastapi import FastAPI, Request
import uvicorn

from fastmcp import FastMCP

mcp = FastMCP("ardoq")

from fastapi.responses import JSONResponse
from collections.abc import Callable
from contextlib import asynccontextmanager, AsyncExitStack
from starlette.types import ASGIApp
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.middleware import Middleware
from starlette.exceptions import HTTPException as StarletteHTTPException
from fastapi.exceptions import RequestValidationError
from loguru import logger

# register tool handlers

def combine_lifespans(*lifespans):
    @asynccontextmanager
    async def combined_lifespan(app):
        async with AsyncExitStack() as stack:
            for l in lifespans:  # noqa: E741
                ctx = l(app)
                await stack.enter_async_context(ctx)
            yield

    return combined_lifespan


def set_id_and_rechunk_response(response_data_chunks: List[bytes]) -> List[bytes]:
    """
    Modifies the 'id' field in a JSON payload from a list of byte chunks,
    and then re-chunks the modified response to approximate the original chunking.

    Args:
        response_data_chunks (list[bytes]): A list of byte chunks from a
                                             server-sent event stream.

    Returns:
        list[bytes]: A list containing the modified and re-chunked byte chunks.
    """
    if not response_data_chunks:
        return []

    full_response_str = b"".join(response_data_chunks).decode("utf-8")

    match = re.search(r"data:\s*({.*})", full_response_str, re.DOTALL)
    if not match:
        return response_data_chunks
    json_str = match.group(1)

    try:
        data_payload = json.loads(json_str)
        if "id" in data_payload:
            data_payload["id"] = str(data_payload["id"])

        modified_json_str = json.dumps(data_payload, separators=(",", ":"))
        modified_full_response_str = full_response_str.replace(json_str, modified_json_str)
        modified_response_bytes = modified_full_response_str.encode("utf-8")

    except json.JSONDecodeError:
        return response_data_chunks

    total_original_size = sum(len(c) for c in response_data_chunks)
    num_original_chunks = len(response_data_chunks)

    avg_chunk_size = (
        (total_original_size // num_original_chunks) if num_original_chunks > 0 else 4096
    )

    if avg_chunk_size == 0:
        avg_chunk_size = 4096

    new_chunks = []
    for i in range(0, len(modified_response_bytes), avg_chunk_size):
        chunk = modified_response_bytes[i : i + avg_chunk_size]
        new_chunks.append(chunk)

    return new_chunks


class IDTypeMismatchFixMiddleware(BaseHTTPMiddleware):
    """Fix for https://github.com/modelcontextprotocol/python-sdk/issues/961"""

    def __init__(self, app: ASGIApp):
        super().__init__(app)

    async def dispatch(self, request: Request, call_next: Callable):
        request_body = b""
        response_body_chunks = []
        async for chunk in request.stream():
            request_body += chunk
        request._body = request_body
        is_request_id_str = False
        if request_body:
            json_request_body = json.loads(request_body)
            is_request_id_str = "id" in json_request_body and isinstance(
                json_request_body["id"], str
            )
        response = await call_next(request)
        if isinstance(response, _StreamingResponse):
            async for chunk in response.body_iterator:
                response_body_chunks.append(chunk)
            if is_request_id_str:
                response_body_chunks = set_id_and_rechunk_response(response_body_chunks)
            response.body_iterator = iterate_in_threadpool(iter(response_body_chunks))
        return response


class ExceptionMiddleware(BaseHTTPMiddleware):
    def __init__(self, app: ASGIApp):
        super().__init__(app)

    async def dispatch(self, request: Request, call_next: Callable):
        with logger.catch():
            try:
                response = await call_next(request)
            except RequestValidationError as exc:
                logger.bind(with_traceback=True).exception(exc)
                response = JSONResponse(
                    status_code=422,
                    content={"detail": exc.errors(), "body": exc.body},
                )
            except StarletteHTTPException as exc:
                logger.bind(with_traceback=True).exception(exc)
                response = JSONResponse(
                    status_code=exc.status_code or 503, content={"detail": str(exc.detail)}
                )
            except Exception as exc:
                logger.bind(with_traceback=True).exception(exc)
                response = JSONResponse(
                    content={"message": "Unhandled exception encountered"}, status_code=500
                )

        return response


custom_middleware = [
    Middleware(
        IDTypeMismatchFixMiddleware,
    ),
    Middleware(
        ExceptionMiddleware,
    ),
]

sse_mcp_app = mcp.http_app(path="/sse", transport="sse", middleware=custom_middleware)
stream_mcp_app = mcp.http_app(
    path="/stream", transport="streamable-http", middleware=custom_middleware
)

app = FastAPI(
    lifespan=combine_lifespans(
        sse_mcp_app.router.lifespan_context, stream_mcp_app.router.lifespan_context
    ),
    middleware=custom_middleware,
)

app.mount("/mcp", sse_mcp_app)
app.mount("/mcp-stream", stream_mcp_app)



if __name__ == "__main__":
    uvicorn_app_spec = {
        "app": "src.main:app",
        "host": "0.0.0.0",
        "port": 8000,
    }
    uvicorn.run(**uvicorn_app_spec)

[sProdz]

Thanks for joining in with fixes! However this should be fixed on the SDK server level as types are not decorative or just for aesthetics and not force programmers do server fixes themselves. Integers and numeric strings are fundamentally different throughout the whole computing and networking stack. They are just different values and should thus conform to this JSON-RPC 2.0 specification, even if only because JSON itself distinguishes between them.

So far the easiest fix was just to revert back to the previous version for this one 👍

[falcowinkler]

Yes completely agree this should be fixed in the SDK ASAP, since it's not compliant to the spec. We need to use the latest version, so this workaround is necessary for us.

[folkvir]

@falcowinkler I can confirm that your fix solves our issue configuring a Microsoft Agent using a MCP server. Thank you!

[vinothkumar1097]

Team, when can we expect this to be fixed?
I was developing mcp tools for my microsoft copilot studio agent using python sdk. it works fine with mcp inspector and github copilot, but while connecting with microsoft copilot studio, connection seems to be successfull however i cannot see any tools visible. While looking for solution, I came across this community discussion highlighting this issuehttps://community.powerplatform.com/forums/thread/details/?threadid=7ec056e9-f950-f011-877a-7c1e5247028a.

[BulatF]

i've downgraded to mcp==1.9.3 for now and everything works, if it helps anyone !

[sProdz]

@vinothkumar1097 I might start working on this next week if no one has fixed it by then. I haven't had time to do this during summer and initially planned only raising the issue. This is a very simple yet crucial fix so if anyone has time before then, please! :)

[EgoManiac]

Hey all, appreciate this isn't the Python fix (i wish i was talented enough to fix that), but i have a work around for the copilot studio people, if needed while we await the fix. I managed to battle the code editor for the custom connector to edit the return response and swap from int to string on the return.

I have provided the code in a repo below.

https://github.com/EgoManiac/CopilotStudioMCPFix/blob/main/README.md

[julio-aguilar]

Hey @EgoManiac i was wondering if you could share a version of your api yaml file, I am currently trying with your fix but I think my open api yml file is also wrong. :/

[ns-amurugesan]

Is there a branch with this fix?