[v2] Boolean progress total is delivered to callbacks as 1.0 #3217

isinstance(total, int | float)

from collections.abc import Mapping
from typing import Any

import anyio
from mcp_types import JSONRPCNotification, JSONRPCRequest, JSONRPCResponse

from mcp.shared.dispatcher import DispatchContext
from mcp.shared.jsonrpc_dispatcher import JSONRPCDispatcher
from mcp.shared.message import SessionMessage
from mcp.shared.transport_context import TransportContext


async def ignore_request(
    context: DispatchContext[TransportContext],
    method: str,
    params: Mapping[str, Any] | None,
) -> dict[str, Any]:
    return {}


async def ignore_notification(
    context: DispatchContext[TransportContext],
    method: str,
    params: Mapping[str, Any] | None,
) -> None:
    return None


async def main() -> None:
    outbound_send, outbound_receive = anyio.create_memory_object_stream[SessionMessage](8)
    inbound_send, inbound_receive = anyio.create_memory_object_stream[SessionMessage | Exception](8)

    dispatcher: JSONRPCDispatcher[TransportContext] = JSONRPCDispatcher(
        inbound_receive,
        outbound_send,
    )

    seen: list[tuple[float, float | None]] = []

    async def peer() -> None:
        request = await outbound_receive.receive()
        assert isinstance(request.message, JSONRPCRequest)
        request_id = request.message.id

        await inbound_send.send(
            SessionMessage(
                message=JSONRPCNotification(
                    jsonrpc="2.0",
                    method="notifications/progress",
                    params={
                        "progressToken": request_id,
                        "progress": 0.5,
                        "total": True,
                    },
                )
            )
        )

        await inbound_send.send(
            SessionMessage(
                message=JSONRPCResponse(
                    jsonrpc="2.0",
                    id=request_id,
                    result={"ok": True},
                )
            )
        )

    async def on_progress(
        progress: float,
        total: float | None,
        message: str | None,
    ) -> None:
        seen.append((progress, total))

    async with anyio.create_task_group() as task_group:
        await task_group.start(
            dispatcher.run,
            ignore_request,
            ignore_notification,
        )

        task_group.start_soon(peer)

        await dispatcher.send_raw_request(
            "ping",
            None,
            {"on_progress": on_progress},
        )

        task_group.cancel_scope.cancel()

    print(seen)


anyio.run(main)