acp-sdk 0.0.6__py3-none-any.whl → 0.1.0rc5__py3-none-any.whl

acp_sdk/server/bundle.py

@@ -0,0 +1,131 @@
+import asyncio
+import logging
+from collections.abc import AsyncGenerator
+from concurrent.futures import ThreadPoolExecutor
+
+from opentelemetry import trace
+from pydantic import ValidationError
+
+from acp_sdk.models import (
+    AnyModel,
+    Await,
+    AwaitEvent,
+    AwaitResume,
+    CancelledEvent,
+    CompletedEvent,
+    CreatedEvent,
+    Error,
+    FailedEvent,
+    GenericEvent,
+    InProgressEvent,
+    Message,
+    MessageEvent,
+    Run,
+    RunEvent,
+    RunStatus,
+)
+from acp_sdk.models.errors import ErrorCode
+from acp_sdk.server.agent import Agent
+from acp_sdk.server.logging import logger
+
+
+class RunBundle:
+    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None) -> None:
+        self.agent = agent
+        self.run = run
+        self.task = task
+
+        self.stream_queue: asyncio.Queue[RunEvent] = asyncio.Queue()
+        self.composed_message = Message()
+
+        self.await_queue: asyncio.Queue[AwaitResume] = asyncio.Queue(maxsize=1)
+        self.await_or_terminate_event = asyncio.Event()
+
+    async def stream(self) -> AsyncGenerator[RunEvent]:
+        while True:
+            event = await self.stream_queue.get()
+            if event is None:
+                break
+            yield event
+            self.stream_queue.task_done()
+
+    async def emit(self, event: RunEvent) -> None:
+        await self.stream_queue.put(event)
+
+    async def await_(self) -> AwaitResume:
+        await self.stream_queue.put(None)
+        self.await_queue.empty()
+        self.await_or_terminate_event.set()
+        self.await_or_terminate_event.clear()
+        resume = await self.await_queue.get()
+        self.await_queue.task_done()
+        return resume
+
+    async def resume(self, resume: AwaitResume) -> None:
+        self.stream_queue = asyncio.Queue()
+        await self.await_queue.put(resume)
+
+    async def join(self) -> None:
+        await self.await_or_terminate_event.wait()
+
+    async def execute(self, input: Message, *, executor: ThreadPoolExecutor) -> None:
+        with trace.get_tracer(__name__).start_as_current_span("execute"):
+            run_logger = logging.LoggerAdapter(logger, {"run_id": self.run.run_id})
+
+            await self.emit(CreatedEvent(run=self.run))
+            try:
+                self.run.session_id = await self.agent.session(self.run.session_id)
+                run_logger.info("Session loaded")
+
+                generator = self.agent.execute(input=input, session_id=self.run.session_id, executor=executor)
+                run_logger.info("Run started")
+
+                self.run.status = RunStatus.IN_PROGRESS
+                await self.emit(InProgressEvent(run=self.run))
+
+                await_resume = None
+                while True:
+                    next = await generator.asend(await_resume)
+                    if isinstance(next, Message):
+                        self.composed_message += next
+                        await self.emit(MessageEvent(message=next))
+                    elif isinstance(next, Await):
+                        self.run.await_ = next
+                        self.run.status = RunStatus.AWAITING
+                        await self.emit(
+                            AwaitEvent.model_validate(
+                                {
+                                    "run_id": self.run.run_id,
+                                    "type": "await",
+                                    "await": next,
+                                }
+                            )
+                        )
+                        run_logger.info("Run awaited")
+                        await_resume = await self.await_()
+                        self.run.status = RunStatus.IN_PROGRESS
+                        await self.emit(InProgressEvent(run=self.run))
+                        run_logger.info("Run resumed")
+                    else:
+                        try:
+                            generic = AnyModel.model_validate(next)
+                            await self.emit(GenericEvent(generic=generic))
+                        except ValidationError:
+                            raise TypeError("Invalid yield")
+            except StopAsyncIteration:
+                self.run.output = self.composed_message
+                self.run.status = RunStatus.COMPLETED
+                await self.emit(CompletedEvent(run=self.run))
+                run_logger.info("Run completed")
+            except asyncio.CancelledError:
+                self.run.status = RunStatus.CANCELLED
+                await self.emit(CancelledEvent(run=self.run))
+                run_logger.info("Run cancelled")
+            except Exception as e:
+                self.run.error = Error(code=ErrorCode.SERVER_ERROR, message=str(e))
+                self.run.status = RunStatus.FAILED
+                await self.emit(FailedEvent(run=self.run))
+                run_logger.exception("Run failed")
+            finally:
+                self.await_or_terminate_event.set()
+                await self.stream_queue.put(None)

acp_sdk/server/context.py

@@ -0,0 +1,33 @@
+from concurrent.futures import ThreadPoolExecutor
+
+import janus
+
+from acp_sdk.models import SessionId
+from acp_sdk.server.types import RunYield, RunYieldResume
+
+
+class Context:
+    def __init__(
+        self,
+        *,
+        session_id: SessionId | None = None,
+        executor: ThreadPoolExecutor,
+        yield_queue: janus.Queue[RunYield],
+        yield_resume_queue: janus.Queue[RunYieldResume],
+    ) -> None:
+        self.session_id = session_id
+        self.executor = executor
+        self._yield_queue = yield_queue
+        self._yield_resume_queue = yield_resume_queue
+
+    def yield_sync(self, value: RunYield) -> RunYieldResume:
+        self._yield_queue.sync_q.put(value)
+        return self._yield_resume_queue.sync_q.get()
+
+    async def yield_async(self, value: RunYield) -> RunYieldResume:
+        await self._yield_queue.async_q.put(value)
+        return await self._yield_resume_queue.async_q.get()
+
+    def shutdown(self) -> None:
+        self._yield_queue.shutdown()
+        self._yield_resume_queue.shutdown()

acp_sdk/server/errors.py

@@ -0,0 +1,54 @@
+from fastapi import Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from acp_sdk.models import Error, ErrorCode
+from acp_sdk.models.errors import ACPError
+from acp_sdk.server.logging import logger
+
+
+def error_code_to_status_code(error_code: ErrorCode) -> int:
+    match error_code:
+        case ErrorCode.NOT_FOUND:
+            return status.HTTP_404_NOT_FOUND
+        case ErrorCode.INVALID_INPUT:
+            return status.HTTP_422_UNPROCESSABLE_ENTITY
+        case _:
+            return status.HTTP_500_INTERNAL_SERVER_ERROR
+
+
+def status_code_to_error_code(status_code: int) -> ErrorCode:
+    match status_code:
+        case status.HTTP_400_BAD_REQUEST:
+            return ErrorCode.INVALID_INPUT
+        case status.HTTP_404_NOT_FOUND:
+            return ErrorCode.NOT_FOUND
+        case status.HTTP_422_UNPROCESSABLE_ENTITY:
+            return ErrorCode.INVALID_INPUT
+        case _:
+            return ErrorCode.SERVER_ERROR
+
+
+async def acp_error_handler(request: Request, exc: ACPError, *, status_code: int | None = None) -> JSONResponse:
+    error = exc.error
+    return JSONResponse(status_code=status_code or error_code_to_status_code(error.code), content=error.model_dump())
+
+
+async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
+    return await acp_error_handler(
+        request,
+        ACPError(Error(code=status_code_to_error_code(exc.status_code), message=exc.detail)),
+        status_code=exc.status_code,
+    )
+
+
+async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
+    return await acp_error_handler(request, ACPError(Error(code=ErrorCode.INVALID_INPUT, message=str(exc))))
+
+
+async def catch_all_exception_handler(request: Request, exc: Exception) -> JSONResponse:
+    logger.error(exc)
+    return await acp_error_handler(
+        request, ACPError(Error(code=ErrorCode.SERVER_ERROR, message="An unexpected error occurred"))
+    )

acp_sdk/server/logging.py

@@ -0,0 +1,16 @@
+import logging
+
+from uvicorn.logging import DefaultFormatter
+
+logger = logging.getLogger("acp")
+
+
+def configure_logger() -> None:
+    """Utility that configures the root logger"""
+    root_logger = logging.getLogger()
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(DefaultFormatter(fmt="%(levelprefix)s %(message)s"))
+
+    root_logger.addHandler(handler)
+    root_logger.setLevel(logging.INFO)

acp_sdk/server/server.py

@@ -0,0 +1,120 @@
+import inspect
+from collections.abc import AsyncGenerator, Coroutine, Generator
+from typing import Any, Callable
+
+from acp_sdk.models import Message
+from acp_sdk.server.agent import Agent
+from acp_sdk.server.app import create_app
+from acp_sdk.server.context import Context
+from acp_sdk.server.logging import configure_logger as configure_logger_func
+from acp_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
+from acp_sdk.server.types import RunYield, RunYieldResume
+
+
+class Server:
+    def __init__(self) -> None:
+        self.agents: list[Agent] = []
+
+    def agent(self, name: str | None = None, description: str | None = None) -> Callable:
+        """Decorator to register an agent."""
+
+        def decorator(fn: Callable) -> Callable:
+            # check agent's function signature
+            signature = inspect.signature(fn)
+            parameters = list(signature.parameters.values())
+
+            # validate agent's function
+            if inspect.isasyncgenfunction(fn):
+                if len(parameters) != 2:
+                    raise TypeError(
+                        "The agent generator function must have one 'input' argument and one 'context' argument"
+                    )
+            else:
+                if len(parameters) != 2:
+                    raise TypeError("The agent function must have one 'input' argument and one 'context' argument")
+
+            agent: Agent
+            if inspect.isasyncgenfunction(fn):
+
+                class DecoratedAgent(Agent):
+                    @property
+                    def name(self) -> str:
+                        return name or fn.__name__
+
+                    @property
+                    def description(self) -> str:
+                        return description or fn.__doc__ or ""
+
+                    async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+                        try:
+                            gen: AsyncGenerator[RunYield, RunYieldResume] = fn(input, context)
+                            value = None
+                            while True:
+                                value = yield await gen.asend(value)
+                        except StopAsyncIteration:
+                            pass
+
+                agent = DecoratedAgent()
+            elif inspect.iscoroutinefunction(fn):
+
+                class DecoratedAgent(Agent):
+                    @property
+                    def name(self) -> str:
+                        return name or fn.__name__
+
+                    @property
+                    def description(self) -> str:
+                        return description or fn.__doc__ or ""
+
+                    async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
+                        return await fn(input, context)
+
+                agent = DecoratedAgent()
+            elif inspect.isgeneratorfunction(fn):
+
+                class DecoratedAgent(Agent):
+                    @property
+                    def name(self) -> str:
+                        return name or fn.__name__
+
+                    @property
+                    def description(self) -> str:
+                        return description or fn.__doc__ or ""
+
+                    def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
+                        yield from fn(input, context)
+
+                agent = DecoratedAgent()
+            else:
+
+                class DecoratedAgent(Agent):
+                    @property
+                    def name(self) -> str:
+                        return name or fn.__name__
+
+                    @property
+                    def description(self) -> str:
+                        return description or fn.__doc__ or ""
+
+                    def run(self, input: Message, context: Context) -> RunYield:
+                        return fn(input, context)
+
+                agent = DecoratedAgent()
+
+            self.register(agent)
+            return fn
+
+        return decorator
+
+    def register(self, *agents: Agent) -> None:
+        self.agents.extend(agents)
+
+    def run(self, configure_logger: bool = True, configure_telemetry: bool = False, **kwargs: dict[str, Any]) -> None:
+        import uvicorn
+
+        if configure_logger:
+            configure_logger_func()
+        if configure_telemetry:
+            configure_telemetry_func()
+
+        uvicorn.run(create_app(*self.agents), **kwargs)

acp_sdk/server/telemetry.py

@@ -0,0 +1,52 @@
+import logging
+from importlib.metadata import version
+
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    SERVICE_NAMESPACE,
+    SERVICE_VERSION,
+    Resource,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+root_logger = logging.getLogger()
+
+
+def configure_telemetry() -> None:
+    """Utility that configures opentelemetry with OTLP exporter"""
+
+    resource = Resource(
+        attributes={
+            SERVICE_NAME: "acp-server",
+            SERVICE_NAMESPACE: "acp",
+            SERVICE_VERSION: version("acp-sdk"),
+        }
+    )
+
+    # Traces
+    provider = TracerProvider(resource=resource)
+    processor = BatchSpanProcessor(OTLPSpanExporter())
+    provider.add_span_processor(processor)
+    trace.set_tracer_provider(provider)
+
+    # Metrics
+    meter_provider = MeterProvider(
+        resource=resource,
+        metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())],
+    )
+    metrics.set_meter_provider(meter_provider)
+
+    # Logs
+    logger_provider = LoggerProvider(resource=resource)
+    processor = BatchLogRecordProcessor(OTLPLogExporter())
+    logger_provider.add_log_record_processor(processor)
+    root_logger.addHandler(LoggingHandler(logger_provider=logger_provider))

acp_sdk/server/types.py

@@ -0,0 +1,6 @@
+from typing import Any
+
+from acp_sdk.models import Await, AwaitResume, Message
+
+RunYield = Message | Await | dict[str | Any]
+RunYieldResume = AwaitResume | None

acp_sdk/server/utils.py

@@ -0,0 +1,14 @@
+from collections.abc import AsyncGenerator
+
+from pydantic import BaseModel
+
+from acp_sdk.server.bundle import RunBundle
+
+
+def encode_sse(model: BaseModel) -> str:
+    return f"data: {model.model_dump_json()}\n\n"
+
+
+async def stream_sse(bundle: RunBundle) -> AsyncGenerator[str]:
+    async for event in bundle.stream():
+        yield encode_sse(event)

acp_sdk-0.1.0rc5.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: acp-sdk
+Version: 0.1.0rc5
+Summary: Agent Communication Protocol SDK
+Requires-Python: <4.0,>=3.11
+Requires-Dist: opentelemetry-api>=1.31.1
+Requires-Dist: pydantic>=2.11.1
+Provides-Extra: client
+Requires-Dist: httpx-sse>=0.4.0; extra == 'client'
+Requires-Dist: httpx>=0.28.1; extra == 'client'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.52b1; extra == 'client'
+Provides-Extra: server
+Requires-Dist: fastapi[standard]>=0.115.8; extra == 'server'
+Requires-Dist: janus>=2.0.0; extra == 'server'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31.1; extra == 'server'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.52b1; extra == 'server'
+Requires-Dist: opentelemetry-sdk>=1.31.1; extra == 'server'
+Description-Content-Type: text/markdown
+
+# Agent Communication Protocol SDK for Python
+
+Agent Communication Protocol SDK for Python provides allows developers to serve and consume agents over the Agent Communication Protocol.
+
+## Prerequisites
+
+✅ Python >= 3.11
+
+## Installation
+
+Install to use client:
+
+```shell
+pip install acp-sdk[client]
+```
+
+Install to use server:
+
+```shell
+pip install acp-sdk[server]
+```
+
+## Overview
+
+### Client
+
+The `client` submodule exposes [httpx]() based client with simple methods for communication over ACP.
+
+```python
+async with Client(base_url="http://localhost:8000") as client:
+    run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
+    print(run.output)
+```
+
+### Server
+
+The `server` submodule exposes [fastapi] application factory that makes it easy to expose any agent over ACP.
+
+```python
+class EchoAgent(Agent):
+    @property
+    def name(self) -> str:
+        return "echo"
+
+    @property
+    def description(self) -> str:
+        return "Echoes everything"
+
+    async def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
+        for part in input:
+            await asyncio.sleep(0.5)
+            yield {"thought": "I should echo everyting"}
+            yield Message(part)
+
+
+serve(EchoAgent())
+```
+
+➡️ Explore more in our [examples library](/python/examples).

acp_sdk-0.1.0rc5.dist-info/RECORD

@@ -0,0 +1,22 @@
+acp_sdk/__init__.py,sha256=XlcAbmvJfvJK5tmOFdxXP19aDwxxdG_jygsTCvXtjTk,43
+acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
+acp_sdk/client/client.py,sha256=W6iXxH65UUODnvt3tnvgdqT_pP1meZUF2HwJpWCM0BM,5029
+acp_sdk/models/__init__.py,sha256=numSDBDT1QHx7n_Y3Deb5VOvKWcUBxbOEaMwQBSRHxc,151
+acp_sdk/models/errors.py,sha256=rEyaMVvQuBi7fwWe_d0PGGySYsD3FZTluQ-SkC0yhAs,444
+acp_sdk/models/models.py,sha256=ACZPQp-wm43tdlx83hrX7QmdtBRWVXvU5bsotUOidHM,3908
+acp_sdk/models/schemas.py,sha256=a0T29vfy93uVIce3ikbd3GSTdKBokMmfXWNVRJD3Eb8,662
+acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
+acp_sdk/server/agent.py,sha256=SZfJK634d4s8fRh0u1Tc56l58XCRHAh3hq5Hcabh6tI,3442
+acp_sdk/server/app.py,sha256=7alacNo9y_f0-BjZI0dm_rzSweW-n5YiuY0hrVtEIR8,5420
+acp_sdk/server/bundle.py,sha256=ZVkIOwWfYgi-VyGYSMKr9WrG_WzYbej-LD-YPUWQdeg,4982
+acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
+acp_sdk/server/errors.py,sha256=fWlgVsQ5hs_AXwzc-wvy6QgoDWEMRUBlSrfJfhHHMyE,2085
+acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
+acp_sdk/server/server.py,sha256=xSS_TjxQ5xi_X9RJDNjFsU0JEytLlCCSqbp6sBVXXhY,4442
+acp_sdk/server/telemetry.py,sha256=EwmtUrWMYid7XHiX76V1J6CigJPa2NrzEPOX0fBoY3o,1838
+acp_sdk/server/types.py,sha256=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
+acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
+acp_sdk-0.1.0rc5.dist-info/METADATA,sha256=laguwvWACy9Yslwj_Wh2p25rfEciRu217HEGGXTIOKg,2147
+acp_sdk-0.1.0rc5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.1.0rc5.dist-info/RECORD,,

acp/__init__.py

@@ -1,138 +0,0 @@
-from .client.session import ClientSession
-from .client.stdio import StdioServerParameters, stdio_client
-from .server.session import ServerSession
-from .server.stdio import stdio_server
-from .shared.exceptions import McpError
-from .types import (
-    Agent,
-    AgentTemplate,
-    CallToolRequest,
-    ClientCapabilities,
-    ClientNotification,
-    ClientRequest,
-    ClientResult,
-    CompleteRequest,
-    CreateAgentRequest,
-    CreateAgentResult,
-    CreateMessageRequest,
-    CreateMessageResult,
-    DestroyAgentRequest,
-    DestroyAgentResult,
-    ErrorData,
-    GetPromptRequest,
-    GetPromptResult,
-    Implementation,
-    IncludeContext,
-    InitializedNotification,
-    InitializeRequest,
-    InitializeResult,
-    JSONRPCError,
-    JSONRPCRequest,
-    JSONRPCResponse,
-    ListAgentsRequest,
-    ListAgentsResult,
-    ListAgentTemplatesRequest,
-    ListAgentTemplatesResult,
-    ListPromptsRequest,
-    ListPromptsResult,
-    ListResourcesRequest,
-    ListResourcesResult,
-    ListToolsResult,
-    LoggingLevel,
-    LoggingMessageNotification,
-    Notification,
-    PingRequest,
-    ProgressNotification,
-    PromptsCapability,
-    ReadResourceRequest,
-    ReadResourceResult,
-    Resource,
-    ResourcesCapability,
-    ResourceUpdatedNotification,
-    RootsCapability,
-    RunAgentRequest,
-    RunAgentResult,
-    SamplingMessage,
-    ServerCapabilities,
-    ServerNotification,
-    ServerRequest,
-    ServerResult,
-    SetLevelRequest,
-    StopReason,
-    SubscribeRequest,
-    Tool,
-    ToolsCapability,
-    UnsubscribeRequest,
-)
-from .types import (
-    Role as SamplingRole,
-)
-
-__all__ = [
-    "CallToolRequest",
-    "ClientCapabilities",
-    "ClientNotification",
-    "ClientRequest",
-    "ClientResult",
-    "ClientSession",
-    "CreateMessageRequest",
-    "CreateMessageResult",
-    "ErrorData",
-    "GetPromptRequest",
-    "GetPromptResult",
-    "Implementation",
-    "IncludeContext",
-    "InitializeRequest",
-    "InitializeResult",
-    "InitializedNotification",
-    "JSONRPCError",
-    "JSONRPCRequest",
-    "ListPromptsRequest",
-    "ListPromptsResult",
-    "ListResourcesRequest",
-    "ListResourcesResult",
-    "ListToolsResult",
-    "LoggingLevel",
-    "LoggingMessageNotification",
-    "McpError",
-    "Notification",
-    "PingRequest",
-    "ProgressNotification",
-    "PromptsCapability",
-    "ReadResourceRequest",
-    "ReadResourceResult",
-    "ResourcesCapability",
-    "ResourceUpdatedNotification",
-    "Resource",
-    "RootsCapability",
-    "SamplingMessage",
-    "SamplingRole",
-    "ServerCapabilities",
-    "ServerNotification",
-    "ServerRequest",
-    "ServerResult",
-    "ServerSession",
-    "SetLevelRequest",
-    "StdioServerParameters",
-    "StopReason",
-    "SubscribeRequest",
-    "Tool",
-    "ToolsCapability",
-    "UnsubscribeRequest",
-    "stdio_client",
-    "stdio_server",
-    "CompleteRequest",
-    "JSONRPCResponse",
-    "AgentTemplate",
-    "ListAgentTemplatesRequest",
-    "ListAgentTemplatesResult",
-    "Agent",
-    "ListAgentsRequest",
-    "ListAgentsResult",
-    "CreateAgentRequest",
-    "CreateAgentResult",
-    "DestroyAgentRequest",
-    "DestroyAgentResult",
-    "RunAgentRequest",
-    "RunAgentResult",
-]

acp/cli/__init__.py

@@ -1,6 +0,0 @@
-"""FastMCP CLI package."""
-
-from .cli import app
-
-if __name__ == "__main__":
-    app()