wcgw 5.0.2__py3-none-any.whl → 5.1.1__py3-none-any.whl

mcp_wcgw/client/__main__.py

@@ -1,79 +0,0 @@
-import argparse
-import logging
-import sys
-from functools import partial
-from urllib.parse import urlparse
-
-import anyio
-
-from mcp_wcgw.client.session import ClientSession
-from mcp_wcgw.client.sse import sse_client
-from mcp_wcgw.client.stdio import StdioServerParameters, stdio_client
-
-if not sys.warnoptions:
-    import warnings
-
-    warnings.simplefilter("ignore")
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("client")
-
-
-async def receive_loop(session: ClientSession):
-    logger.info("Starting receive loop")
-    async for message in session.incoming_messages:
-        if isinstance(message, Exception):
-            logger.error("Error: %s", message)
-            continue
-
-        logger.info("Received message from server: %s", message)
-
-
-async def run_session(read_stream, write_stream):
-    async with (
-        ClientSession(read_stream, write_stream) as session,
-        anyio.create_task_group() as tg,
-    ):
-        tg.start_soon(receive_loop, session)
-
-        logger.info("Initializing session")
-        await session.initialize()
-        logger.info("Initialized")
-
-
-async def main(command_or_url: str, args: list[str], env: list[tuple[str, str]]):
-    env_dict = dict(env)
-
-    if urlparse(command_or_url).scheme in ("http", "https"):
-        # Use SSE client for HTTP(S) URLs
-        async with sse_client(command_or_url) as streams:
-            await run_session(*streams)
-    else:
-        # Use stdio client for commands
-        server_parameters = StdioServerParameters(
-            command=command_or_url, args=args, env=env_dict
-        )
-        async with stdio_client(server_parameters) as streams:
-            await run_session(*streams)
-
-
-def cli():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("command_or_url", help="Command or URL to connect to")
-    parser.add_argument("args", nargs="*", help="Additional arguments")
-    parser.add_argument(
-        "-e",
-        "--env",
-        nargs=2,
-        action="append",
-        metavar=("KEY", "VALUE"),
-        help="Environment variables to set. Can be used multiple times.",
-        default=[],
-    )
-
-    args = parser.parse_args()
-    anyio.run(partial(main, args.command_or_url, args.args, args.env), backend="trio")
-
-
-if __name__ == "__main__":
-    cli()

mcp_wcgw/client/session.py

@@ -1,234 +0,0 @@
-from datetime import timedelta
-
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from pydantic import AnyUrl
-
-import mcp_wcgw.types as types
-from mcp_wcgw.shared.session import BaseSession
-from mcp_wcgw.shared.version import SUPPORTED_PROTOCOL_VERSIONS
-
-
-class ClientSession(
-    BaseSession[
-        types.ClientRequest,
-        types.ClientNotification,
-        types.ClientResult,
-        types.ServerRequest,
-        types.ServerNotification,
-    ]
-):
-    def __init__(
-        self,
-        read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception],
-        write_stream: MemoryObjectSendStream[types.JSONRPCMessage],
-        read_timeout_seconds: timedelta | None = None,
-    ) -> None:
-        super().__init__(
-            read_stream,
-            write_stream,
-            types.ServerRequest,
-            types.ServerNotification,
-            read_timeout_seconds=read_timeout_seconds,
-        )
-
-    async def initialize(self) -> types.InitializeResult:
-        result = await self.send_request(
-            types.ClientRequest(
-                types.InitializeRequest(
-                    method="initialize",
-                    params=types.InitializeRequestParams(
-                        protocolVersion=types.LATEST_PROTOCOL_VERSION,
-                        capabilities=types.ClientCapabilities(
-                            sampling=None,
-                            experimental=None,
-                            roots=types.RootsCapability(
-                                # TODO: Should this be based on whether we
-                                # _will_ send notifications, or only whether
-                                # they're supported?
-                                listChanged=True
-                            ),
-                        ),
-                        clientInfo=types.Implementation(name="mcp", version="0.1.0"),
-                    ),
-                )
-            ),
-            types.InitializeResult,
-        )
-
-        if result.protocolVersion not in SUPPORTED_PROTOCOL_VERSIONS:
-            raise RuntimeError(
-                "Unsupported protocol version from the server: "
-                f"{result.protocolVersion}"
-            )
-
-        await self.send_notification(
-            types.ClientNotification(
-                types.InitializedNotification(method="notifications/initialized")
-            )
-        )
-
-        return result
-
-    async def send_ping(self) -> types.EmptyResult:
-        """Send a ping request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.PingRequest(
-                    method="ping",
-                )
-            ),
-            types.EmptyResult,
-        )
-
-    async def send_progress_notification(
-        self, progress_token: str | int, progress: float, total: float | None = None
-    ) -> None:
-        """Send a progress notification."""
-        await self.send_notification(
-            types.ClientNotification(
-                types.ProgressNotification(
-                    method="notifications/progress",
-                    params=types.ProgressNotificationParams(
-                        progressToken=progress_token,
-                        progress=progress,
-                        total=total,
-                    ),
-                ),
-            )
-        )
-
-    async def set_logging_level(self, level: types.LoggingLevel) -> types.EmptyResult:
-        """Send a logging/setLevel request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.SetLevelRequest(
-                    method="logging/setLevel",
-                    params=types.SetLevelRequestParams(level=level),
-                )
-            ),
-            types.EmptyResult,
-        )
-
-    async def list_resources(self) -> types.ListResourcesResult:
-        """Send a resources/list request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.ListResourcesRequest(
-                    method="resources/list",
-                )
-            ),
-            types.ListResourcesResult,
-        )
-
-    async def read_resource(self, uri: AnyUrl) -> types.ReadResourceResult:
-        """Send a resources/read request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.ReadResourceRequest(
-                    method="resources/read",
-                    params=types.ReadResourceRequestParams(uri=uri),
-                )
-            ),
-            types.ReadResourceResult,
-        )
-
-    async def subscribe_resource(self, uri: AnyUrl) -> types.EmptyResult:
-        """Send a resources/subscribe request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.SubscribeRequest(
-                    method="resources/subscribe",
-                    params=types.SubscribeRequestParams(uri=uri),
-                )
-            ),
-            types.EmptyResult,
-        )
-
-    async def unsubscribe_resource(self, uri: AnyUrl) -> types.EmptyResult:
-        """Send a resources/unsubscribe request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.UnsubscribeRequest(
-                    method="resources/unsubscribe",
-                    params=types.UnsubscribeRequestParams(uri=uri),
-                )
-            ),
-            types.EmptyResult,
-        )
-
-    async def call_tool(
-        self, name: str, arguments: dict | None = None
-    ) -> types.CallToolResult:
-        """Send a tools/call request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.CallToolRequest(
-                    method="tools/call",
-                    params=types.CallToolRequestParams(name=name, arguments=arguments),
-                )
-            ),
-            types.CallToolResult,
-        )
-
-    async def list_prompts(self) -> types.ListPromptsResult:
-        """Send a prompts/list request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.ListPromptsRequest(
-                    method="prompts/list",
-                )
-            ),
-            types.ListPromptsResult,
-        )
-
-    async def get_prompt(
-        self, name: str, arguments: dict[str, str] | None = None
-    ) -> types.GetPromptResult:
-        """Send a prompts/get request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.GetPromptRequest(
-                    method="prompts/get",
-                    params=types.GetPromptRequestParams(name=name, arguments=arguments),
-                )
-            ),
-            types.GetPromptResult,
-        )
-
-    async def complete(
-        self, ref: types.ResourceReference | types.PromptReference, argument: dict
-    ) -> types.CompleteResult:
-        """Send a completion/complete request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.CompleteRequest(
-                    method="completion/complete",
-                    params=types.CompleteRequestParams(
-                        ref=ref,
-                        argument=types.CompletionArgument(**argument),
-                    ),
-                )
-            ),
-            types.CompleteResult,
-        )
-
-    async def list_tools(self) -> types.ListToolsResult:
-        """Send a tools/list request."""
-        return await self.send_request(
-            types.ClientRequest(
-                types.ListToolsRequest(
-                    method="tools/list",
-                )
-            ),
-            types.ListToolsResult,
-        )
-
-    async def send_roots_list_changed(self) -> None:
-        """Send a roots/list_changed notification."""
-        await self.send_notification(
-            types.ClientNotification(
-                types.RootsListChangedNotification(
-                    method="notifications/roots/list_changed",
-                )
-            )
-        )

mcp_wcgw/client/sse.py

@@ -1,142 +0,0 @@
-import logging
-from contextlib import asynccontextmanager
-from typing import Any
-from urllib.parse import urljoin, urlparse
-
-import anyio
-import httpx
-from anyio.abc import TaskStatus
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from httpx_sse import aconnect_sse
-
-import mcp_wcgw.types as types
-
-logger = logging.getLogger(__name__)
-
-
-def remove_request_params(url: str) -> str:
-    return urljoin(url, urlparse(url).path)
-
-
-@asynccontextmanager
-async def sse_client(
-    url: str,
-    headers: dict[str, Any] | None = None,
-    timeout: float = 5,
-    sse_read_timeout: float = 60 * 5,
-):
-    """
-    Client transport for SSE.
-
-    `sse_read_timeout` determines how long (in seconds) the client will wait for a new
-    event before disconnecting. All other HTTP operations are controlled by `timeout`.
-    """
-    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
-    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
-
-    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
-    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
-
-    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
-    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-
-    async with anyio.create_task_group() as tg:
-        try:
-            logger.info(f"Connecting to SSE endpoint: {remove_request_params(url)}")
-            async with httpx.AsyncClient(headers=headers) as client:
-                async with aconnect_sse(
-                    client,
-                    "GET",
-                    url,
-                    timeout=httpx.Timeout(timeout, read=sse_read_timeout),
-                ) as event_source:
-                    event_source.response.raise_for_status()
-                    logger.debug("SSE connection established")
-
-                    async def sse_reader(
-                        task_status: TaskStatus[str] = anyio.TASK_STATUS_IGNORED,
-                    ):
-                        try:
-                            async for sse in event_source.aiter_sse():
-                                logger.debug(f"Received SSE event: {sse.event}")
-                                match sse.event:
-                                    case "endpoint":
-                                        endpoint_url = urljoin(url, sse.data)
-                                        logger.info(
-                                            f"Received endpoint URL: {endpoint_url}"
-                                        )
-
-                                        url_parsed = urlparse(url)
-                                        endpoint_parsed = urlparse(endpoint_url)
-                                        if (
-                                            url_parsed.netloc != endpoint_parsed.netloc
-                                            or url_parsed.scheme
-                                            != endpoint_parsed.scheme
-                                        ):
-                                            error_msg = (
-                                                "Endpoint origin does not match "
-                                                f"connection origin: {endpoint_url}"
-                                            )
-                                            logger.error(error_msg)
-                                            raise ValueError(error_msg)
-
-                                        task_status.started(endpoint_url)
-
-                                    case "message":
-                                        try:
-                                            message = types.JSONRPCMessage.model_validate_json(  # noqa: E501
-                                                sse.data
-                                            )
-                                            logger.debug(
-                                                f"Received server message: {message}"
-                                            )
-                                        except Exception as exc:
-                                            logger.error(
-                                                f"Error parsing server message: {exc}"
-                                            )
-                                            await read_stream_writer.send(exc)
-                                            continue
-
-                                        await read_stream_writer.send(message)
-                        except Exception as exc:
-                            logger.error(f"Error in sse_reader: {exc}")
-                            await read_stream_writer.send(exc)
-                        finally:
-                            await read_stream_writer.aclose()
-
-                    async def post_writer(endpoint_url: str):
-                        try:
-                            async with write_stream_reader:
-                                async for message in write_stream_reader:
-                                    logger.debug(f"Sending client message: {message}")
-                                    response = await client.post(
-                                        endpoint_url,
-                                        json=message.model_dump(
-                                            by_alias=True,
-                                            mode="json",
-                                            exclude_none=True,
-                                        ),
-                                    )
-                                    response.raise_for_status()
-                                    logger.debug(
-                                        "Client message sent successfully: "
-                                        f"{response.status_code}"
-                                    )
-                        except Exception as exc:
-                            logger.error(f"Error in post_writer: {exc}")
-                        finally:
-                            await write_stream.aclose()
-
-                    endpoint_url = await tg.start(sse_reader)
-                    logger.info(
-                        f"Starting post writer with endpoint URL: {endpoint_url}"
-                    )
-                    tg.start_soon(post_writer, endpoint_url)
-
-                    try:
-                        yield read_stream, write_stream
-                    finally:
-                        tg.cancel_scope.cancel()
-        finally:
-            await read_stream_writer.aclose()
-            await write_stream.aclose()

mcp_wcgw/client/stdio.py

@@ -1,128 +0,0 @@
-import os
-import sys
-from contextlib import asynccontextmanager
-
-import anyio
-import anyio.lowlevel
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from anyio.streams.text import TextReceiveStream
-from pydantic import BaseModel, Field
-
-import mcp_wcgw.types as types
-
-# Environment variables to inherit by default
-DEFAULT_INHERITED_ENV_VARS = (
-    [
-        "APPDATA",
-        "HOMEDRIVE",
-        "HOMEPATH",
-        "LOCALAPPDATA",
-        "PATH",
-        "PROCESSOR_ARCHITECTURE",
-        "SYSTEMDRIVE",
-        "SYSTEMROOT",
-        "TEMP",
-        "USERNAME",
-        "USERPROFILE",
-    ]
-    if sys.platform == "win32"
-    else ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"]
-)
-
-
-def get_default_environment() -> dict[str, str]:
-    """
-    Returns a default environment object including only environment variables deemed
-    safe to inherit.
-    """
-    env: dict[str, str] = {}
-
-    for key in DEFAULT_INHERITED_ENV_VARS:
-        value = os.environ.get(key)
-        if value is None:
-            continue
-
-        if value.startswith("()"):
-            # Skip functions, which are a security risk
-            continue
-
-        env[key] = value
-
-    return env
-
-
-class StdioServerParameters(BaseModel):
-    command: str
-    """The executable to run to start the server."""
-
-    args: list[str] = Field(default_factory=list)
-    """Command line arguments to pass to the executable."""
-
-    env: dict[str, str] | None = None
-    """
-    The environment to use when spawning the process.
-
-    If not specified, the result of get_default_environment() will be used.
-    """
-
-
-@asynccontextmanager
-async def stdio_client(server: StdioServerParameters):
-    """
-    Client transport for stdio: this will connect to a server by spawning a
-    process and communicating with it over stdin/stdout.
-    """
-    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
-    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
-
-    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
-    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
-
-    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
-    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-
-    process = await anyio.open_process(
-        [server.command, *server.args],
-        env=server.env if server.env is not None else get_default_environment(),
-        stderr=sys.stderr,
-    )
-
-    async def stdout_reader():
-        assert process.stdout, "Opened process is missing stdout"
-
-        try:
-            async with read_stream_writer:
-                buffer = ""
-                async for chunk in TextReceiveStream(process.stdout):
-                    lines = (buffer + chunk).split("\n")
-                    buffer = lines.pop()
-
-                    for line in lines:
-                        try:
-                            message = types.JSONRPCMessage.model_validate_json(line)
-                        except Exception as exc:
-                            await read_stream_writer.send(exc)
-                            continue
-
-                        await read_stream_writer.send(message)
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
-
-    async def stdin_writer():
-        assert process.stdin, "Opened process is missing stdin"
-
-        try:
-            async with write_stream_reader:
-                async for message in write_stream_reader:
-                    json = message.model_dump_json(by_alias=True, exclude_none=True)
-                    await process.stdin.send((json + "\n").encode())
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
-
-    async with (
-        anyio.create_task_group() as tg,
-        process,
-    ):
-        tg.start_soon(stdout_reader)
-        tg.start_soon(stdin_writer)
-        yield read_stream, write_stream