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

acp/client/session.py

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

acp/client/sse.py

@@ -1,145 +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 acp.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()
-        except Exception as ex:
-            logger.error(f"Error in post_writer: {ex}")
-            raise
-        finally:
-            await read_stream_writer.aclose()
-            await write_stream.aclose()

acp/client/stdio.py

@@ -1,153 +0,0 @@
-import os
-import sys
-from contextlib import asynccontextmanager
-from typing import Literal
-
-import anyio
-import anyio.lowlevel
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from anyio.streams.text import TextReceiveStream
-from pydantic import BaseModel, Field
-
-import acp.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.
-    """
-
-    encoding: str = "utf-8"
-    """
-    The text encoding used when sending/receiving messages to the server
-
-    defaults to utf-8
-    """
-
-    encoding_error_handler: Literal["strict", "ignore", "replace"] = "strict"
-    """
-    The text encoding error handler.
-
-    See https://docs.python.org/3/library/codecs.html#codec-base-classes for
-    explanations of possible values
-    """
-
-
-@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,
-                    encoding=server.encoding,
-                    errors=server.encoding_error_handler,
-                ):
-                    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(
-                            encoding=server.encoding,
-                            errors=server.encoding_error_handler,
-                        )
-                    )
-        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

acp/server/__init__.py

@@ -1,3 +0,0 @@
-from .lowlevel import NotificationOptions, Server
-
-__all__ = ["Server", "NotificationOptions"]