mcp-proxy 0.2.1__tar.gz

mcp_proxy-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sergey Parfenyuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_proxy-0.2.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: mcp-proxy
+Version: 0.2.1
+Author-email: Sergey Parfenyuk <sergey.parfenyuk@gmail.com>
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: mcp

mcp_proxy-0.2.1/README.md

@@ -0,0 +1,76 @@
+# mcp-proxy
+
+- [mcp-proxy](#mcp-proxy)
+  - [About](#about)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+    - [Claude Desktop Configuration](#claude-desktop-configuration)
+  - [Advanced Configuration](#advanced-configuration)
+    - [Environment Variables](#environment-variables)
+
+## About
+
+Connect to MCP servers that run on SSE transport using the MCP Proxy server.
+
+```mermaid
+graph LR
+    A["Claude Desktop"] <--> B["mcp-proxy"]
+    B <--> C["External MCP Server"]
+
+    style A fill:#ffe6f9,stroke:#333,color:black,stroke-width:2px
+    style B fill:#e6e6ff,stroke:#333,color:black,stroke-width:2px
+    style C fill:#e6ffe6,stroke:#333,color:black,stroke-width:2px
+```
+
+> [!TIP]
+> As of now, Claude Desktop does not support MCP servers that run on SSE transport. This server is a workaround to enable the support.
+
+## Installation
+
+```bash
+uv tool install git+https://github.com/sparfenyuk/mcp-proxy
+```
+
+> [!NOTE]
+> If you have already installed the server, you can update it using `uv tool upgrade --reinstall` command.
+
+> [!NOTE]
+> If you want to delete the server, use the `uv tool uninstall mcp-proxy` command.
+
+## Configuration
+
+### Claude Desktop Configuration
+
+Configure Claude Desktop to recognize the MCP server.
+
+1. Open the Claude Desktop configuration file:
+   - in MacOS, the configuration file is located at `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - in Windows, the configuration file is located at `%APPDATA%\Claude\claude_desktop_config.json`
+
+   > __Note:__
+   > You can also find claude_desktop_config.json inside the settings of Claude Desktop app
+
+2. Add the server configuration
+
+    ```json
+    {
+      "mcpServers": {
+        "mcp-proxy": {
+            "command": "mcp-proxy",
+            "env": {
+              "SSE_URL": "http://example.io/sse"
+            }
+        }
+      }
+    }
+
+    ```
+
+## Advanced Configuration
+
+### Environment Variables
+
+| Name             | Description                                                                        |
+| ---------------- | ---------------------------------------------------------------------------------- |
+| SSE_URL          | The MCP server SSE endpoint to connect to e.g. http://example.io/sse               |
+| API_ACCESS_TOKEN | Added in the `Authorization` header of the HTTP request as a `Bearer` access token |

mcp_proxy-0.2.1/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "mcp-proxy"
+authors = [{ name = "Sergey Parfenyuk", email = "sergey.parfenyuk@gmail.com" }]
+version = "0.2.1"
+requires-python = ">=3.11"
+dependencies = ["mcp"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+mcp-proxy = "mcp_proxy.__main__:main"
+
+[tool.setuptools.package-data]
+"*" = ["py.typed"]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=8.3.3",
+    "pytest-asyncio>=0.25.0",
+    "coverage>=7.6.0",
+]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+skip_covered = true
+show_missing = true
+precision = 2
+exclude_lines = [
+    'pragma: no cover',
+    'raise NotImplementedError',
+    'if TYPE_CHECKING:',
+    'if typing.TYPE_CHECKING:',
+    '@overload',
+    '@typing.overload',
+    '\(Protocol\):$',
+    'typing.assert_never',
+    '$\s*assert_never\(',
+    'if __name__ == .__main__.:',
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "EM101",  # Exception must not use a string literal, assign to variable first
+    "TRY003", # Avoid specifying long messages outside the exception class
+    "ERA001", # Found commented-out code
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101", "INP001"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.pytest.ini_options]
+pythonpath = "src"
+addopts = ["--import-mode=importlib"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

mcp_proxy-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mcp_proxy-0.2.1/src/mcp_proxy/__init__.py

@@ -0,0 +1,143 @@
+"""Create a local server that proxies requests to a remote server over SSE."""
+
+import logging
+import typing as t
+
+from mcp import server, types
+from mcp.client.session import ClientSession
+
+logger = logging.getLogger(__name__)
+
+
+async def create_proxy_server(remote_app: ClientSession) -> server.Server:  # noqa: C901
+    """Create a server instance from a remote app."""
+    response = await remote_app.initialize()
+    capabilities = response.capabilities
+
+    app = server.Server(response.serverInfo.name)
+
+    if capabilities.prompts:
+
+        async def _list_prompts(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            result = await remote_app.list_prompts()
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ListPromptsRequest] = _list_prompts
+
+        async def _get_prompt(req: types.GetPromptRequest) -> types.ServerResult:
+            result = await remote_app.get_prompt(req.params.name, req.params.arguments)
+            return types.ServerResult(result)
+
+        app.request_handlers[types.GetPromptRequest] = _get_prompt
+
+    if capabilities.resources:
+
+        async def _list_resources(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            result = await remote_app.list_resources()
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ListResourcesRequest] = _list_resources
+
+        # list_resource_templates() is not implemented in the client
+        # async def _list_resource_templates(_: t.Any) -> types.ServerResult:
+        #     result = await remote_app.list_resource_templates()
+        #     return types.ServerResult(result)
+
+        # app.request_handlers[types.ListResourceTemplatesRequest] = _list_resource_templates
+
+        async def _read_resource(req: types.ReadResourceRequest) -> types.ServerResult:
+            result = await remote_app.read_resource(req.params.uri)
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ReadResourceRequest] = _read_resource
+
+    if capabilities.logging:
+
+        async def _set_logging_level(req: types.SetLevelRequest) -> types.ServerResult:
+            await remote_app.set_logging_level(req.params.level)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.SetLevelRequest] = _set_logging_level
+
+    if capabilities.resources:
+
+        async def _subscribe_resource(req: types.SubscribeRequest) -> types.ServerResult:
+            await remote_app.subscribe_resource(req.params.uri)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.SubscribeRequest] = _subscribe_resource
+
+        async def _unsubscribe_resource(req: types.UnsubscribeRequest) -> types.ServerResult:
+            await remote_app.unsubscribe_resource(req.params.uri)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.UnsubscribeRequest] = _unsubscribe_resource
+
+    if capabilities.tools:
+
+        async def _list_tools(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            tools = await remote_app.list_tools()
+            return types.ServerResult(tools)
+
+        app.request_handlers[types.ListToolsRequest] = _list_tools
+
+        async def _call_tool(req: types.CallToolRequest) -> types.ServerResult:
+            try:
+                result = await remote_app.call_tool(
+                    req.params.name,
+                    (req.params.arguments or {}),
+                )
+                return types.ServerResult(result)
+            except Exception as e:  # noqa: BLE001
+                return types.ServerResult(
+                    types.CallToolResult(
+                        content=[types.TextContent(type="text", text=str(e))],
+                        isError=True,
+                    ),
+                )
+
+        app.request_handlers[types.CallToolRequest] = _call_tool
+
+    async def _send_progress_notification(req: types.ProgressNotification) -> None:
+        await remote_app.send_progress_notification(
+            req.params.progressToken,
+            req.params.progress,
+            req.params.total,
+        )
+
+    app.notification_handlers[types.ProgressNotification] = _send_progress_notification
+
+    async def _complete(req: types.CompleteRequest) -> types.ServerResult:
+        result = await remote_app.complete(
+            req.params.ref,
+            req.params.argument.model_dump(),
+        )
+        return types.ServerResult(result)
+
+    app.request_handlers[types.CompleteRequest] = _complete
+
+    return app
+
+
+async def run_sse_client(url: str, api_access_token: str | None = None) -> None:
+    """Run the SSE client.
+
+    Args:
+        url: The URL to connect to.
+        api_access_token: The API access token to use for authentication.
+
+    """
+    from mcp.client.sse import sse_client
+
+    headers = {}
+    if api_access_token is not None:
+        headers["Authorization"] = f"Bearer {api_access_token}"
+
+    async with sse_client(url=url, headers=headers) as streams, ClientSession(*streams) as session:
+        app = await create_proxy_server(session)
+        async with server.stdio_server() as (read_stream, write_stream):
+            await app.run(
+                read_stream,
+                write_stream,
+                app.create_initialization_options(),
+            )

mcp_proxy-0.2.1/src/mcp_proxy/__main__.py

@@ -0,0 +1,30 @@
+"""The entry point for the mcp-proxy application. It sets up the logging and runs the main function.
+
+Two ways to run the application:
+1. Run the application as a module `uv run -m mcp_proxy`
+2. Run the application as a package `uv run mcp-proxy`
+
+"""
+
+import asyncio
+import logging
+import os
+import typing as t
+
+from . import run_sse_client
+
+logging.basicConfig(level=logging.DEBUG)
+SSE_URL: t.Final[str] = os.getenv("SSE_URL", "")
+API_ACCESS_TOKEN: t.Final[str | None] = os.getenv("API_ACCESS_TOKEN", None)
+
+if not SSE_URL:
+    raise ValueError("SSE_URL environment variable is not set")
+
+
+def main() -> None:
+    """Start the client using asyncio."""
+    asyncio.run(run_sse_client(SSE_URL, api_access_token=API_ACCESS_TOKEN))
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: mcp-proxy
+Version: 0.2.1
+Author-email: Sergey Parfenyuk <sergey.parfenyuk@gmail.com>
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: mcp

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/mcp_proxy/__init__.py
+src/mcp_proxy/__main__.py
+src/mcp_proxy/py.typed
+src/mcp_proxy.egg-info/PKG-INFO
+src/mcp_proxy.egg-info/SOURCES.txt
+src/mcp_proxy.egg-info/dependency_links.txt
+src/mcp_proxy.egg-info/entry_points.txt
+src/mcp_proxy.egg-info/requires.txt
+src/mcp_proxy.egg-info/top_level.txt
+tests/test_init.py

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-proxy = mcp_proxy.__main__:main

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/requires.txt

@@ -0,0 +1 @@
+mcp

mcp_proxy-0.2.1/src/mcp_proxy.egg-info/top_level.txt

@@ -0,0 +1 @@
+mcp_proxy

mcp_proxy-0.2.1/tests/test_init.py

@@ -0,0 +1,464 @@
+"""Tests for the mcp-proxy module.
+
+Tests are running in two modes:
+- One where the server is exercised directly though an in memory client, just to
+  set a baseline for the expected behavior.
+- Another where the server is exercised through a proxy server, which forwards
+  the requests to the original server.
+
+The same test code is run on both to ensure parity.
+"""
+
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from unittest.mock import AsyncMock
+
+import pytest
+from mcp import types
+from mcp.client.session import ClientSession
+from mcp.server import Server
+from mcp.shared.exceptions import McpError
+from mcp.shared.memory import create_connected_server_and_client_session
+from pydantic import AnyUrl
+
+from mcp_proxy import create_proxy_server
+
+TOOL_INPUT_SCHEMA = {"type": "object", "properties": {"input1": {"type": "string"}}}
+
+SessionContextManager = Callable[[Server], AbstractAsyncContextManager[ClientSession]]
+
+# Direct server connection
+in_memory: SessionContextManager = create_connected_server_and_client_session
+
+
+@asynccontextmanager
+async def proxy(server: Server) -> 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)
+        async with in_memory(wrapped_server) as wrapped_session:
+            yield wrapped_session
+
+
+@pytest.fixture(params=["server", "proxy"])
+def session_generator(request: pytest.FixtureRequest) -> SessionContextManager:
+    """Fixture that returns a client creation strategy either direct or using the proxy."""
+    if request.param == "server":
+        return in_memory
+    return proxy
+
+
+@pytest.fixture
+def server() -> Server:
+    """Return a server instance."""
+    return Server("test-server")
+
+
+@pytest.fixture
+def server_can_list_prompts(server: Server, prompt: types.Prompt) -> Server:
+    """Return a server instance with prompts."""
+
+    @server.list_prompts()
+    async def _() -> list[types.Prompt]:
+        return [prompt]
+
+    return server
+
+
+@pytest.fixture
+def server_can_get_prompt(
+    server_can_list_prompts: Server,
+    prompt_callback: Callable[[str, dict[str, str] | None], Awaitable[types.GetPromptResult]],
+) -> Server:
+    """Return a server instance with prompts."""
+    server_can_list_prompts.get_prompt()(prompt_callback)
+
+    return server_can_list_prompts
+
+
+@pytest.fixture
+def server_can_list_tools(server: Server, tool: types.Tool) -> Server:
+    """Return a server instance with tools."""
+
+    @server.list_tools()
+    async def _() -> list[types.Tool]:
+        return [tool]
+
+    return server
+
+
+@pytest.fixture
+def server_can_call_tool(server_can_list_tools: Server, tool: Callable[..., ...]) -> Server:
+    """Return a server instance with tools."""
+    server_can_list_tools.call_tool()(tool)
+
+    return server_can_list_tools
+
+
+@pytest.fixture
+def server_can_list_resources(server: Server, resource: types.Resource) -> Server:
+    """Return a server instance with resources."""
+
+    @server.list_resources()
+    async def _() -> list[types.Resource]:
+        return [resource]
+
+    return server
+
+
+@pytest.fixture
+def server_can_subscribe_resource(
+    server_can_list_resources: Server,
+    subscribe_callback: Callable[[AnyUrl], Awaitable[None]],
+) -> Server:
+    """Return a server instance with resource templates."""
+    server_can_list_resources.subscribe_resource()(subscribe_callback)
+
+    return server_can_list_resources
+
+
+@pytest.fixture
+def server_can_unsubscribe_resource(
+    server_can_list_resources: Server,
+    unsubscribe_callback: Callable[[AnyUrl], Awaitable[None]],
+) -> Server:
+    """Return a server instance with resource templates."""
+    server_can_list_resources.unsubscribe_resource()(unsubscribe_callback)
+
+    return server_can_list_resources
+
+
+@pytest.fixture
+def server_can_read_resource(
+    server_can_list_resources: Server,
+    resource_callback: Callable[[AnyUrl], Awaitable[str | bytes]],
+) -> Server:
+    """Return a server instance with resources."""
+    server_can_list_resources.read_resource()(resource_callback)
+
+    return server_can_list_resources
+
+
+@pytest.fixture
+def server_can_set_logging_level(
+    server: Server,
+    logging_level_callback: Callable[[types.LoggingLevel], Awaitable[None]],
+) -> Server:
+    """Return a server instance with logging capabilities."""
+    server.set_logging_level()(logging_level_callback)
+
+    return server
+
+
+@pytest.fixture
+def server_can_send_progress_notification(
+    server: Server,
+) -> Server:
+    """Return a server instance with logging capabilities."""
+    return server
+
+
+@pytest.fixture
+def server_can_complete(
+    server: Server,
+    complete_callback: Callable[
+        [types.PromptReference | types.ResourceReference, types.CompletionArgument],
+        Awaitable[types.Completion | None],
+    ],
+) -> Server:
+    """Return a server instance with logging capabilities."""
+    server.completion()(complete_callback)
+    return server
+
+
+@pytest.mark.parametrize("prompt", [types.Prompt(name="prompt1")])
+async def test_list_prompts(
+    session_generator: SessionContextManager,
+    server_can_list_prompts: Server,
+    prompt: types.Prompt,
+) -> None:
+    """Test list_prompts."""
+    async with session_generator(server_can_list_prompts) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities.prompts
+        assert not result.capabilities.tools
+        assert not result.capabilities.resources
+        assert not result.capabilities.logging
+
+        list_prompts_result = await session.list_prompts()
+        assert list_prompts_result.prompts == [prompt]
+
+        with pytest.raises(McpError, match="Method not found"):
+            await session.list_tools()
+
+
+@pytest.mark.parametrize(
+    "tool",
+    [
+        types.Tool(
+            name="tool-name",
+            description="tool-description",
+            inputSchema=TOOL_INPUT_SCHEMA,
+        ),
+    ],
+)
+async def test_list_tools(
+    session_generator: SessionContextManager,
+    server_can_list_tools: Server,
+    tool: types.Tool,
+) -> None:
+    """Test list_tools."""
+    async with session_generator(server_can_list_tools) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities.tools
+        assert not result.capabilities.prompts
+        assert not result.capabilities.resources
+        assert not result.capabilities.logging
+
+        list_tools_result = await session.list_tools()
+        assert list_tools_result.tools == [tool]
+
+        with pytest.raises(McpError, match="Method not found"):
+            await session.list_prompts()
+
+
+@pytest.mark.parametrize("logging_level_callback", [AsyncMock()])
+@pytest.mark.parametrize(
+    "log_level",
+    ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"],
+)
+async def test_set_logging_error(
+    session_generator: SessionContextManager,
+    server_can_set_logging_level: Server,
+    logging_level_callback: AsyncMock,
+    log_level: types.LoggingLevel,
+) -> None:
+    """Test set_logging_level."""
+    async with session_generator(server_can_set_logging_level) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities.logging
+        assert not result.capabilities.prompts
+        assert not result.capabilities.resources
+        assert not result.capabilities.tools
+
+        logging_level_callback.return_value = None
+        await session.set_logging_level(log_level)
+        logging_level_callback.assert_called_once_with(log_level)
+        logging_level_callback.reset_mock()  # Reset the mock for the next test case
+
+
+@pytest.mark.parametrize("tool", [AsyncMock()])
+async def test_call_tool(
+    session_generator: SessionContextManager,
+    server_can_call_tool: Server,
+    tool: AsyncMock,
+) -> None:
+    """Test call_tool."""
+    async with session_generator(server_can_call_tool) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities
+        assert result.capabilities.tools
+        assert not result.capabilities.prompts
+        assert not result.capabilities.resources
+        assert not result.capabilities.logging
+
+        tool.return_value = []
+        call_tool_result = await session.call_tool("tool", {})
+        assert call_tool_result.content == []
+        assert not call_tool_result.isError
+
+        tool.assert_called_once_with("tool", {})
+        tool.reset_mock()
+
+
+@pytest.mark.parametrize(
+    "resource",
+    [
+        types.Resource(
+            uri=AnyUrl("scheme://resource-uri"),
+            name="resource-name",
+            description="resource-description",
+        ),
+    ],
+)
+async def test_list_resources(
+    session_generator: SessionContextManager,
+    server_can_list_resources: Server,
+    resource: types.Resource,
+) -> None:
+    """Test get_resource."""
+    async with session_generator(server_can_list_resources) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities.resources
+        assert not result.capabilities.prompts
+        assert not result.capabilities.tools
+        assert not result.capabilities.logging
+
+        list_resources_result = await session.list_resources()
+        assert list_resources_result.resources == [resource]
+
+
+@pytest.mark.parametrize("prompt_callback", [AsyncMock()])
+@pytest.mark.parametrize("prompt", [types.Prompt(name="prompt1")])
+async def test_get_prompt(
+    session_generator: SessionContextManager,
+    server_can_get_prompt: Server,
+    prompt_callback: AsyncMock,
+) -> None:
+    """Test get_prompt."""
+    async with session_generator(server_can_get_prompt) as session:
+        await session.initialize()
+
+        prompt_callback.return_value = types.GetPromptResult(messages=[])
+
+        await session.get_prompt("prompt", {})
+        prompt_callback.assert_called_once_with("prompt", {})
+        prompt_callback.reset_mock()
+
+
+@pytest.mark.parametrize("resource_callback", [AsyncMock()])
+@pytest.mark.parametrize(
+    "resource",
+    [
+        types.Resource(
+            uri=AnyUrl("scheme://resource-uri"),
+            name="resource-name",
+            description="resource-description",
+        ),
+    ],
+)
+async def test_read_resource(
+    session_generator: SessionContextManager,
+    server_can_read_resource: Server,
+    resource_callback: AsyncMock,
+    resource: types.Resource,
+) -> None:
+    """Test read_resource."""
+    async with session_generator(server_can_read_resource) as session:
+        await session.initialize()
+
+        resource_callback.return_value = "resource-content"
+        await session.read_resource(resource.uri)
+        resource_callback.assert_called_once_with(resource.uri)
+        resource_callback.reset_mock()
+
+
+@pytest.mark.parametrize("subscribe_callback", [AsyncMock()])
+@pytest.mark.parametrize(
+    "resource",
+    [
+        types.Resource(
+            uri=AnyUrl("scheme://resource-uri"),
+            name="resource-name",
+            description="resource-description",
+        ),
+    ],
+)
+async def test_subscribe_resource(
+    session_generator: SessionContextManager,
+    server_can_subscribe_resource: Server,
+    subscribe_callback: AsyncMock,
+    resource: types.Resource,
+) -> None:
+    """Test subscribe_resource."""
+    async with session_generator(server_can_subscribe_resource) as session:
+        await session.initialize()
+
+        subscribe_callback.return_value = None
+        await session.subscribe_resource(resource.uri)
+        subscribe_callback.assert_called_once_with(resource.uri)
+        subscribe_callback.reset_mock()
+
+
+@pytest.mark.parametrize("unsubscribe_callback", [AsyncMock()])
+@pytest.mark.parametrize(
+    "resource",
+    [
+        types.Resource(
+            uri=AnyUrl("scheme://resource-uri"),
+            name="resource-name",
+            description="resource-description",
+        ),
+    ],
+)
+async def test_unsubscribe_resource(
+    session_generator: SessionContextManager,
+    server_can_unsubscribe_resource: Server,
+    unsubscribe_callback: AsyncMock,
+    resource: types.Resource,
+) -> None:
+    """Test subscribe_resource."""
+    async with session_generator(server_can_unsubscribe_resource) as session:
+        await session.initialize()
+
+        unsubscribe_callback.return_value = None
+        await session.unsubscribe_resource(resource.uri)
+        unsubscribe_callback.assert_called_once_with(resource.uri)
+        unsubscribe_callback.reset_mock()
+
+
+async def test_send_progress_notification(
+    session_generator: SessionContextManager,
+    server_can_send_progress_notification: Server,
+) -> None:
+    """Test send_progress_notification."""
+    async with session_generator(server_can_send_progress_notification) as session:
+        await session.initialize()
+
+        await session.send_progress_notification(
+            progress_token=1,
+            progress=0.5,
+            total=1,
+        )
+
+
+@pytest.mark.parametrize("complete_callback", [AsyncMock()])
+async def test_complete(
+    session_generator: SessionContextManager,
+    server_can_complete: Server,
+    complete_callback: AsyncMock,
+) -> None:
+    """Test complete."""
+    async with session_generator(server_can_complete) as session:
+        await session.initialize()
+
+        complete_callback.return_value = None
+        result = await session.complete(
+            types.PromptReference(type="ref/prompt", name="name"),
+            argument={"name": "name", "value": "value"},
+        )
+
+        assert result.completion.values == []
+
+        complete_callback.assert_called_with(
+            types.PromptReference(type="ref/prompt", name="name"),
+            types.CompletionArgument(name="name", value="value"),
+        )
+        complete_callback.reset_mock()
+
+
+@pytest.mark.parametrize("tool", [AsyncMock()])
+async def test_call_tool_with_error(
+    session_generator: SessionContextManager,
+    server_can_call_tool: Server,
+    tool: AsyncMock,
+) -> None:
+    """Test call_tool."""
+    async with session_generator(server_can_call_tool) as session:
+        result = await session.initialize()
+        assert result.capabilities
+        assert result.capabilities
+        assert result.capabilities.tools
+        assert not result.capabilities.prompts
+        assert not result.capabilities.resources
+        assert not result.capabilities.logging
+
+        tool.side_effect = Exception("Error")
+
+        call_tool_result = await session.call_tool("tool", {})
+        assert call_tool_result.isError