chore: bump all deps (sparfenyuk#38)

Author: sparfenyuk

README.md

@@ -269,7 +269,7 @@ Check the `mcp-proxy` server by running it with the `mcp-server-fetch` server. Y
 mcp-proxy --sse-port=8080 uvx mcp-server-fetch &
 
 # Connect to the SSE proxy server spawned above using another instance of mcp-proxy given the URL of the SSE server
-mcp-proxy http://localhost:8080/sse
+mcp-proxy http://127.0.0.1:8080/sse
 
 # Send CTRL+C to stop the second server
 

pyproject.toml

@@ -25,9 +25,9 @@ classifiers = [
     "Topic :: Utilities",
     "Typing :: Typed",
 ]
-version = "0.5.0"
+version = "0.5.1"
 requires-python = ">=3.10"
-dependencies = ["mcp>=1.2.0,<2", "uvicorn>=0.34.0"]
+dependencies = ["mcp>=1.5.0,<2", "uvicorn>=0.34.0"]
 
 [build-system]
 requires = ["setuptools"]

src/mcp_proxy/proxy_server.py

@@ -9,12 +9,12 @@
 from mcp.client.session import ClientSession
 
 
-async def create_proxy_server(remote_app: ClientSession) -> server.Server:  # noqa: C901
+async def create_proxy_server(remote_app: ClientSession) -> server.Server[object]:  # noqa: C901
     """Create a server instance from a remote app."""
     response = await remote_app.initialize()
     capabilities = response.capabilities
 
-    app = server.Server(response.serverInfo.name)
+    app: server.Server[object] = server.Server(name=response.serverInfo.name)
 
     if capabilities.prompts:
 

src/mcp_proxy/sse_server.py

@@ -28,7 +28,7 @@ class SseServerSettings:
 
 
 def create_starlette_app(
-    mcp_server: Server,
+    mcp_server: Server[object],
     *,
     allow_origins: list[str] | None = None,
     debug: bool = False,

tests/test_proxy_server.py

@@ -9,6 +9,7 @@
 The same test code is run on both to ensure parity.
 """
 
+import typing as t
 from collections.abc import AsyncGenerator, Awaitable, Callable
 from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from unittest.mock import AsyncMock
@@ -25,14 +26,14 @@
 
 TOOL_INPUT_SCHEMA = {"type": "object", "properties": {"input1": {"type": "string"}}}
 
-SessionContextManager = Callable[[Server], AbstractAsyncContextManager[ClientSession]]
+SessionContextManager = Callable[[Server[object]], AbstractAsyncContextManager[ClientSession]]
 
 # Direct server connection
 in_memory: SessionContextManager = create_connected_server_and_client_session
 
 
 @asynccontextmanager
-async def proxy(server: Server) -> AsyncGenerator[ClientSession, None]:
+async def proxy(server: Server[object]) -> AsyncGenerator[ClientSession, None]:
     """Create a connection to the server through the proxy server."""
     async with in_memory(server) as session:
         wrapped_server = await create_proxy_server(session)
@@ -49,16 +50,16 @@ def session_generator(request: pytest.FixtureRequest) -> SessionContextManager:
 
 
 @pytest.fixture
-def server() -> Server:
+def server() -> Server[object]:
     """Return a server instance."""
     return Server("test-server")
 
 
 @pytest.fixture
-def server_can_list_prompts(server: Server, prompt: types.Prompt) -> Server:
+def server_can_list_prompts(server: Server[object], prompt: types.Prompt) -> Server[object]:
     """Return a server instance with prompts."""
 
-    @server.list_prompts()
+    @server.list_prompts()  # type: ignore[no-untyped-call,misc]
     async def _() -> list[types.Prompt]:
         return [prompt]
 
@@ -67,39 +68,42 @@ async def _() -> list[types.Prompt]:
 
 @pytest.fixture
 def server_can_get_prompt(
-    server_can_list_prompts: Server,
+    server_can_list_prompts: Server[object],
     prompt_callback: Callable[[str, dict[str, str] | None], Awaitable[types.GetPromptResult]],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with prompts."""
-    server_can_list_prompts.get_prompt()(prompt_callback)
+    server_can_list_prompts.get_prompt()(prompt_callback)  # type: ignore[no-untyped-call]
 
     return server_can_list_prompts
 
 
 @pytest.fixture
-def server_can_list_tools(server: Server, tool: types.Tool) -> Server:
+def server_can_list_tools(server: Server[object], tool: types.Tool) -> Server[object]:
     """Return a server instance with tools."""
 
-    @server.list_tools()
+    @server.list_tools()  # type: ignore[no-untyped-call,misc]
     async def _() -> list[types.Tool]:
         return [tool]
 
     return server
 
 
 @pytest.fixture
-def server_can_call_tool(server_can_list_tools: Server, tool: Callable[..., ...]) -> Server:
+def server_can_call_tool(
+    server_can_list_tools: Server[object],
+    tool: Callable[..., t.Any],
+) -> Server[object]:
     """Return a server instance with tools."""
-    server_can_list_tools.call_tool()(tool)
+    server_can_list_tools.call_tool()(tool)  # type: ignore[no-untyped-call]
 
     return server_can_list_tools
 
 
 @pytest.fixture
-def server_can_list_resources(server: Server, resource: types.Resource) -> Server:
+def server_can_list_resources(server: Server[object], resource: types.Resource) -> Server[object]:
     """Return a server instance with resources."""
 
-    @server.list_resources()
+    @server.list_resources()  # type: ignore[no-untyped-call,misc]
     async def _() -> list[types.Resource]:
         return [resource]
 
@@ -108,73 +112,73 @@ async def _() -> list[types.Resource]:
 
 @pytest.fixture
 def server_can_subscribe_resource(
-    server_can_list_resources: Server,
+    server_can_list_resources: Server[object],
     subscribe_callback: Callable[[AnyUrl], Awaitable[None]],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with resource templates."""
-    server_can_list_resources.subscribe_resource()(subscribe_callback)
+    server_can_list_resources.subscribe_resource()(subscribe_callback)  # type: ignore[no-untyped-call]
 
     return server_can_list_resources
 
 
 @pytest.fixture
 def server_can_unsubscribe_resource(
-    server_can_list_resources: Server,
+    server_can_list_resources: Server[object],
     unsubscribe_callback: Callable[[AnyUrl], Awaitable[None]],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with resource templates."""
-    server_can_list_resources.unsubscribe_resource()(unsubscribe_callback)
+    server_can_list_resources.unsubscribe_resource()(unsubscribe_callback)  # type: ignore[no-untyped-call]
 
     return server_can_list_resources
 
 
 @pytest.fixture
 def server_can_read_resource(
-    server_can_list_resources: Server,
+    server_can_list_resources: Server[object],
     resource_callback: Callable[[AnyUrl], Awaitable[str | bytes]],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with resources."""
-    server_can_list_resources.read_resource()(resource_callback)
+    server_can_list_resources.read_resource()(resource_callback)  # type: ignore[no-untyped-call]
 
     return server_can_list_resources
 
 
 @pytest.fixture
 def server_can_set_logging_level(
-    server: Server,
+    server: Server[object],
     logging_level_callback: Callable[[types.LoggingLevel], Awaitable[None]],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with logging capabilities."""
-    server.set_logging_level()(logging_level_callback)
+    server.set_logging_level()(logging_level_callback)  # type: ignore[no-untyped-call]
 
     return server
 
 
 @pytest.fixture
 def server_can_send_progress_notification(
-    server: Server,
-) -> Server:
+    server: Server[object],
+) -> Server[object]:
     """Return a server instance with logging capabilities."""
     return server
 
 
 @pytest.fixture
 def server_can_complete(
-    server: Server,
+    server: Server[object],
     complete_callback: Callable[
         [types.PromptReference | types.ResourceReference, types.CompletionArgument],
         Awaitable[types.Completion | None],
     ],
-) -> Server:
+) -> Server[object]:
     """Return a server instance with logging capabilities."""
-    server.completion()(complete_callback)
+    server.completion()(complete_callback)  # type: ignore[no-untyped-call]
     return server
 
 
 @pytest.mark.parametrize("prompt", [types.Prompt(name="prompt1")])
 async def test_list_prompts(
     session_generator: SessionContextManager,
-    server_can_list_prompts: Server,
+    server_can_list_prompts: Server[object],
     prompt: types.Prompt,
 ) -> None:
     """Test list_prompts."""
@@ -205,7 +209,7 @@ async def test_list_prompts(
 )
 async def test_list_tools(
     session_generator: SessionContextManager,
-    server_can_list_tools: Server,
+    server_can_list_tools: Server[object],
     tool: types.Tool,
 ) -> None:
     """Test list_tools."""
@@ -231,7 +235,7 @@ async def test_list_tools(
 )
 async def test_set_logging_error(
     session_generator: SessionContextManager,
-    server_can_set_logging_level: Server,
+    server_can_set_logging_level: Server[object],
     logging_level_callback: AsyncMock,
     log_level: types.LoggingLevel,
 ) -> None:
@@ -253,7 +257,7 @@ async def test_set_logging_error(
 @pytest.mark.parametrize("tool", [AsyncMock()])
 async def test_call_tool(
     session_generator: SessionContextManager,
-    server_can_call_tool: Server,
+    server_can_call_tool: Server[object],
     tool: AsyncMock,
 ) -> None:
     """Test call_tool."""
@@ -287,7 +291,7 @@ async def test_call_tool(
 )
 async def test_list_resources(
     session_generator: SessionContextManager,
-    server_can_list_resources: Server,
+    server_can_list_resources: Server[object],
     resource: types.Resource,
 ) -> None:
     """Test get_resource."""
@@ -307,7 +311,7 @@ async def test_list_resources(
 @pytest.mark.parametrize("prompt", [types.Prompt(name="prompt1")])
 async def test_get_prompt(
     session_generator: SessionContextManager,
-    server_can_get_prompt: Server,
+    server_can_get_prompt: Server[object],
     prompt_callback: AsyncMock,
 ) -> None:
     """Test get_prompt."""
@@ -334,7 +338,7 @@ async def test_get_prompt(
 )
 async def test_read_resource(
     session_generator: SessionContextManager,
-    server_can_read_resource: Server,
+    server_can_read_resource: Server[object],
     resource_callback: AsyncMock,
     resource: types.Resource,
 ) -> None:
@@ -361,7 +365,7 @@ async def test_read_resource(
 )
 async def test_subscribe_resource(
     session_generator: SessionContextManager,
-    server_can_subscribe_resource: Server,
+    server_can_subscribe_resource: Server[object],
     subscribe_callback: AsyncMock,
     resource: types.Resource,
 ) -> None:
@@ -388,7 +392,7 @@ async def test_subscribe_resource(
 )
 async def test_unsubscribe_resource(
     session_generator: SessionContextManager,
-    server_can_unsubscribe_resource: Server,
+    server_can_unsubscribe_resource: Server[object],
     unsubscribe_callback: AsyncMock,
     resource: types.Resource,
 ) -> None:
@@ -404,7 +408,7 @@ async def test_unsubscribe_resource(
 
 async def test_send_progress_notification(
     session_generator: SessionContextManager,
-    server_can_send_progress_notification: Server,
+    server_can_send_progress_notification: Server[object],
 ) -> None:
     """Test send_progress_notification."""
     async with session_generator(server_can_send_progress_notification) as session:
@@ -420,7 +424,7 @@ async def test_send_progress_notification(
 @pytest.mark.parametrize("complete_callback", [AsyncMock()])
 async def test_complete(
     session_generator: SessionContextManager,
-    server_can_complete: Server,
+    server_can_complete: Server[object],
     complete_callback: AsyncMock,
 ) -> None:
     """Test complete."""
@@ -445,7 +449,7 @@ async def test_complete(
 @pytest.mark.parametrize("tool", [AsyncMock()])
 async def test_call_tool_with_error(
     session_generator: SessionContextManager,
-    server_can_call_tool: Server,
+    server_can_call_tool: Server[object],
     tool: AsyncMock,
 ) -> None:
     """Test call_tool."""

tests/test_sse_server.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import contextlib
+import typing as t
 
 import uvicorn
 from mcp import types
@@ -19,7 +20,7 @@ def install_signal_handlers(self) -> None:
         """Do not install signal handlers."""
 
     @contextlib.asynccontextmanager
-    async def run_in_background(self) -> None:
+    async def run_in_background(self) -> t.AsyncIterator[None]:
         """Run the server in a background thread."""
         task = asyncio.create_task(self.serve())
         try:
@@ -41,13 +42,13 @@ def url(self) -> str:
 
 async def test_create_starlette_app() -> None:
     """Test basic glue code for the SSE transport and a fake MCP server."""
-    server = Server("prompt-server")
+    mcp_server: Server[object] = Server("prompt-server")
 
-    @server.list_prompts()
+    @mcp_server.list_prompts()  # type: ignore[no-untyped-call,misc]
     async def list_prompts() -> list[types.Prompt]:
         return [types.Prompt(name="prompt1")]
 
-    app = create_starlette_app(server, allow_origins=["*"])
+    app = create_starlette_app(mcp_server, allow_origins=["*"])
 
     config = uvicorn.Config(app, port=0, log_level="info")
     server = BackgroundServer(config)