acp-sdk 1.0.0rc1__tar.gz → 1.0.0rc3__tar.gz

acp_sdk-1.0.0rc3/.python-version

@@ -0,0 +1 @@
+3.11

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 1.0.0rc1
+Version: 1.0.0rc3
 Summary: Agent Communication Protocol SDK
-Requires-Python: <4.0,>=3.13
+Requires-Python: <4.0,>=3.11
 Requires-Dist: opentelemetry-api>=1.31.1
 Requires-Dist: pydantic>=2.11.1
 Provides-Extra: client
@@ -30,16 +30,14 @@ Install using pip:
 pip install acp-sdk
 ```
 
-## Example
+## Examples
 
 The SDK can be used to implement both clients and servers.
 
 ### Server
 
-To run an example server use [FastAPI CLI](https://fastapi.tiangolo.com/fastapi-cli/) or other [deployment strategies](https://fastapi.tiangolo.com/deployment/):
-
 ```shell
-fastapi dev examples/servers/echo.py
+python examples/servers/echo.py
 ```
 
 ### Client

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/README.md

@@ -12,16 +12,14 @@ Install using pip:
 pip install acp-sdk
 ```
 
-## Example
+## Examples
 
 The SDK can be used to implement both clients and servers.
 
 ### Server
 
-To run an example server use [FastAPI CLI](https://fastapi.tiangolo.com/fastapi-cli/) or other [deployment strategies](https://fastapi.tiangolo.com/deployment/):
-
 ```shell
-fastapi dev examples/servers/echo.py
+python examples/servers/echo.py
 ```
 
 ### Client

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/examples/clients/advanced.py

@@ -1,10 +1,11 @@
 import asyncio
+
+import httpx
 from acp_sdk.client.client import Client
 from acp_sdk.models import Message, TextMessagePart
-import httpx
 
 
-async def example():
+async def example() -> None:
     async with Client(
         client=httpx.AsyncClient(
             base_url="http://localhost:8000",
@@ -12,9 +13,7 @@ async def example():
             # Additional client configuration
         )
     ) as client:
-        run = await client.run_sync(
-            agent="echo", input=Message(TextMessagePart(content="Howdy!"))
-        )
+        run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
         print(run.output)
 
 

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/examples/clients/simple.py

@@ -1,18 +1,15 @@
 import asyncio
 
+from acp_sdk.client import Client
 from acp_sdk.models import (
     Message,
     TextMessagePart,
 )
 
-from acp_sdk.client import Client
-
 
-async def example():
+async def example() -> None:
     async with Client(base_url="http://localhost:8000") as client:
-        run = await client.run_sync(
-            agent="echo", input=Message(TextMessagePart(content="Howdy!"))
-        )
+        run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
         print(run.output)
 
 

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/examples/clients/stream.py

@@ -4,11 +4,9 @@ from acp_sdk.client import Client
 from acp_sdk.models import Message, TextMessagePart
 
 
-async def example():
+async def example() -> None:
     async with Client(base_url="http://localhost:8000") as client:
-        async for event in client.run_stream(
-            agent="echo", input=Message(TextMessagePart(content="Howdy!"))
-        ):
+        async for event in client.run_stream(agent="echo", input=Message(TextMessagePart(content="Howdy!"))):
             print(event)
 
 

acp_sdk-1.0.0rc3/examples/servers/awaiting.py

@@ -0,0 +1,28 @@
+from collections.abc import AsyncGenerator
+
+from acp_sdk.models import (
+    Await,
+    AwaitResume,
+    Message,
+    TextMessagePart,
+)
+from acp_sdk.server import Agent, serve
+from acp_sdk.server.context import Context
+
+
+class AwaitingAgent(Agent):
+    @property
+    def name(self) -> str:
+        return "awaiting"
+
+    @property
+    def description(self) -> str:
+        return "Greets and awaits for more data"
+
+    async def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
+        yield Message(TextMessagePart(content="Hello!"))
+        data = yield Await()
+        yield Message(TextMessagePart(content=f"Thanks for {data}"))
+
+
+serve(AwaitingAgent())

acp_sdk-1.0.0rc3/examples/servers/echo.py

@@ -0,0 +1,29 @@
+import asyncio
+from collections.abc import AsyncGenerator
+
+from acp_sdk.models import (
+    Await,
+    AwaitResume,
+    Message,
+)
+from acp_sdk.server import Agent, serve
+from acp_sdk.server.context import Context
+
+
+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())

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "acp-sdk"
-version = "1.0.0rc1"
+version = "1.0.0rc3"
 description = "Agent Communication Protocol SDK"
 readme = "README.md"
 authors = []
-requires-python = ">=3.13, <4.0"
+requires-python = ">=3.11, <4.0"
 dependencies = ["opentelemetry-api>=1.31.1", "pydantic>=2.11.1"]
 
 [project.optional-dependencies]
@@ -20,6 +20,17 @@ server = [
     "opentelemetry-sdk>=1.31.1",
 ]
 
+[tool.uv]
+dev-dependencies = [
+    "httpx>=0.28.1",
+    "httpx-sse>=0.4.0",
+    "opentelemetry-instrumentation-httpx>=0.52b1",
+    "fastapi[standard]>=0.115.8",
+    "opentelemetry-exporter-otlp-proto-http>=1.31.1",
+    "opentelemetry-instrumentation-fastapi>=0.52b1",
+    "opentelemetry-sdk>=1.31.1",
+]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

acp_sdk-1.0.0rc3/src/acp_sdk/__init__.py

@@ -0,0 +1 @@
+from acp_sdk.models import *  # noqa: F403

acp_sdk-1.0.0rc3/src/acp_sdk/client/__init__.py

@@ -0,0 +1 @@
+from acp_sdk.client.client import Client as Client

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/client/client.py

@@ -1,21 +1,24 @@
+from collections.abc import AsyncIterator
 from types import TracebackType
-from typing import AsyncIterator
+from typing import Self
 
 import httpx
 from httpx_sse import EventSource, aconnect_sse
-
 from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+from pydantic import TypeAdapter
 
 from acp_sdk.models import (
+    ACPError,
     Agent,
     AgentName,
     AgentReadResponse,
     AgentsListResponse,
     AwaitResume,
+    Error,
     Message,
+    Run,
     RunCancelResponse,
     RunCreateRequest,
-    Run,
     RunCreateResponse,
     RunEvent,
     RunId,
@@ -23,23 +26,20 @@ from acp_sdk.models import (
     RunResumeRequest,
     RunResumeResponse,
 )
-from pydantic import TypeAdapter
 
 
 class Client:
-    def __init__(
-        self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None
-    ):
+    def __init__(self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None) -> None:
         self.base_url = base_url
 
         self._client = self._init_client(client)
 
-    def _init_client(self, client: httpx.AsyncClient | None = None):
+    def _init_client(self, client: httpx.AsyncClient | None = None) -> httpx.AsyncClient:
         client = client or httpx.AsyncClient(base_url=self.base_url)
         HTTPXClientInstrumentor.instrument_client(client)
         return client
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Self:
         await self._client.__aenter__()
         return self
 
@@ -48,56 +48,54 @@ class Client:
         exc_type: type[BaseException] | None = None,
         exc_value: BaseException | None = None,
         traceback: TracebackType | None = None,
-    ):
+    ) -> None:
         await self._client.__aexit__(exc_type, exc_value, traceback)
 
     async def agents(self) -> AsyncIterator[Agent]:
         response = await self._client.get("/agents")
+        self._raise_error(response)
         for agent in AgentsListResponse.model_validate(response.json()).agents:
             yield agent
 
     async def agent(self, *, name: AgentName) -> Agent:
         response = await self._client.get(f"/agents/{name}")
+        self._raise_error(response)
         return AgentReadResponse.model_validate(response.json())
 
     async def run_sync(self, *, agent: AgentName, input: Message) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.SYNC
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.SYNC).model_dump(),
         )
+        self._raise_error(response)
         return RunCreateResponse.model_validate(response.json())
 
     async def run_async(self, *, agent: AgentName, input: Message) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.ASYNC
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.ASYNC).model_dump(),
         )
+        self._raise_error(response)
         return RunCreateResponse.model_validate(response.json())
 
-    async def run_stream(
-        self, *, agent: AgentName, input: Message
-    ) -> AsyncIterator[RunEvent]:
+    async def run_stream(self, *, agent: AgentName, input: Message) -> AsyncIterator[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.STREAM
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.STREAM).model_dump(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
                 yield event
 
     async def run_status(self, *, run_id: RunId) -> Run:
         response = await self._client.get(f"/runs/{run_id}")
+        self._raise_error(response)
         return Run.model_validate(response.json())
 
     async def run_cancel(self, *, run_id: RunId) -> Run:
         response = await self._client.post(f"/runs/{run_id}/cancel")
+        self._raise_error(response)
         return RunCancelResponse.model_validate(response.json())
 
     async def run_resume_sync(self, *, run_id: RunId, await_: AwaitResume) -> Run:
@@ -105,6 +103,7 @@ class Client:
             f"/runs/{run_id}",
             json=RunResumeRequest(await_=await_, mode=RunMode.SYNC).model_dump(),
         )
+        self._raise_error(response)
         return RunResumeResponse.model_validate(response.json())
 
     async def run_resume_async(self, *, run_id: RunId, await_: AwaitResume) -> Run:
@@ -112,11 +111,10 @@ class Client:
             f"/runs/{run_id}",
             json=RunResumeRequest(await_=await_, mode=RunMode.ASYNC).model_dump(),
         )
+        self._raise_error(response)
         return RunResumeResponse.model_validate(response.json())
 
-    async def run_resume_stream(
-        self, *, run_id: RunId, await_: AwaitResume
-    ) -> AsyncIterator[RunEvent]:
+    async def run_resume_stream(self, *, run_id: RunId, await_: AwaitResume) -> AsyncIterator[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",
@@ -133,3 +131,9 @@ class Client:
         async for event in event_source.aiter_sse():
             event = TypeAdapter(RunEvent).validate_json(event.data)
             yield event
+
+    def _raise_error(self, response: httpx.Response) -> None:
+        try:
+            response.raise_for_status()
+        except httpx.HTTPError:
+            raise ACPError(Error.model_validate(response.json()))

acp_sdk-1.0.0rc3/src/acp_sdk/models/__init__.py

@@ -0,0 +1,2 @@
+from acp_sdk.models.errors import *  # noqa: F403
+from acp_sdk.models.models import *  # noqa: F403

acp_sdk-1.0.0rc3/src/acp_sdk/models/errors.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class ErrorCode(str, Enum):
+    SERVER_ERROR = "server_error"
+    INVALID_INPUT = "invalid_input"
+    NOT_FOUND = "not_found"
+
+
+class Error(BaseModel):
+    code: ErrorCode
+    message: str
+
+
+class ACPError(Exception):
+    def __init__(self, error: Error) -> None:
+        super().__init__()
+        self.error = error
+
+    def __str__(self) -> str:
+        return str(self.error.message)

{acp_sdk-1.0.0rc1/src/acp_sdk → acp_sdk-1.0.0rc3/src/acp_sdk/models}/models.py

@@ -1,13 +1,15 @@
-from enum import Enum
-from typing import Annotated, Literal, Union
 import uuid
+from collections.abc import Iterator
+from enum import Enum
+from typing import Any, Literal, Union
 
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field, RootModel
 
+from acp_sdk.models.errors import Error
+
 
-class ACPError(BaseModel):
-    code: str
-    message: str
+class Metadata(BaseModel):
+    model_config = ConfigDict(extra="allow")
 
 
 class AnyModel(BaseModel):
@@ -40,24 +42,19 @@ MessagePart = Union[TextMessagePart, ImageMessagePart, ArtifactMessagePart]
 class Message(RootModel):
     root: list[MessagePart]
 
-    def __init__(self, *items: MessagePart):
+    def __init__(self, *items: MessagePart) -> None:
         super().__init__(root=list(items))
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[MessagePart]:
         return iter(self.root)
 
-    def __getitem__(self, item):
-        return self.root[item]
-
     def __add__(self, other: "Message") -> "Message":
         if not isinstance(other, Message):
             raise TypeError(f"Cannot concatenate Message with {type(other).__name__}")
         return Message(*(self.root + other.root))
 
-    def __str__(self):
-        return "".join(
-            str(part) for part in self.root if isinstance(part, TextMessagePart)
-        )
+    def __str__(self) -> str:
+        return "".join(str(part) for part in self.root if isinstance(part, TextMessagePart))
 
 
 AgentName = str
@@ -101,14 +98,14 @@ class Run(BaseModel):
     status: RunStatus = RunStatus.CREATED
     await_: Await | None = Field(None, alias="await")
     output: Message | None = None
-    error: ACPError | None = None
+    error: Error | None = None
 
     model_config = ConfigDict(populate_by_name=True)
 
     def model_dump_json(
         self,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> str:
         return super().model_dump_json(
             by_alias=True,
             **kwargs,
@@ -128,8 +125,8 @@ class AwaitEvent(BaseModel):
 
     def model_dump_json(
         self,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> str:
         return super().model_dump_json(
             by_alias=True,
             **kwargs,
@@ -209,6 +206,7 @@ class RunCancelResponse(Run):
 class Agent(BaseModel):
     name: str
     description: str | None = None
+    metadata: Metadata = Metadata()
 
 
 class AgentsListResponse(BaseModel):

acp_sdk-1.0.0rc3/src/acp_sdk/server/__init__.py

@@ -0,0 +1,3 @@
+from acp_sdk.server.agent import Agent as Agent
+from acp_sdk.server.server import create_app as create_app
+from acp_sdk.server.server import serve as serve

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/server/agent.py

@@ -1,13 +1,14 @@
 import abc
-from typing import AsyncGenerator
+from collections.abc import AsyncGenerator
 
 from acp_sdk.models import (
     AgentName,
-    Message,
     Await,
     AwaitResume,
+    Message,
     SessionId,
 )
+from acp_sdk.models.models import Metadata
 from acp_sdk.server.context import Context
 
 
@@ -20,10 +21,12 @@ class Agent(abc.ABC):
     def description(self) -> str:
         return ""
 
+    @property
+    def metadata(self) -> Metadata:
+        return Metadata()
+
     @abc.abstractmethod
-    def run(
-        self, input: Message, *, context: Context
-    ) -> AsyncGenerator[Message | Await, AwaitResume]:
+    def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
         pass
 
     async def session(self, session_id: SessionId | None) -> SessionId | None:

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/server/bundle.py

@@ -1,35 +1,36 @@
 import asyncio
 import logging
+from collections.abc import AsyncGenerator
 
 from opentelemetry import trace
 from pydantic import ValidationError
 
-from acp_sdk.server.agent import Agent
 from acp_sdk.models import (
-    ACPError,
     AnyModel,
     Await,
     AwaitEvent,
+    AwaitResume,
     CancelledEvent,
     CompletedEvent,
     CreatedEvent,
+    Error,
     FailedEvent,
     GenericEvent,
     InProgressEvent,
     Message,
     MessageEvent,
     Run,
-    AwaitResume,
     RunEvent,
     RunStatus,
 )
+from acp_sdk.models.errors import ErrorCode
+from acp_sdk.server.agent import Agent
 from acp_sdk.server.context import Context
-
-logger = logging.getLogger("uvicorn.error")
+from acp_sdk.server.logging import logger
 
 
 class RunBundle:
-    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None):
+    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None) -> None:
         self.agent = agent
         self.run = run
         self.task = task
@@ -40,20 +41,19 @@ class RunBundle:
         self.await_queue: asyncio.Queue[AwaitResume] = asyncio.Queue(maxsize=1)
         self.await_or_terminate_event = asyncio.Event()
 
-    async def stream(self):
-        try:
-            while True:
-                event = await self.stream_queue.get()
-                yield event
-                self.stream_queue.task_done()
-        except asyncio.QueueShutDown:
-            pass
+    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):
+    async def emit(self, event: RunEvent) -> None:
         await self.stream_queue.put(event)
 
     async def await_(self) -> AwaitResume:
-        self.stream_queue.shutdown()
+        await self.stream_queue.put(None)
         self.await_queue.empty()
         self.await_or_terminate_event.set()
         self.await_or_terminate_event.clear()
@@ -61,14 +61,14 @@ class RunBundle:
         self.await_queue.task_done()
         return resume
 
-    async def resume(self, resume: AwaitResume):
+    async def resume(self, resume: AwaitResume) -> None:
         self.stream_queue = asyncio.Queue()
         await self.await_queue.put(resume)
 
-    async def join(self):
+    async def join(self) -> None:
         await self.await_or_terminate_event.wait()
 
-    async def execute(self, input: Message):
+    async def execute(self, input: Message) -> None:
         with trace.get_tracer(__name__).start_as_current_span("execute"):
             run_logger = logging.LoggerAdapter(logger, {"run_id": self.run.run_id})
 
@@ -77,9 +77,7 @@ class RunBundle:
                 self.run.session_id = await self.agent.session(self.run.session_id)
                 run_logger.info("Session loaded")
 
-                generator = self.agent.run(
-                    input=input, context=Context(session_id=self.run.session_id)
-                )
+                generator = self.agent.run(input=input, context=Context(session_id=self.run.session_id))
                 run_logger.info("Run started")
 
                 self.run.status = RunStatus.IN_PROGRESS
@@ -124,10 +122,10 @@ class RunBundle:
                 await self.emit(CancelledEvent(run=self.run))
                 run_logger.info("Run cancelled")
             except Exception as e:
-                self.run.error = ACPError(code="unspecified", message=str(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()
-                self.stream_queue.shutdown()
+                await self.stream_queue.put(None)

{acp_sdk-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/server/context.py

@@ -2,5 +2,5 @@ from acp_sdk.models import SessionId
 
 
 class Context:
-    def __init__(self, *, session_id: SessionId | None = None):
+    def __init__(self, *, session_id: SessionId | None = None) -> None:
         self.session_id = session_id

acp_sdk-1.0.0rc3/src/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-1.0.0rc3/src/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-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/server/server.py

@@ -1,17 +1,17 @@
 import asyncio
-
-from acp_sdk.server.telemetry import configure_telemetry
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from typing import Any
 
 from fastapi import FastAPI, HTTPException, status
 from fastapi.responses import JSONResponse, StreamingResponse
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 
-from acp_sdk.server.agent import Agent
 from acp_sdk.models import (
-    AgentName,
     Agent as AgentModel,
-    AgentsListResponse,
+)
+from acp_sdk.models import (
+    AgentName,
     AgentReadResponse,
+    AgentsListResponse,
     Run,
     RunCancelResponse,
     RunCreateRequest,
@@ -23,47 +23,63 @@ from acp_sdk.models import (
     RunResumeResponse,
     RunStatus,
 )
+from acp_sdk.models.errors import ACPError
+from acp_sdk.server.agent import Agent
 from acp_sdk.server.bundle import RunBundle
+from acp_sdk.server.errors import (
+    RequestValidationError,
+    StarletteHTTPException,
+    acp_error_handler,
+    catch_all_exception_handler,
+    http_exception_handler,
+    validation_exception_handler,
+)
+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.utils import stream_sse
 
 
 def create_app(*agents: Agent) -> FastAPI:
     app = FastAPI(title="acp-agents")
 
-    configure_telemetry()
     FastAPIInstrumentor.instrument_app(app)
 
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
-    runs: dict[RunId, RunBundle] = dict()
+    runs: dict[RunId, RunBundle] = {}
 
-    def find_run_bundle(run_id: RunId):
-        bundle = runs.get(run_id, None)
+    app.exception_handler(ACPError)(acp_error_handler)
+    app.exception_handler(StarletteHTTPException)(http_exception_handler)
+    app.exception_handler(RequestValidationError)(validation_exception_handler)
+    app.exception_handler(Exception)(catch_all_exception_handler)
+
+    def find_run_bundle(run_id: RunId) -> RunBundle:
+        bundle = runs.get(run_id)
         if not bundle:
             raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
         return bundle
 
-    def find_agent(agent_name: AgentName):
+    def find_agent(agent_name: AgentName) -> Agent:
         agent = agents.get(agent_name, None)
         if not agent:
             raise HTTPException(status_code=404, detail=f"Agent {agent_name} not found")
         return agent
 
     @app.get("/agents")
-    async def list() -> AgentsListResponse:
+    async def list_agents() -> AgentsListResponse:
         return AgentsListResponse(
             agents=[
-                AgentModel(name=agent.name, description=agent.description)
+                AgentModel(name=agent.name, description=agent.description, metadata=agent.metadata)
                 for agent in agents.values()
             ]
         )
 
     @app.get("/agents/{name}")
-    async def read(name: AgentName) -> AgentReadResponse:
+    async def read_agent(name: AgentName) -> AgentReadResponse:
         agent = find_agent(name)
-        return AgentModel(name=agent.name, description=agent.description)
+        return AgentModel(name=agent.name, description=agent.description, metadata=agent.metadata)
 
     @app.post("/runs")
-    async def create(request: RunCreateRequest) -> RunCreateResponse:
+    async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
         bundle = RunBundle(
             agent=agent,
@@ -94,12 +110,12 @@ def create_app(*agents: Agent) -> FastAPI:
                 raise NotImplementedError()
 
     @app.get("/runs/{run_id}")
-    async def read(run_id: RunId) -> RunReadResponse:
+    async def read_run(run_id: RunId) -> RunReadResponse:
         bundle = find_run_bundle(run_id)
         return bundle.run
 
     @app.post("/runs/{run_id}")
-    async def resume(run_id: RunId, request: RunResumeRequest) -> RunResumeResponse:
+    async def resume_run(run_id: RunId, request: RunResumeRequest) -> RunResumeResponse:
         bundle = find_run_bundle(run_id)
         bundle.stream_queue = asyncio.Queue()  # TODO improve
         await bundle.await_queue.put(request.await_)
@@ -121,7 +137,7 @@ def create_app(*agents: Agent) -> FastAPI:
                 raise NotImplementedError()
 
     @app.post("/runs/{run_id}/cancel")
-    async def cancel(run_id: RunId) -> RunCancelResponse:
+    async def cancel_run(run_id: RunId) -> RunCancelResponse:
         bundle = find_run_bundle(run_id)
         if bundle.run.status.is_terminal:
             raise HTTPException(
@@ -130,8 +146,19 @@ def create_app(*agents: Agent) -> FastAPI:
             )
         bundle.task.cancel()
         bundle.run.status = RunStatus.CANCELLING
-        return JSONResponse(
-            status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump()
-        )
+        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump())
 
     return app
+
+
+def serve(
+    *agents: Agent, 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(*agents), **kwargs)

acp_sdk-1.0.0rc3/src/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-1.0.0rc1 → acp_sdk-1.0.0rc3}/src/acp_sdk/server/utils.py

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

acp_sdk-1.0.0rc1/.python-version

@@ -1 +0,0 @@
-3.13

acp_sdk-1.0.0rc1/examples/servers/echo.py

@@ -1,22 +0,0 @@
-from acp_sdk.models import (
-    Message,
-)
-from acp_sdk.server import Agent, create_app
-
-from acp_sdk.server.context import Context
-
-
-class EchoAgent(Agent):
-    @property
-    def name(self):
-        return "echo"
-
-    @property
-    def description(self):
-        return "Echoes everything"
-
-    async def run(self, input: Message, *, context: Context):
-        yield input
-
-
-app = create_app(EchoAgent())

acp_sdk-1.0.0rc1/examples/servers/multi-agent.py

@@ -1,169 +0,0 @@
-import asyncio
-from typing import AsyncGenerator
-import uuid
-
-from acp_sdk.models import (
-    Message,
-    Await,
-    AwaitResume,
-    SessionId,
-    TextMessagePart,
-)
-from acp_sdk.server import Agent, serve
-
-from beeai_framework.agents.react import ReActAgent
-from beeai_framework.backend.chat import ChatModel, ChatModelParameters
-from beeai_framework.backend.message import UserMessage
-from beeai_framework.memory import TokenMemory
-from beeai_framework.tools.search import DuckDuckGoSearchTool, WikipediaTool
-from beeai_framework.tools.weather.openmeteo import OpenMeteoTool
-
-from acp_sdk.server.context import Context
-
-
-class EchoAgent(Agent):
-    @property
-    def name(self):
-        return "echo"
-
-    @property
-    def description(self):
-        return "Echoes everything"
-
-    async def run(self, input: Message, *, context: Context):
-        yield input
-
-
-class LazyEchoAgent(Agent):
-    @property
-    def name(self):
-        return "lazy_echo"
-
-    @property
-    def description(self):
-        return "Echoes everything with 1 minute delay"
-
-    async def run(self, input: Message, *, context: Context):
-        await asyncio.sleep(60)
-        yield input
-
-
-class StreamingEchoAgent(Agent):
-    @property
-    def name(self):
-        return "streaming_echo"
-
-    @property
-    def description(self):
-        return "Echoes all message parts in a stream"
-
-    async def run(self, input: Message, *, context: Context):
-        for part in input:
-            yield {"thought": "nothing really"}
-            yield Message(part)
-
-
-class AwaitingAgent(Agent):
-    @property
-    def name(self):
-        return "awaiting"
-
-    @property
-    def description(self):
-        return "Greets and awaits for more data"
-
-    async def run(
-        self, input: Message, *, context: Context
-    ) -> AsyncGenerator[Message | Await, AwaitResume]:
-        yield Message(TextMessagePart(content="Hello!"))
-        data = yield Await()
-        yield Message(TextMessagePart(content=f"Thanks for {data}"))
-
-
-class BeeAIAgent(Agent):
-    def __init__(self):
-        self.llm = ChatModel.from_name(
-            "ollama:llama3.1",
-            ChatModelParameters(temperature=0),
-        )
-
-    @property
-    def name(self):
-        return "beeai"
-
-    @property
-    def description(self):
-        return "Beeai agent powered by ollama and no tools"
-
-    async def run(self, input: Message, *, context: Context):
-        memory = TokenMemory(self.llm)
-        await memory.add_many(
-            (
-                UserMessage(part.content)
-                for part in input
-                if isinstance(part, TextMessagePart)
-            )
-        )
-        output = await ReActAgent(llm=self.llm, tools=[], memory=memory).run(
-            prompt=None
-        )
-        for content in output.result.get_texts():
-            yield Message(TextMessagePart(content=content.text))
-
-
-class BeeAIAgentAdvanced(Agent):
-    def __init__(self):
-        self.llm = ChatModel.from_name(
-            "ollama:llama3.1",
-            ChatModelParameters(temperature=0),
-        )
-        self.tools = [
-            WikipediaTool(),
-            OpenMeteoTool(),
-            DuckDuckGoSearchTool(),
-        ]
-        self.memories: dict[SessionId, TokenMemory] = dict()
-
-    @property
-    def name(self):
-        return "beeai_advanced"
-
-    @property
-    def description(self):
-        return "Beeai agent powered by ollama with tools and sessions"
-
-    async def session(self, session_id: SessionId | None):
-        if session_id and session_id not in self.memories:
-            raise ValueError("Memory not found")
-
-        session_id = session_id or str(uuid.uuid4())
-        memory = self.memories.get(session_id, TokenMemory(self.llm))
-        self.memories[session_id] = memory
-        return session_id
-
-    async def run(self, input: Message, *, context: Context):
-        await self.memories[context.session_id].add_many(
-            (
-                UserMessage(part.content)
-                for part in input
-                if isinstance(part, TextMessagePart)
-            )
-        )
-        output = await ReActAgent(
-            llm=self.llm, tools=self.tools, memory=self.memories[context.session_id]
-        ).run(prompt=None)
-        for content in output.result.get_texts():
-            yield Message(TextMessagePart(content=content.text))
-
-
-if __name__ == "__main__":
-    asyncio.run(
-        serve(
-            EchoAgent(),
-            LazyEchoAgent(),
-            StreamingEchoAgent(),
-            AwaitingAgent(),
-            BeeAIAgent(),
-            BeeAIAgentAdvanced(),
-        )
-    )

acp_sdk-1.0.0rc1/src/acp_sdk/client/__init__.py

@@ -1 +0,0 @@
-from acp_sdk.client.client import Client

acp_sdk-1.0.0rc1/src/acp_sdk/server/__init__.py

@@ -1,2 +0,0 @@
-from acp_sdk.server.server import create_app
-from acp_sdk.server.agent import Agent

acp_sdk-1.0.0rc1/src/acp_sdk/server/telemetry.py

@@ -1,45 +0,0 @@
-import logging
-from importlib.metadata import version
-
-from opentelemetry import trace
-from opentelemetry.sdk.resources import (
-    Resource,
-    SERVICE_NAME,
-    SERVICE_NAMESPACE,
-    SERVICE_VERSION,
-)
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExportResult
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-
-logger = logging.getLogger("uvicorn.error")
-
-
-class SilentOTLPSpanExporter(OTLPSpanExporter):
-    def export(self, spans):
-        try:
-            return super().export(spans)
-        except Exception as e:
-            logger.warning(f"OpenTelemetry Exporter failed silently: {e}")
-            return SpanExportResult.FAILURE
-
-
-def configure_telemetry():
-    current_provider = trace.get_tracer_provider()
-
-    # Detect default provider and override
-    if isinstance(current_provider, trace.ProxyTracerProvider):
-        provider = TracerProvider(
-            resource=Resource(
-                attributes={
-                    SERVICE_NAME: "acp-server",
-                    SERVICE_NAMESPACE: "acp",
-                    SERVICE_VERSION: version("acp-sdk"),
-                }
-            )
-        )
-
-        processor = BatchSpanProcessor(SilentOTLPSpanExporter())
-        provider.add_span_processor(processor)
-
-        trace.set_tracer_provider(provider)