acp-sdk 0.0.6__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

acp/server/session.py

@@ -1,315 +0,0 @@
-"""
-ServerSession Module
-
-This module provides the ServerSession class, which manages communication between the
-server and client in the MCP (Model Context Protocol) framework. It is most commonly
-used in MCP servers to interact with the client.
-
-Common usage pattern:
-```
-    server = Server(name)
-
-    @server.call_tool()
-    async def handle_tool_call(ctx: RequestContext, arguments: dict[str, Any]) -> Any:
-        # Check client capabilities before proceeding
-        if ctx.session.check_client_capability(
-            types.ClientCapabilities(experimental={"advanced_tools": dict()})
-        ):
-            # Perform advanced tool operations
-            result = await perform_advanced_tool_operation(arguments)
-        else:
-            # Fall back to basic tool operations
-            result = await perform_basic_tool_operation(arguments)
-
-        return result
-
-    @server.list_prompts()
-    async def handle_list_prompts(ctx: RequestContext) -> list[types.Prompt]:
-        # Access session for any necessary checks or operations
-        if ctx.session.client_params:
-            # Customize prompts based on client initialization parameters
-            return generate_custom_prompts(ctx.session.client_params)
-        else:
-            return default_prompts
-```
-
-The ServerSession class is typically used internally by the Server class and should not
-be instantiated directly by users of the MCP framework.
-"""
-
-from enum import Enum
-from typing import Any
-
-import anyio
-import anyio.lowlevel
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from pydantic import AnyUrl
-
-import acp.types as types
-from acp.server.models import InitializationOptions
-from acp.shared.session import (
-    BaseSession,
-    RequestResponder,
-)
-
-
-class InitializationState(Enum):
-    NotInitialized = 1
-    Initializing = 2
-    Initialized = 3
-
-
-class ServerSession(
-    BaseSession[
-        types.ServerRequest,
-        types.ServerNotification,
-        types.ServerResult,
-        types.ClientRequest,
-        types.ClientNotification,
-    ]
-):
-    _initialized: InitializationState = InitializationState.NotInitialized
-    _client_params: types.InitializeRequestParams | None = None
-
-    def __init__(
-        self,
-        read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception],
-        write_stream: MemoryObjectSendStream[types.JSONRPCMessage],
-        init_options: InitializationOptions,
-    ) -> None:
-        super().__init__(
-            read_stream, write_stream, types.ClientRequest, types.ClientNotification
-        )
-        self._initialization_state = InitializationState.NotInitialized
-        self._init_options = init_options
-
-    @property
-    def client_params(self) -> types.InitializeRequestParams | None:
-        return self._client_params
-
-    def check_client_capability(self, capability: types.ClientCapabilities) -> bool:
-        """Check if the client supports a specific capability."""
-        if self._client_params is None:
-            return False
-
-        # Get client capabilities from initialization params
-        client_caps = self._client_params.capabilities
-
-        # Check each specified capability in the passed in capability object
-        if capability.roots is not None:
-            if client_caps.roots is None:
-                return False
-            if capability.roots.listChanged and not client_caps.roots.listChanged:
-                return False
-
-        if capability.sampling is not None:
-            if client_caps.sampling is None:
-                return False
-
-        if capability.experimental is not None:
-            if client_caps.experimental is None:
-                return False
-            # Check each experimental capability
-            for exp_key, exp_value in capability.experimental.items():
-                if (
-                    exp_key not in client_caps.experimental
-                    or client_caps.experimental[exp_key] != exp_value
-                ):
-                    return False
-
-        return True
-
-    async def _received_request(
-        self, responder: RequestResponder[types.ClientRequest, types.ServerResult]
-    ):
-        match responder.request.root:
-            case types.InitializeRequest(params=params):
-                self._initialization_state = InitializationState.Initializing
-                self._client_params = params
-                async with responder:
-                    await responder.respond(
-                        types.ServerResult(
-                            types.InitializeResult(
-                                protocolVersion=types.LATEST_PROTOCOL_VERSION,
-                                capabilities=self._init_options.capabilities,
-                                serverInfo=types.Implementation(
-                                    name=self._init_options.server_name,
-                                    version=self._init_options.server_version,
-                                ),
-                                instructions=self._init_options.instructions,
-                            )
-                        )
-                    )
-            case _:
-                if self._initialization_state != InitializationState.Initialized:
-                    raise RuntimeError(
-                        "Received request before initialization was complete"
-                    )
-
-    async def _received_notification(
-        self, notification: types.ClientNotification
-    ) -> None:
-        # Need this to avoid ASYNC910
-        await anyio.lowlevel.checkpoint()
-        match notification.root:
-            case types.InitializedNotification():
-                self._initialization_state = InitializationState.Initialized
-            case _:
-                if self._initialization_state != InitializationState.Initialized:
-                    raise RuntimeError(
-                        "Received notification before initialization was complete"
-                    )
-
-    async def send_log_message(
-        self, level: types.LoggingLevel, data: Any, logger: str | None = None
-    ) -> None:
-        """Send a log message notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.LoggingMessageNotification(
-                    method="notifications/message",
-                    params=types.LoggingMessageNotificationParams(
-                        level=level,
-                        data=data,
-                        logger=logger,
-                    ),
-                )
-            )
-        )
-
-    async def send_resource_updated(self, uri: AnyUrl) -> None:
-        """Send a resource updated notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.ResourceUpdatedNotification(
-                    method="notifications/resources/updated",
-                    params=types.ResourceUpdatedNotificationParams(uri=uri),
-                )
-            )
-        )
-
-    async def create_message(
-        self,
-        messages: list[types.SamplingMessage],
-        *,
-        max_tokens: int,
-        system_prompt: str | None = None,
-        include_context: types.IncludeContext | None = None,
-        temperature: float | None = None,
-        stop_sequences: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        model_preferences: types.ModelPreferences | None = None,
-    ) -> types.CreateMessageResult:
-        """Send a sampling/create_message request."""
-        return await self.send_request(
-            types.ServerRequest(
-                types.CreateMessageRequest(
-                    method="sampling/createMessage",
-                    params=types.CreateMessageRequestParams(
-                        messages=messages,
-                        systemPrompt=system_prompt,
-                        includeContext=include_context,
-                        temperature=temperature,
-                        maxTokens=max_tokens,
-                        stopSequences=stop_sequences,
-                        metadata=metadata,
-                        modelPreferences=model_preferences,
-                    ),
-                )
-            ),
-            types.CreateMessageResult,
-        )
-
-    async def list_roots(self) -> types.ListRootsResult:
-        """Send a roots/list request."""
-        return await self.send_request(
-            types.ServerRequest(
-                types.ListRootsRequest(
-                    method="roots/list",
-                )
-            ),
-            types.ListRootsResult,
-        )
-
-    async def send_ping(self) -> types.EmptyResult:
-        """Send a ping request."""
-        return await self.send_request(
-            types.ServerRequest(
-                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.ServerNotification(
-                types.ProgressNotification(
-                    method="notifications/progress",
-                    params=types.ProgressNotificationParams(
-                        progressToken=progress_token,
-                        progress=progress,
-                        total=total,
-                    ),
-                )
-            )
-        )
-
-    async def send_resource_list_changed(self) -> None:
-        """Send a resource list changed notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.ResourceListChangedNotification(
-                    method="notifications/resources/list_changed",
-                )
-            )
-        )
-
-    async def send_tool_list_changed(self) -> None:
-        """Send a tool list changed notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.ToolListChangedNotification(
-                    method="notifications/tools/list_changed",
-                )
-            )
-        )
-
-    async def send_prompt_list_changed(self) -> None:
-        """Send a prompt list changed notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.PromptListChangedNotification(
-                    method="notifications/prompts/list_changed",
-                )
-            )
-        )
-
-    async def send_agents_list_changed(self) -> None:
-        """Send an agent list changed notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.AgentListChangedNotification(
-                    method="notifications/agents/list_changed",
-                )
-            )
-        )
-
-    async def send_agent_run_progress(
-        self, progress_token: str | int, delta: dict[str, Any]
-    ) -> None:
-        """Send an agent run progress notification."""
-        await self.send_notification(
-            types.ServerNotification(
-                types.AgentRunProgressNotification(
-                    method="notifications/agents/run/progress",
-                    params=types.AgentRunProgressNotificationParams(
-                        progressToken=progress_token, delta=delta
-                    ),
-                )
-            )
-        )

acp/server/sse.py

@@ -1,175 +0,0 @@
-"""
-SSE Server Transport Module
-
-This module implements a Server-Sent Events (SSE) transport layer for MCP servers.
-
-Example usage:
-```
-    # Create an SSE transport at an endpoint
-    sse = SseServerTransport("/messages/")
-
-    # Create Starlette routes for SSE and message handling
-    routes = [
-        Route("/sse", endpoint=handle_sse),
-        Mount("/messages/", app=sse.handle_post_message),
-    ]
-
-    # Define handler functions
-    async def handle_sse(request):
-        async with sse.connect_sse(
-            request.scope, request.receive, request._send
-        ) as streams:
-            await app.run(
-                streams[0], streams[1], app.create_initialization_options()
-            )
-
-    # Create and run Starlette app
-    starlette_app = Starlette(routes=routes)
-    uvicorn.run(starlette_app, host="0.0.0.0", port=port)
-```
-
-See SseServerTransport class documentation for more details.
-"""
-
-import logging
-from contextlib import asynccontextmanager
-from typing import Any
-from urllib.parse import quote
-from uuid import UUID, uuid4
-
-import anyio
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from pydantic import ValidationError
-from sse_starlette import EventSourceResponse
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.types import Receive, Scope, Send
-
-import acp.types as types
-
-logger = logging.getLogger(__name__)
-
-
-class SseServerTransport:
-    """
-    SSE server transport for MCP. This class provides _two_ ASGI applications,
-    suitable to be used with a framework like Starlette and a server like Hypercorn:
-
-        1. connect_sse() is an ASGI application which receives incoming GET requests,
-           and sets up a new SSE stream to send server messages to the client.
-        2. handle_post_message() is an ASGI application which receives incoming POST
-           requests, which should contain client messages that link to a
-           previously-established SSE session.
-    """
-
-    _endpoint: str
-    _read_stream_writers: dict[
-        UUID, MemoryObjectSendStream[types.JSONRPCMessage | Exception]
-    ]
-
-    def __init__(self, endpoint: str) -> None:
-        """
-        Creates a new SSE server transport, which will direct the client to POST
-        messages to the relative or absolute URL given.
-        """
-
-        super().__init__()
-        self._endpoint = endpoint
-        self._read_stream_writers = {}
-        logger.debug(f"SseServerTransport initialized with endpoint: {endpoint}")
-
-    @asynccontextmanager
-    async def connect_sse(self, scope: Scope, receive: Receive, send: Send):
-        if scope["type"] != "http":
-            logger.error("connect_sse received non-HTTP request")
-            raise ValueError("connect_sse can only handle HTTP requests")
-
-        logger.debug("Setting up SSE connection")
-        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)
-
-        session_id = uuid4()
-        session_uri = f"{quote(self._endpoint)}?session_id={session_id.hex}"
-        self._read_stream_writers[session_id] = read_stream_writer
-        logger.debug(f"Created new session with ID: {session_id}")
-
-        sse_stream_writer, sse_stream_reader = anyio.create_memory_object_stream[
-            dict[str, Any]
-        ](0)
-
-        async def sse_writer():
-            logger.debug("Starting SSE writer")
-            async with sse_stream_writer, write_stream_reader:
-                await sse_stream_writer.send({"event": "endpoint", "data": session_uri})
-                logger.debug(f"Sent endpoint event: {session_uri}")
-
-                async for message in write_stream_reader:
-                    logger.debug(f"Sending message via SSE: {message}")
-                    await sse_stream_writer.send(
-                        {
-                            "event": "message",
-                            "data": message.model_dump_json(
-                                by_alias=True, exclude_none=True
-                            ),
-                        }
-                    )
-
-        async with anyio.create_task_group() as tg:
-            response = EventSourceResponse(
-                content=sse_stream_reader, data_sender_callable=sse_writer
-            )
-            logger.debug("Starting SSE response task")
-            tg.start_soon(response, scope, receive, send)
-
-            logger.debug("Yielding read and write streams")
-            yield (read_stream, write_stream)
-
-    async def handle_post_message(
-        self, scope: Scope, receive: Receive, send: Send
-    ) -> None:
-        logger.debug("Handling POST message")
-        request = Request(scope, receive)
-
-        session_id_param = request.query_params.get("session_id")
-        if session_id_param is None:
-            logger.warning("Received request without session_id")
-            response = Response("session_id is required", status_code=400)
-            return await response(scope, receive, send)
-
-        try:
-            session_id = UUID(hex=session_id_param)
-            logger.debug(f"Parsed session ID: {session_id}")
-        except ValueError:
-            logger.warning(f"Received invalid session ID: {session_id_param}")
-            response = Response("Invalid session ID", status_code=400)
-            return await response(scope, receive, send)
-
-        writer = self._read_stream_writers.get(session_id)
-        if not writer:
-            logger.warning(f"Could not find session for ID: {session_id}")
-            response = Response("Could not find session", status_code=404)
-            return await response(scope, receive, send)
-
-        json = await request.json()
-        logger.debug(f"Received JSON: {json}")
-
-        try:
-            message = types.JSONRPCMessage.model_validate(json)
-            logger.debug(f"Validated client message: {message}")
-        except ValidationError as err:
-            logger.error(f"Failed to parse message: {err}")
-            response = Response("Could not parse message", status_code=400)
-            await response(scope, receive, send)
-            await writer.send(err)
-            return
-
-        logger.debug(f"Sending message to writer: {message}")
-        response = Response("Accepted", status_code=202)
-        await response(scope, receive, send)
-        await writer.send(message)

acp/server/stdio.py

@@ -1,83 +0,0 @@
-"""
-Stdio Server Transport Module
-
-This module provides functionality for creating an stdio-based transport layer
-that can be used to communicate with an MCP client through standard input/output
-streams.
-
-Example usage:
-```
-    async def run_server():
-        async with stdio_server() as (read_stream, write_stream):
-            # read_stream contains incoming JSONRPCMessages from stdin
-            # write_stream allows sending JSONRPCMessages to stdout
-            server = await create_my_server()
-            await server.run(read_stream, write_stream, init_options)
-
-    anyio.run(run_server)
-```
-"""
-
-import sys
-from contextlib import asynccontextmanager
-
-import anyio
-import anyio.lowlevel
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-
-import acp.types as types
-
-
-@asynccontextmanager
-async def stdio_server(
-    stdin: anyio.AsyncFile[str] | None = None,
-    stdout: anyio.AsyncFile[str] | None = None,
-):
-    """
-    Server transport for stdio: this communicates with an MCP client by reading
-    from the current process' stdin and writing to stdout.
-    """
-    # Purposely not using context managers for these, as we don't want to close
-    # standard process handles.
-    if not stdin:
-        stdin = anyio.wrap_file(sys.stdin)
-    if not stdout:
-        stdout = anyio.wrap_file(sys.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)
-
-    async def stdin_reader():
-        try:
-            async with read_stream_writer:
-                async for line in stdin:
-                    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 stdout_writer():
-        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 stdout.write(json + "\n")
-                    await stdout.flush()
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
-
-    async with anyio.create_task_group() as tg:
-        tg.start_soon(stdin_reader)
-        tg.start_soon(stdout_writer)
-        yield read_stream, write_stream

acp/server/websocket.py

@@ -1,61 +0,0 @@
-import logging
-from contextlib import asynccontextmanager
-
-import anyio
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from starlette.types import Receive, Scope, Send
-from starlette.websockets import WebSocket
-
-import acp.types as types
-
-logger = logging.getLogger(__name__)
-
-
-@asynccontextmanager
-async def websocket_server(scope: Scope, receive: Receive, send: Send):
-    """
-    WebSocket server transport for MCP. This is an ASGI application, suitable to be
-    used with a framework like Starlette and a server like Hypercorn.
-    """
-
-    websocket = WebSocket(scope, receive, send)
-    await websocket.accept(subprotocol="mcp")
-
-    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 def ws_reader():
-        try:
-            async with read_stream_writer:
-                async for message in websocket.iter_json():
-                    try:
-                        client_message = types.JSONRPCMessage.model_validate(message)
-                    except Exception as exc:
-                        await read_stream_writer.send(exc)
-                        continue
-
-                    await read_stream_writer.send(client_message)
-        except anyio.ClosedResourceError:
-            await websocket.close()
-
-    async def ws_writer():
-        try:
-            async with write_stream_reader:
-                async for message in write_stream_reader:
-                    obj = message.model_dump(
-                        by_alias=True, mode="json", exclude_none=True
-                    )
-                    await websocket.send_json(obj)
-        except anyio.ClosedResourceError:
-            await websocket.close()
-
-    async with anyio.create_task_group() as tg:
-        tg.start_soon(ws_reader)
-        tg.start_soon(ws_writer)
-        yield (read_stream, write_stream)

acp/shared/context.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass
-from typing import Generic, TypeVar
-
-from acp.shared.session import BaseSession
-from acp.types import RequestId, RequestParams
-
-SessionT = TypeVar("SessionT", bound=BaseSession)
-
-
-@dataclass
-class RequestContext(Generic[SessionT]):
-    request_id: RequestId
-    meta: RequestParams.Meta | None
-    session: SessionT

acp/shared/exceptions.py

@@ -1,14 +0,0 @@
-from acp.types import ErrorData
-
-
-class McpError(Exception):
-    """
-    Exception type raised when an error arrives over an MCP connection.
-    """
-
-    error: ErrorData
-
-    def __init__(self, error: ErrorData):
-        """Initialize McpError."""
-        super().__init__(error.message)
-        self.error = error