mcpsync-cli 0.1.0__tar.gz

mcpsync_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Repo Factory
+
+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.

mcpsync_cli-0.1.0/PKG-INFO

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: mcpsync-cli
+Version: 0.1.0
+Summary: Synchronous MCP Python client — call MCP servers from sync Python without async/await
+Author-email: Repo Factory <noreply@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/prasad-a-abhishek/mcpsync
+Project-URL: Repository, https://github.com/prasad-a-abhishek/mcpsync
+Project-URL: Issues, https://github.com/prasad-a-abhishek/mcpsync/issues
+Keywords: mcp,model-context-protocol,synchronous,sync,client,stdio,http,streamable-http
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# mcpsync
+
+[![PyPI](https://img.shields.io/badge/version-0.1.0-blue)](https://pypi.org/project/mcpsync)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/badge/tests-129%20passing-brightgreen.svg)](tests/)
+[![Min runtime deps](https://img.shields.io/badge/dependencies-mcp-blue)](pyproject.toml)
+
+> **Synchronous Python API for MCP servers — stdio and HTTP transports, plus a CLI for ad-hoc inspection.**
+
+`mcpsync` wraps the official `mcp` Python SDK's async client behind a
+blocking `SyncMCPClient` so you can call MCP tools, list resources, and
+read resources from synchronous code (CLI tools, Django views, Flask
+handlers, scripts). It also ships a CLI for ad-hoc server inspection
+from the shell.
+
+## Quick Start
+
+Install from source:
+
+```bash
+pip install git+https://github.com/prasad-a-abhishek/mcpsync.git
+```
+
+Connect to a stdio MCP server and call a tool:
+
+```python
+from mcpsync import SyncMCPClient, StdioServerParameters
+
+params = StdioServerParameters(
+    command="python", args=("-m", "my_mcp_server"),
+    env={"DEBUG": "1"},
+    cwd="/srv/myapp",
+)
+
+with SyncMCPClient(params) as client:
+    tools = client.list_tools()
+    for tool in tools:
+        print(f"- {tool.name}: {tool.description}")
+
+    result = client.call_tool("add", {"a": 2, "b": 3})
+    for block in result.content:
+        print(block.text)
+```
+
+Connect to an HTTP MCP server:
+
+```python
+from mcpsync import SyncMCPClient, HttpServerParameters
+
+params = HttpServerParameters(
+    url="https://mcp.example.com/api",
+    headers={"Authorization": "Bearer ..."},
+    timeout=10.0,
+)
+
+with SyncMCPClient(params) as client:
+    resources = client.list_resources()
+    contents = client.read_resource(resources[0].uri)
+```
+
+Turn any async MCP helper into a sync function with the `@sync`
+decorator:
+
+```python
+from mcpsync import sync
+
+@sync
+async def load_schema(server_url: str) -> dict:
+    async with some_async_helper(server_url) as helper:
+        return await helper.fetch_schema()
+```
+
+## ⚡ Performance & Benchmarks
+
+We publish `benchmarks/BENCHMARK.md` per Invariant 14 — including
+the methodology caveat. The honest summary: mcpsync uses
+`asyncio.Runner` per call, which actually benchmarks ~15% faster
+than the SDK's `asyncio.run` pattern in this setup (interpreter
+boot dominates; relative comparison is meaningful). Reproduce
+locally:
+
+```bash
+python benchmarks/run_benchmark.py
+```
+
+The full results table, methodology, and the trade-off
+transparency statement are in
+[benchmarks/BENCHMARK.md](benchmarks/BENCHMARK.md).
+
+## Why `mcpsync`? (Problem & Trade-Off Statement)
+
+The MCP Python SDK ships an **async-only** client. Synchronous callers
+(Django views, CLI tools, scripts) hit the same wall: every
+`asyncio.run()` from sync code re-creates an event loop, leaks
+resources, and breaks under `asyncio.run()` recursion if the
+surrounding runtime already runs a loop.
+
+Two GitHub issues document the gap:
+
+- [`modelcontextprotocol/python-sdk#1223`](https://github.com/modelcontextprotocol/python-sdk/issues/1223) — "Sync client API" (open, multiple reactions)
+- `modelcontextprotocol/python-sdk` — the SDK explicitly documents
+  the `client.session.stdio` use pattern as **async only**.
+
+**What mcpsync is:** a thin wrapper that gives you `SyncMCPClient` +
+a `@sync` decorator, plus a CLI for ad-hoc inspection. It uses the
+official `mcp` SDK under the hood and never re-implements the JSON-RPC
+protocol or transport.
+
+**What mcpsync is NOT:**
+- Not a replacement for the `mcp` SDK — it depends on it.
+- Not an MCP server implementation. It's a client.
+- Not magic. Each `SyncMCPClient.list_tools()` call creates a
+  one-shot event loop on a worker thread. If you need 100k calls/sec,
+  use the SDK's async client directly.
+
+**Trade-offs you accept by using mcpsync:**
+- Each `SyncMCPClient` call creates a fresh `asyncio.Runner` on a
+  worker thread. The bench shows this is ~15% faster than the SDK
+  baseline, but for a true long-lived async loop you should use
+  the SDK's async client directly.
+- The close path needs a wall-clock fuse to escape a known deadlock
+  in the `mcp` SDK's `stdio_client.__aexit__` shielded cancel scope.
+  Without the fuse the caller's process hangs. See
+  `src/mcpsync/client.py::_run_bounded` and the docstring on
+  `SyncMCPClient.close()`.
+- HTTP transport requires the `mcp` SDK's optional `httpx2` dep,
+  which is re-exported by `mcp` for convenience.
+
+## Key Features & Complete API / CLI Reference
+
+### Library API
+
+| Name | Returns | Notes |
+|---|---|---|
+| `StdioServerParameters(command, args, env, cwd)` | dataclass | spawn the server as a subprocess |
+| `HttpServerParameters(url, headers, timeout)` | dataclass | connect to a streamable-HTTP MCP server |
+| `SyncMCPClient(params)` | context manager | open the session; use as `with` block |
+| `client.list_tools()` | `list[Tool]` | tool descriptors from `mcp.types.Tool` |
+| `client.list_resources()` | `list[Resource]` | resource descriptors from `mcp.types.Resource` |
+| `client.call_tool(name, arguments)` | `CallToolResult` | invoke a tool; `result.content` is a list of typed blocks |
+| `client.read_resource(uri)` | `ReadResourceResult` | fetch a resource by URI |
+| `@sync` decorator | wraps an async function into a sync one | uses a per-call event loop |
+| `MCPError` | exception | re-exported from `mcp.shared.exceptions` |
+
+All public types are fully type-hinted. A `py.typed` marker ships in
+`src/mcpsync/` for PEP 561.
+
+### CLI
+
+```text
+$ mcpsync --help
+usage: mcpsync [-h] [--version] {stdio,http} ...
+
+Synchronous client for MCP servers.
+
+$ mcpsync stdio list-tools -- python -m my_server
+[
+  {"name": "echo", "description": "Echo the input message back", "inputSchema": {...}},
+  ...
+]
+
+$ mcpsync stdio call-tool add '{"a":2,"b":3}' -- python -m my_server
+{"content":[{"type":"text","text":"5"}]}
+
+$ mcpsync stdio list-resources -- python -m my_server
+[{"uri": "file:///greeting.txt", "name": "greeting", "mimeType": "text/plain"}, ...]
+
+$ mcpsync stdio call-resource 'file:///greeting.txt' -- python -m my_server
+{"contents":[{"uri": "file:///greeting.txt", "text": "Hello!", "mimeType": "text/plain"}]}
+
+$ mcpsync http list-tools --url https://mcp.example.com/api
+$ mcpsync http call-tool add '{"a":2}' --url https://mcp.example.com/api
+```
+
+The `stdio` subcommand takes a `--` separator before the server
+command + args. The `http` subcommand takes `--url`, `--header` (repeatable
+`KEY=VAL`), and `--timeout`.
+
+### Out of scope
+
+- MCP server implementation
+- Long-lived event-loop reuse across calls (each call creates a new
+  one; see trade-off above)
+- Streaming / subscription primitives
+- Server-side protocol: `mcpsync` is a client only
+- Any protocol version below what the bundled `mcp` SDK supports
+
+### Limitations
+
+- **One shot per call.** Each `SyncMCPClient` use opens the server
+  process, runs the request, and closes. If you need a long-lived
+  connection, keep the `with` block open and make many calls inside.
+- **HTTP transport** requires the `httpx2` runtime dep (re-exported
+  by `mcp` for convenience).
+- **Close path** is bounded by a wall-clock fuse to avoid a known
+  deadlock in the `mcp` SDK's stdio teardown.
+
+## Tests
+
+```bash
+pytest tests/ -q
+```
+
+129 tests across 1 file (split into 16 test classes by behavior).
+Coverage spans every spec acceptance criterion plus angular sweep
+(empty/None inputs, unicode, large payloads, malformed JSON, CLI
+end-to-end, concurrent `@sync` calls, parameter adversarial
+inputs, and regression guards for the close-path deadlock).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

mcpsync_cli-0.1.0/README.md

@@ -0,0 +1,213 @@
+# mcpsync
+
+[![PyPI](https://img.shields.io/badge/version-0.1.0-blue)](https://pypi.org/project/mcpsync)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/badge/tests-129%20passing-brightgreen.svg)](tests/)
+[![Min runtime deps](https://img.shields.io/badge/dependencies-mcp-blue)](pyproject.toml)
+
+> **Synchronous Python API for MCP servers — stdio and HTTP transports, plus a CLI for ad-hoc inspection.**
+
+`mcpsync` wraps the official `mcp` Python SDK's async client behind a
+blocking `SyncMCPClient` so you can call MCP tools, list resources, and
+read resources from synchronous code (CLI tools, Django views, Flask
+handlers, scripts). It also ships a CLI for ad-hoc server inspection
+from the shell.
+
+## Quick Start
+
+Install from source:
+
+```bash
+pip install git+https://github.com/prasad-a-abhishek/mcpsync.git
+```
+
+Connect to a stdio MCP server and call a tool:
+
+```python
+from mcpsync import SyncMCPClient, StdioServerParameters
+
+params = StdioServerParameters(
+    command="python", args=("-m", "my_mcp_server"),
+    env={"DEBUG": "1"},
+    cwd="/srv/myapp",
+)
+
+with SyncMCPClient(params) as client:
+    tools = client.list_tools()
+    for tool in tools:
+        print(f"- {tool.name}: {tool.description}")
+
+    result = client.call_tool("add", {"a": 2, "b": 3})
+    for block in result.content:
+        print(block.text)
+```
+
+Connect to an HTTP MCP server:
+
+```python
+from mcpsync import SyncMCPClient, HttpServerParameters
+
+params = HttpServerParameters(
+    url="https://mcp.example.com/api",
+    headers={"Authorization": "Bearer ..."},
+    timeout=10.0,
+)
+
+with SyncMCPClient(params) as client:
+    resources = client.list_resources()
+    contents = client.read_resource(resources[0].uri)
+```
+
+Turn any async MCP helper into a sync function with the `@sync`
+decorator:
+
+```python
+from mcpsync import sync
+
+@sync
+async def load_schema(server_url: str) -> dict:
+    async with some_async_helper(server_url) as helper:
+        return await helper.fetch_schema()
+```
+
+## ⚡ Performance & Benchmarks
+
+We publish `benchmarks/BENCHMARK.md` per Invariant 14 — including
+the methodology caveat. The honest summary: mcpsync uses
+`asyncio.Runner` per call, which actually benchmarks ~15% faster
+than the SDK's `asyncio.run` pattern in this setup (interpreter
+boot dominates; relative comparison is meaningful). Reproduce
+locally:
+
+```bash
+python benchmarks/run_benchmark.py
+```
+
+The full results table, methodology, and the trade-off
+transparency statement are in
+[benchmarks/BENCHMARK.md](benchmarks/BENCHMARK.md).
+
+## Why `mcpsync`? (Problem & Trade-Off Statement)
+
+The MCP Python SDK ships an **async-only** client. Synchronous callers
+(Django views, CLI tools, scripts) hit the same wall: every
+`asyncio.run()` from sync code re-creates an event loop, leaks
+resources, and breaks under `asyncio.run()` recursion if the
+surrounding runtime already runs a loop.
+
+Two GitHub issues document the gap:
+
+- [`modelcontextprotocol/python-sdk#1223`](https://github.com/modelcontextprotocol/python-sdk/issues/1223) — "Sync client API" (open, multiple reactions)
+- `modelcontextprotocol/python-sdk` — the SDK explicitly documents
+  the `client.session.stdio` use pattern as **async only**.
+
+**What mcpsync is:** a thin wrapper that gives you `SyncMCPClient` +
+a `@sync` decorator, plus a CLI for ad-hoc inspection. It uses the
+official `mcp` SDK under the hood and never re-implements the JSON-RPC
+protocol or transport.
+
+**What mcpsync is NOT:**
+- Not a replacement for the `mcp` SDK — it depends on it.
+- Not an MCP server implementation. It's a client.
+- Not magic. Each `SyncMCPClient.list_tools()` call creates a
+  one-shot event loop on a worker thread. If you need 100k calls/sec,
+  use the SDK's async client directly.
+
+**Trade-offs you accept by using mcpsync:**
+- Each `SyncMCPClient` call creates a fresh `asyncio.Runner` on a
+  worker thread. The bench shows this is ~15% faster than the SDK
+  baseline, but for a true long-lived async loop you should use
+  the SDK's async client directly.
+- The close path needs a wall-clock fuse to escape a known deadlock
+  in the `mcp` SDK's `stdio_client.__aexit__` shielded cancel scope.
+  Without the fuse the caller's process hangs. See
+  `src/mcpsync/client.py::_run_bounded` and the docstring on
+  `SyncMCPClient.close()`.
+- HTTP transport requires the `mcp` SDK's optional `httpx2` dep,
+  which is re-exported by `mcp` for convenience.
+
+## Key Features & Complete API / CLI Reference
+
+### Library API
+
+| Name | Returns | Notes |
+|---|---|---|
+| `StdioServerParameters(command, args, env, cwd)` | dataclass | spawn the server as a subprocess |
+| `HttpServerParameters(url, headers, timeout)` | dataclass | connect to a streamable-HTTP MCP server |
+| `SyncMCPClient(params)` | context manager | open the session; use as `with` block |
+| `client.list_tools()` | `list[Tool]` | tool descriptors from `mcp.types.Tool` |
+| `client.list_resources()` | `list[Resource]` | resource descriptors from `mcp.types.Resource` |
+| `client.call_tool(name, arguments)` | `CallToolResult` | invoke a tool; `result.content` is a list of typed blocks |
+| `client.read_resource(uri)` | `ReadResourceResult` | fetch a resource by URI |
+| `@sync` decorator | wraps an async function into a sync one | uses a per-call event loop |
+| `MCPError` | exception | re-exported from `mcp.shared.exceptions` |
+
+All public types are fully type-hinted. A `py.typed` marker ships in
+`src/mcpsync/` for PEP 561.
+
+### CLI
+
+```text
+$ mcpsync --help
+usage: mcpsync [-h] [--version] {stdio,http} ...
+
+Synchronous client for MCP servers.
+
+$ mcpsync stdio list-tools -- python -m my_server
+[
+  {"name": "echo", "description": "Echo the input message back", "inputSchema": {...}},
+  ...
+]
+
+$ mcpsync stdio call-tool add '{"a":2,"b":3}' -- python -m my_server
+{"content":[{"type":"text","text":"5"}]}
+
+$ mcpsync stdio list-resources -- python -m my_server
+[{"uri": "file:///greeting.txt", "name": "greeting", "mimeType": "text/plain"}, ...]
+
+$ mcpsync stdio call-resource 'file:///greeting.txt' -- python -m my_server
+{"contents":[{"uri": "file:///greeting.txt", "text": "Hello!", "mimeType": "text/plain"}]}
+
+$ mcpsync http list-tools --url https://mcp.example.com/api
+$ mcpsync http call-tool add '{"a":2}' --url https://mcp.example.com/api
+```
+
+The `stdio` subcommand takes a `--` separator before the server
+command + args. The `http` subcommand takes `--url`, `--header` (repeatable
+`KEY=VAL`), and `--timeout`.
+
+### Out of scope
+
+- MCP server implementation
+- Long-lived event-loop reuse across calls (each call creates a new
+  one; see trade-off above)
+- Streaming / subscription primitives
+- Server-side protocol: `mcpsync` is a client only
+- Any protocol version below what the bundled `mcp` SDK supports
+
+### Limitations
+
+- **One shot per call.** Each `SyncMCPClient` use opens the server
+  process, runs the request, and closes. If you need a long-lived
+  connection, keep the `with` block open and make many calls inside.
+- **HTTP transport** requires the `httpx2` runtime dep (re-exported
+  by `mcp` for convenience).
+- **Close path** is bounded by a wall-clock fuse to avoid a known
+  deadlock in the `mcp` SDK's stdio teardown.
+
+## Tests
+
+```bash
+pytest tests/ -q
+```
+
+129 tests across 1 file (split into 16 test classes by behavior).
+Coverage spans every spec acceptance criterion plus angular sweep
+(empty/None inputs, unicode, large payloads, malformed JSON, CLI
+end-to-end, concurrent `@sync` calls, parameter adversarial
+inputs, and regression guards for the close-path deadlock).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

mcpsync_cli-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "mcpsync-cli"
+version = "0.1.0"
+description = "Synchronous MCP Python client — call MCP servers from sync Python without async/await"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+authors = [
+    {name = "Repo Factory", email = "noreply@example.com"},
+]
+keywords = [
+    "mcp",
+    "model-context-protocol",
+    "synchronous",
+    "sync",
+    "client",
+    "stdio",
+    "http",
+    "streamable-http",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+# mcpsync wraps the official `mcp` SDK. It introduces NO deps beyond `mcp` + stdlib.
+# See spec.md acceptance criterion #14: no third-party imports outside stdlib.
+dependencies = [
+    "mcp>=1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]
+
+[project.scripts]
+mcpsync = "mcpsync.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/prasad-a-abhishek/mcpsync"
+Repository = "https://github.com/prasad-a-abhishek/mcpsync"
+Issues = "https://github.com/prasad-a-abhishek/mcpsync/issues"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+mcpsync = ["py.typed", "*.pyi"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

mcpsync_cli-0.1.0/setup.cfg

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

mcpsync_cli-0.1.0/src/mcpsync/__init__.py

@@ -0,0 +1,31 @@
+"""``mcpsync`` — Synchronous MCP Python client.
+
+Call MCP servers from sync Python without ``async``/``await``. Wraps the
+official `mcp` SDK's async ``ClientSession`` inside a dedicated
+``asyncio.Runner`` per session, and exposes ``call_tool``, ``list_tools``,
+``call_resource``, and ``list_resources`` as plain blocking methods.
+
+Example::
+
+    from mcpsync import SyncMCPClient, StdioServerParameters
+
+    params = StdioServerParameters(command="python", args=["-m", "my_server"])
+    with SyncMCPClient(params) as client:
+        tools = client.list_tools()
+        result = client.call_tool("git_log", {"n": 5})
+"""
+
+from mcpsync.client import SyncMCPClient
+from mcpsync.errors import MCPError
+from mcpsync.params import HttpServerParameters, StdioServerParameters
+from mcpsync.sync import sync
+
+__all__ = [
+    "HttpServerParameters",
+    "MCPError",
+    "StdioServerParameters",
+    "SyncMCPClient",
+    "sync",
+]
+
+__version__ = "0.1.0"

mcpsync_cli-0.1.0/src/mcpsync/__init__.pyi

@@ -0,0 +1,64 @@
+"""Type stubs for the ``mcpsync`` public API."""
+
+from collections.abc import Callable, Mapping
+from types import TracebackType
+from typing import Any, ParamSpec, TypeVar
+
+from typing_extensions import Self
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+class StdioServerParameters:
+    command: str
+    args: tuple[str, ...]
+    env: Mapping[str, str] | None
+    cwd: str | None
+    def __init__(
+        self,
+        command: str,
+        args: tuple[str, ...] | list[str] = (),
+        env: Mapping[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> None: ...
+    def to_argv(self) -> list[str]: ...
+
+class HttpServerParameters:
+    url: str
+    headers: Mapping[str, str]
+    timeout: float
+    def __init__(
+        self,
+        url: str,
+        headers: Mapping[str, str] | None = None,
+        timeout: float = 30.0,
+    ) -> None: ...
+
+class MCPError(Exception):
+    code: int
+    message: str
+    data: Any
+    def __init__(self, code: int, message: str, data: Any = None) -> None: ...
+
+class SyncMCPClient:
+    def __init__(
+        self,
+        params: StdioServerParameters | HttpServerParameters,
+        *,
+        timeout: float | None = None,
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    def list_tools(self) -> list[Any]: ...
+    def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> Any: ...
+    def list_resources(self) -> list[Any]: ...
+    def call_resource(self, uri: str) -> Any: ...
+    def read_resource(self, uri: str) -> Any: ...
+    def close(self) -> None: ...
+
+def sync(fn: Callable[P, Any]) -> Callable[P, Any]: ...

mcpsync_cli-0.1.0/src/mcpsync/__main__.py

@@ -0,0 +1,5 @@
+"""Allow ``python -m mcpsync`` to invoke the CLI."""
+
+from mcpsync.cli import main
+
+raise SystemExit(main())