acp-sdk 0.8.4__tar.gz → 0.9.1__tar.gz

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.8.4
+Version: 0.9.1
 Summary: Agent Communication Protocol SDK
 Author: IBM Corp.
 Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>
@@ -16,7 +16,7 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31.1
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.52b1
 Requires-Dist: opentelemetry-instrumentation-httpx>=0.52b1
 Requires-Dist: opentelemetry-sdk>=1.31.1
-Requires-Dist: pydantic>=2.11.1
+Requires-Dist: pydantic>=2.0.0
 Description-Content-Type: text/markdown
 
 # Agent Communication Protocol SDK for Python

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.8.4"
+version = "0.9.1"
 description = "Agent Communication Protocol SDK"
 license = "Apache-2.0"
 readme = "README.md"
@@ -9,7 +9,7 @@ maintainers = [{ name = "Tomas Pilar", email = "thomas7pilar@gmail.com" }]
 requires-python = ">=3.11, <4.0"
 dependencies = [
     "opentelemetry-api>=1.31.1",
-    "pydantic>=2.11.1",
+    "pydantic>=2.0.0",
     "httpx>=0.26.0",
     "httpx-sse>=0.4.0",
     "opentelemetry-instrumentation-httpx>=0.52b1",

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/client/client.py

@@ -8,7 +8,6 @@ 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.client.types import Input
@@ -22,6 +21,7 @@ from acp_sdk.models import (
     AgentsListResponse,
     AwaitResume,
     Error,
+    ErrorEvent,
     Event,
     PingResponse,
     Run,
@@ -43,7 +43,6 @@ class Client:
         *,
         session_id: SessionId | None = None,
         client: httpx.AsyncClient | None = None,
-        instrument: bool = True,
         auth: httpx._types.AuthTypes | None = None,
         params: httpx._types.QueryParamTypes | None = None,
         headers: httpx._types.HeaderTypes | None = None,
@@ -84,8 +83,6 @@ class Client:
             transport=transport,
             trust_env=trust_env,
         )
-        if instrument:
-            HTTPXClientInstrumentor.instrument_client(self._client)
 
     @property
     def client(self) -> httpx.AsyncClient:
@@ -107,7 +104,7 @@ class Client:
     async def session(self, session_id: SessionId | None = None) -> AsyncGenerator[Self]:
         session_id = session_id or uuid.uuid4()
         with get_tracer().start_as_current_span("session", attributes={"acp.session": str(session_id)}):
-            yield Client(client=self._client, session_id=session_id, instrument=False)
+            yield Client(client=self._client, session_id=session_id)
 
     async def agents(self) -> AsyncIterator[Agent]:
         response = await self._client.get("/agents")
@@ -224,7 +221,9 @@ class Client:
             await event_source.response.aread()
             self._raise_error(event_source.response)
         async for event in event_source.aiter_sse():
-            event = TypeAdapter(Event).validate_json(event.data)
+            event: Event = TypeAdapter(Event).validate_json(event.data)
+            if isinstance(event, ErrorEvent):
+                raise ACPError(error=event.error)
             yield event
 
     def _raise_error(self, response: httpx.Response) -> None:

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/models/models.py

@@ -262,7 +262,13 @@ class RunCompletedEvent(BaseModel):
     run: Run
 
 
+class ErrorEvent(BaseModel):
+    type: Literal["error"] = "error"
+    error: Error
+
+
 Event = Union[
+    ErrorEvent,
     RunCreatedEvent,
     RunInProgressEvent,
     MessageCreatedEvent,

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/server/app.py

@@ -6,9 +6,9 @@ from enum import Enum
 
 from cachetools import TTLCache
 from fastapi import Depends, FastAPI, HTTPException, status
+from fastapi.applications import AppType, Lifespan
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 
 from acp_sdk.models import (
     Agent as AgentModel,
@@ -53,24 +53,27 @@ def create_app(
     *agents: Agent,
     run_limit: int = 1000,
     run_ttl: timedelta = timedelta(hours=1),
+    lifespan: Lifespan[AppType] | None = None,
     dependencies: list[Depends] | None = None,
 ) -> FastAPI:
     executor: ThreadPoolExecutor
 
     @asynccontextmanager
-    async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+    async def internal_lifespan(app: FastAPI) -> AsyncGenerator[None]:
         nonlocal executor
         with ThreadPoolExecutor() as exec:
             executor = exec
-            yield
+            if not lifespan:
+                yield None
+            else:
+                async with lifespan(app) as state:
+                    yield state
 
     app = FastAPI(
-        lifespan=lifespan,
+        lifespan=internal_lifespan,
         dependencies=dependencies,
     )
 
-    FastAPIInstrumentor.instrument_app(app)
-
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
     runs: TTLCache[RunId, RunBundle] = TTLCache(maxsize=run_limit, ttl=run_ttl, timer=datetime.now)
     sessions: TTLCache[SessionId, Session] = TTLCache(maxsize=run_limit, ttl=run_ttl, timer=datetime.now)

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/server/bundle.py

@@ -142,6 +142,8 @@ class RunBundle:
                         run_logger.info("Run resumed")
                     elif isinstance(next, Error):
                         raise ACPError(error=next)
+                    elif isinstance(next, ACPError):
+                        raise next
                     elif next is None:
                         await flush_message()
                     elif isinstance(next, BaseModel):
@@ -176,3 +178,5 @@ class RunBundle:
             finally:
                 self.await_or_terminate_event.set()
                 await self.stream_queue.put(None)
+                if not self.task.done():
+                    self.task.cancel()

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/server/server.py

@@ -1,12 +1,14 @@
 import asyncio
 import os
-from collections.abc import Awaitable
+from collections.abc import AsyncGenerator, Awaitable
+from contextlib import asynccontextmanager
 from datetime import timedelta
 from typing import Any, Callable
 
 import requests
 import uvicorn
 import uvicorn.config
+from fastapi import FastAPI
 
 from acp_sdk.models import Metadata
 from acp_sdk.server.agent import Agent
@@ -20,8 +22,8 @@ from acp_sdk.server.utils import async_request_with_retry
 
 class Server:
     def __init__(self) -> None:
-        self._agents: list[Agent] = []
-        self._server: uvicorn.Server | None = None
+        self.agents: list[Agent] = []
+        self.server: uvicorn.Server | None = None
 
     def agent(
         self,
@@ -40,10 +42,15 @@ class Server:
         return decorator
 
     def register(self, *agents: Agent) -> None:
-        self._agents.extend(agents)
+        self.agents.extend(agents)
 
-    def run(
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI) -> AsyncGenerator[None]:
+        yield
+
+    async def serve(
         self,
+        *,
         configure_logger: bool = True,
         configure_telemetry: bool = False,
         self_registration: bool = True,
@@ -101,18 +108,25 @@ class Server:
         factory: bool = False,
         h11_max_incomplete_event_size: int | None = None,
     ) -> None:
-        if self._server:
+        if self.server:
             raise RuntimeError("The server is already running")
 
+        if headers is None:
+            headers = [("server", "acp")]
+        elif not any(k.lower() == "server" for k, _ in headers):
+            headers.append(("server", "acp"))
+
         import uvicorn
 
+        app = create_app(*self.agents, lifespan=self.lifespan, run_limit=run_limit, run_ttl=run_ttl)
+
         if configure_logger:
             configure_logger_func()
         if configure_telemetry:
-            configure_telemetry_func()
+            configure_telemetry_func(app)
 
         config = uvicorn.Config(
-            create_app(*self._agents, run_limit=run_limit, run_ttl=run_ttl),
+            app,
             host,
             port,
             uds,
@@ -161,23 +175,139 @@ class Server:
             factory,
             h11_max_incomplete_event_size,
         )
-        self._server = uvicorn.Server(config)
+        self.server = uvicorn.Server(config)
+        await self._serve(self_registration=self_registration)
 
-        asyncio.run(self._serve(self_registration=self_registration))
+    def run(
+        self,
+        *,
+        configure_logger: bool = True,
+        configure_telemetry: bool = False,
+        self_registration: bool = True,
+        run_limit: int = 1000,
+        run_ttl: timedelta = timedelta(hours=1),
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        uds: str | None = None,
+        fd: int | None = None,
+        loop: uvicorn.config.LoopSetupType = "auto",
+        http: type[asyncio.Protocol] | uvicorn.config.HTTPProtocolType = "auto",
+        ws: type[asyncio.Protocol] | uvicorn.config.WSProtocolType = "auto",
+        ws_max_size: int = 16 * 1024 * 1024,
+        ws_max_queue: int = 32,
+        ws_ping_interval: float | None = 20.0,
+        ws_ping_timeout: float | None = 20.0,
+        ws_per_message_deflate: bool = True,
+        lifespan: uvicorn.config.LifespanType = "auto",
+        env_file: str | os.PathLike[str] | None = None,
+        log_config: dict[str, Any]
+        | str
+        | uvicorn.config.RawConfigParser
+        | uvicorn.config.IO[Any]
+        | None = uvicorn.config.LOGGING_CONFIG,
+        log_level: str | int | None = None,
+        access_log: bool = True,
+        use_colors: bool | None = None,
+        interface: uvicorn.config.InterfaceType = "auto",
+        reload: bool = False,
+        reload_dirs: list[str] | str | None = None,
+        reload_delay: float = 0.25,
+        reload_includes: list[str] | str | None = None,
+        reload_excludes: list[str] | str | None = None,
+        workers: int | None = None,
+        proxy_headers: bool = True,
+        server_header: bool = True,
+        date_header: bool = True,
+        forwarded_allow_ips: list[str] | str | None = None,
+        root_path: str = "",
+        limit_concurrency: int | None = None,
+        limit_max_requests: int | None = None,
+        backlog: int = 2048,
+        timeout_keep_alive: int = 5,
+        timeout_notify: int = 30,
+        timeout_graceful_shutdown: int | None = None,
+        callback_notify: Callable[..., Awaitable[None]] | None = None,
+        ssl_keyfile: str | os.PathLike[str] | None = None,
+        ssl_certfile: str | os.PathLike[str] | None = None,
+        ssl_keyfile_password: str | None = None,
+        ssl_version: int = uvicorn.config.SSL_PROTOCOL_VERSION,
+        ssl_cert_reqs: int = uvicorn.config.ssl.CERT_NONE,
+        ssl_ca_certs: str | None = None,
+        ssl_ciphers: str = "TLSv1",
+        headers: list[tuple[str, str]] | None = None,
+        factory: bool = False,
+        h11_max_incomplete_event_size: int | None = None,
+    ) -> None:
+        asyncio.run(
+            self.serve(
+                configure_logger=configure_logger,
+                configure_telemetry=configure_telemetry,
+                self_registration=self_registration,
+                run_limit=run_limit,
+                run_ttl=run_ttl,
+                host=host,
+                port=port,
+                uds=uds,
+                fd=fd,
+                loop=loop,
+                http=http,
+                ws=ws,
+                ws_max_size=ws_max_size,
+                ws_max_queue=ws_max_queue,
+                ws_ping_interval=ws_ping_interval,
+                ws_ping_timeout=ws_ping_timeout,
+                ws_per_message_deflate=ws_per_message_deflate,
+                lifespan=lifespan,
+                env_file=env_file,
+                log_config=log_config,
+                log_level=log_level,
+                access_log=access_log,
+                use_colors=use_colors,
+                interface=interface,
+                reload=reload,
+                reload_dirs=reload_dirs,
+                reload_delay=reload_delay,
+                reload_includes=reload_includes,
+                reload_excludes=reload_excludes,
+                workers=workers,
+                proxy_headers=proxy_headers,
+                server_header=server_header,
+                date_header=date_header,
+                forwarded_allow_ips=forwarded_allow_ips,
+                root_path=root_path,
+                limit_concurrency=limit_concurrency,
+                limit_max_requests=limit_max_requests,
+                backlog=backlog,
+                timeout_keep_alive=timeout_keep_alive,
+                timeout_notify=timeout_notify,
+                timeout_graceful_shutdown=timeout_graceful_shutdown,
+                callback_notify=callback_notify,
+                ssl_keyfile=ssl_keyfile,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile_password=ssl_keyfile_password,
+                ssl_version=ssl_version,
+                ssl_cert_reqs=ssl_cert_reqs,
+                ssl_ca_certs=ssl_ca_certs,
+                ssl_ciphers=ssl_ciphers,
+                headers=headers,
+                factory=factory,
+                h11_max_incomplete_event_size=h11_max_incomplete_event_size,
+            )
+        )
 
     async def _serve(self, self_registration: bool = True) -> None:
         registration_task = asyncio.create_task(self._register_agent()) if self_registration else None
-        await self._server.serve()
+        await self.server.serve()
         if registration_task:
             registration_task.cancel()
 
     @property
     def should_exit(self) -> bool:
-        return self._server.should_exit if self._server else False
+        return self.server.should_exit if self.server else False
 
     @should_exit.setter
     def should_exit(self, value: bool) -> None:
-        self._server.should_exit = value
+        self.server.should_exit = value
 
     async def _register_agent(self) -> None:
         """If not in PRODUCTION mode, register agent to the beeai platform and provide missing env variables"""
@@ -187,7 +317,7 @@ class Server:
 
         url = os.getenv("PLATFORM_URL", "http://127.0.0.1:8333")
         request_data = {
-            "location": f"http://{self._server.config.host}:{self._server.config.port}",
+            "location": f"http://{self.server.config.host}:{self.server.config.port}",
         }
         try:
             await async_request_with_retry(
@@ -198,7 +328,7 @@ class Server:
             # check missing env keyes
             envs_request = await async_request_with_retry(lambda client: client.get(f"{url}/api/v1/variables"))
             envs = envs_request.get("env")
-            for agent in self._agents:
+            for agent in self.agents:
                 # register all available envs
                 missing_keyes = []
                 for env in agent.metadata.model_dump().get("env", []):
@@ -215,4 +345,11 @@ class Server:
         except requests.exceptions.ConnectionError as e:
             logger.warning(f"Can not reach server, check if running on {url} : {e}")
         except (requests.exceptions.HTTPError, Exception) as e:
-            logger.warning(f"Agent can not be registered to beeai server: {e}")
+            try:
+                error_message = e.response.json().get("detail")
+                if error_message:
+                    logger.warning(f"Agent can not be registered to beeai server: {error_message}")
+                else:
+                    logger.warning(f"Agent can not be registered to beeai server: {e}")
+            except Exception:
+                logger.warning(f"Agent can not be registered to beeai server: {e}")

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/src/acp_sdk/server/telemetry.py

@@ -1,9 +1,11 @@
 import logging
 
+from fastapi import FastAPI
 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.instrumentation.fastapi import FastAPIInstrumentor
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.metrics import MeterProvider
@@ -22,8 +24,10 @@ from acp_sdk.version import __version__
 root_logger = logging.getLogger()
 
 
-def configure_telemetry() -> None:
-    """Utility that configures opentelemetry with OTLP exporter"""
+def configure_telemetry(app: FastAPI) -> None:
+    """Utility that configures opentelemetry with OTLP exporter and FastAPI instrumentation"""
+
+    FastAPIInstrumentor.instrument_app(app)
 
     resource = Resource(
         attributes={

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/tests/e2e/fixtures/server.py

@@ -7,6 +7,7 @@ from threading import Thread
 
 import pytest
 from acp_sdk.models import Artifact, AwaitResume, Error, ErrorCode, Message, MessageAwaitRequest, MessagePart
+from acp_sdk.models.errors import ACPError
 from acp_sdk.server import Context, Server
 
 from e2e.config import Config
@@ -38,6 +39,11 @@ def server(request: pytest.FixtureRequest) -> Generator[None]:
     @server.agent()
     async def failer(input: list[Message], context: Context) -> AsyncIterator[Message]:
         yield Error(code=ErrorCode.INVALID_INPUT, message="Wrong question buddy!")
+        raise RuntimeError("Unreachable code")
+
+    @server.agent()
+    async def raiser(input: list[Message], context: Context) -> AsyncIterator[Message]:
+        raise ACPError(Error(code=ErrorCode.INVALID_INPUT, message="Wrong question buddy!"))
 
     @server.agent()
     async def sessioner(input: list[Message], context: Context) -> AsyncIterator[Message]:

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/tests/e2e/test_suites/test_runs.py

@@ -72,8 +72,9 @@ async def test_run_events_are_stream(server: Server, client: Client) -> None:
 
 
 @pytest.mark.asyncio
-async def test_failure(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="failer", input=input)
+@pytest.mark.parametrize("agent", ["failer", "raiser"])
+async def test_failure(server: Server, client: Client, agent: AgentName) -> None:
+    run = await client.run_sync(agent=agent, input=input)
     assert run.status == RunStatus.FAILED
     assert run.error is not None
     assert run.error.code == ErrorCode.INVALID_INPUT

{acp_sdk-0.8.4 → acp_sdk-0.9.1}/tests/unit/client/test_client.py

@@ -4,8 +4,12 @@ import uuid
 import pytest
 from acp_sdk.client import Client
 from acp_sdk.models import (
+    ACPError,
     Agent,
     AgentsListResponse,
+    Error,
+    ErrorCode,
+    ErrorEvent,
     Message,
     MessageAwaitResume,
     MessagePart,
@@ -77,6 +81,24 @@ async def test_run_stream(httpx_mock: HTTPXMock) -> None:
             assert event == mock_event
 
 
+@pytest.mark.asyncio
+async def test_run_stream_error(httpx_mock: HTTPXMock) -> None:
+    error = Error(code=ErrorCode.SERVER_ERROR, message="whoops")
+    mock_event = ErrorEvent(error=error)
+    httpx_mock.add_response(
+        url="http://test/runs",
+        method="POST",
+        headers={"content-type": "text/event-stream"},
+        content=f"data: {mock_event.model_dump_json()}\n\n",
+    )
+
+    async with Client(base_url="http://test") as client:
+        with pytest.raises(ACPError) as e:
+            async for _ in client.run_stream("Howdy!", agent=mock_run.agent_name):
+                raise AssertionError()
+        assert e.value.error == error
+
+
 @pytest.mark.asyncio
 async def test_run_status(httpx_mock: HTTPXMock) -> None:
     httpx_mock.add_response(url=f"http://test/runs/{mock_run.run_id}", method="GET", content=mock_run.model_dump_json())

acp_sdk-0.9.1/tests/unit/server/test_server.py

@@ -0,0 +1,31 @@
+import asyncio
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import pytest
+from acp_sdk.server import Server
+from fastapi import FastAPI
+
+
+@pytest.mark.asyncio
+async def test_lifespan() -> None:
+    entry = False
+    exit = False
+
+    class TestServer(Server):
+        @asynccontextmanager
+        async def lifespan(self, app: FastAPI) -> AsyncGenerator[None]:
+            nonlocal entry
+            nonlocal exit
+            entry = True
+            yield
+            exit = True
+
+    server = TestServer()
+    task = asyncio.create_task(server.serve())
+    await asyncio.sleep(1)
+    server.should_exit = True
+    await task
+
+    assert entry
+    assert exit