acp-sdk 0.8.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

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/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/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/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/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/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.dist-info → acp_sdk-0.9.1.dist-info}/METADATA

@@ -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.dist-info → acp_sdk-0.9.1.dist-info}/RECORD

@@ -3,25 +3,25 @@ acp_sdk/instrumentation.py,sha256=JqSyvILN3sGAfOZrmckQq4-M_4_5alyPn95DK0o5lfA,16
 acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 acp_sdk/version.py,sha256=Niy83rgvigB4hL_rR-O4ySvI7dj6xnqkyOe_JTymi9s,73
 acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
-acp_sdk/client/client.py,sha256=GnkbhCoEghI9A0_Otmzb18V4ot1uNz0hEXNjIAPNHOE,8599
+acp_sdk/client/client.py,sha256=7GVD7eVlaSU78O3puMlyoOTqKjTwZYaBKLHyYvbvr3I,8504
 acp_sdk/client/types.py,sha256=_H6zYt-2OHOOYRtssRnbDIiwmgsl2-KIXc9lb-mJLFA,133
 acp_sdk/client/utils.py,sha256=2jhJyrPJmVFRoDJh0q_JMqOMlC3IxCh-6HXed-PIZS8,924
 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=PSv3Vq07ahCi6JpvEMzEdEjHdUU7NT9KTf21CF9B3-g,7629
+acp_sdk/models/models.py,sha256=So5D9VjJxX2jdOF8BGc3f9D2ssbAyFEO2Rgr1KykI-M,7730
 acp_sdk/models/schemas.py,sha256=_ah7_zHsQJGxDXvnzsBvASdRsQHVphFQ7Sum6A04iRw,759
 acp_sdk/server/__init__.py,sha256=mxBBBFaZuMEUENRMLwp1XZkuLeT9QghcFmNvjnqvAAU,377
 acp_sdk/server/agent.py,sha256=6VBKn_qVXqUl79G8T7grwhnuLMwr67d4UGagMGX1hMs,6586
-acp_sdk/server/app.py,sha256=1S1mxECioL5NeGjGo5C8u94x7Ybvj79L_Aauu2352vA,7117
-acp_sdk/server/bundle.py,sha256=5Rq6E4WgmuwPQ4u-sViaHeu5loCLEUgojWav9LAghX4,7036
+acp_sdk/server/app.py,sha256=ViumwzMngn63wtpFllu3nnIOt9JL9PQYrTcI8v-_uY4,7257
+acp_sdk/server/bundle.py,sha256=umD2GgDp17lUddu0adpp1zUcm1JJvDrDpIZ0uR-6VeY,7204
 acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
 acp_sdk/server/errors.py,sha256=GSO8yYIqEeX8Y4Lz86ks35dMTHiQiXuOrLYYx0eXsbI,2110
 acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
-acp_sdk/server/server.py,sha256=JLQ2tyZpQaWvhZYw6-OWbKlSRNWezXLXhD5OFbKPysw,8014
+acp_sdk/server/server.py,sha256=0thIxmqLV-hqwSqP_TUSZAl9pog06lROAQgnSIIabME,13621
 acp_sdk/server/session.py,sha256=ekz1o6Sy1tQZlpaoS_VgbvFuUQh2qpiHG71mvBdvhgc,662
-acp_sdk/server/telemetry.py,sha256=1BUxNg-xL_Vqgs27PDWNc3HikrQW2lidAtT_FKlp_Qk,1833
+acp_sdk/server/telemetry.py,sha256=lbB2ppijUcqbHUOn0e-15LGcVvT_qrMguq8qBokICac,2016
 acp_sdk/server/types.py,sha256=gLb5wCkMYhmu2laj_ymK-TPfN9LSjRgKOP1H_893UzA,304
 acp_sdk/server/utils.py,sha256=BhZKBNaLgczX6aYjxYva-6VI1bKmHtYQ5YDA5LrwF50,1831
-acp_sdk-0.8.4.dist-info/METADATA,sha256=AZFhr-FKotfSVMuKUCdixS18rg6d-fjePoy2hWw3SnY,1651
-acp_sdk-0.8.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.8.4.dist-info/RECORD,,
+acp_sdk-0.9.1.dist-info/METADATA,sha256=fdUTU2kHk-OakxDoaTCLUagieJuM8DjsKZiFsOzDEK8,1650
+acp_sdk-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.9.1.dist-info/RECORD,,