acp-sdk 0.8.3__py3-none-any.whl → 0.9.0__py3-none-any.whl

acp_sdk/client/client.py

@@ -22,6 +22,7 @@ from acp_sdk.models import (
     AgentsListResponse,
     AwaitResume,
     Error,
+    ErrorEvent,
     Event,
     PingResponse,
     Run,
@@ -224,7 +225,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

@@ -1,3 +1,4 @@
+import asyncio
 import uuid
 from datetime import datetime, timezone
 from enum import Enum
@@ -5,7 +6,7 @@ from typing import Any, Literal, Optional, Union
 
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field
 
-from acp_sdk.models.errors import Error
+from acp_sdk.models.errors import ACPError, Error
 
 
 class AnyModel(BaseModel):
@@ -196,6 +197,15 @@ class Run(BaseModel):
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     finished_at: datetime | None = None
 
+    def raise_for_status(self) -> "Run":
+        match self.status:
+            case RunStatus.CANCELLED:
+                raise asyncio.CancelledError()
+            case RunStatus.FAILED:
+                raise ACPError(error=self.error)
+            case _:
+                return self
+
 
 class MessageCreatedEvent(BaseModel):
     type: Literal["message.created"] = "message.created"
@@ -252,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/agent.py

@@ -58,13 +58,13 @@ class Agent(abc.ABC):
             run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, input, context)
 
         try:
-            while True:
+            while not run.done() or yield_queue.async_q.qsize() > 0:
                 value = yield await yield_queue.async_q.get()
+                if isinstance(value, Exception):
+                    raise value
                 await yield_resume_queue.async_q.put(value)
         except janus.AsyncQueueShutDown:
             pass
-        finally:
-            await run  # Raise exceptions
 
     async def _run_async_gen(self, input: list[Message], context: Context) -> None:
         try:
@@ -74,12 +74,16 @@ class Agent(abc.ABC):
                 value = await context.yield_async(await gen.asend(value))
         except StopAsyncIteration:
             pass
+        except Exception as e:
+            await context.yield_async(e)
         finally:
             context.shutdown()
 
     async def _run_coro(self, input: list[Message], context: Context) -> None:
         try:
             await context.yield_async(await self.run(input, context))
+        except Exception as e:
+            await context.yield_async(e)
         finally:
             context.shutdown()
 
@@ -91,12 +95,16 @@ class Agent(abc.ABC):
                 value = context.yield_sync(gen.send(value))
         except StopIteration:
             pass
+        except Exception as e:
+            context.yield_sync(e)
         finally:
             context.shutdown()
 
     def _run_func(self, input: list[Message], context: Context) -> None:
         try:
             context.yield_sync(self.run(input, context))
+        except Exception as e:
+            context.yield_sync(e)
         finally:
             context.shutdown()
 

acp_sdk/server/app.py

@@ -6,6 +6,7 @@ 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
@@ -53,19 +54,24 @@ 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,
     )
 

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,9 +108,14 @@ 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
 
         if configure_logger:
@@ -112,7 +124,7 @@ class Server:
             configure_telemetry_func()
 
         config = uvicorn.Config(
-            create_app(*self._agents, run_limit=run_limit, run_ttl=run_ttl),
+            create_app(*self.agents, lifespan=self.lifespan, run_limit=run_limit, run_ttl=run_ttl),
             host,
             port,
             uds,
@@ -161,23 +173,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 +315,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 +326,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 +343,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/types.py

@@ -5,5 +5,5 @@ from pydantic import BaseModel
 from acp_sdk.models import AwaitRequest, AwaitResume, Message
 from acp_sdk.models.models import MessagePart
 
-RunYield = Message | MessagePart | str | AwaitRequest | BaseModel | dict[str | Any] | None
+RunYield = Message | MessagePart | str | AwaitRequest | BaseModel | dict[str | Any] | None | Exception
 RunYieldResume = AwaitResume | None

{acp_sdk-0.8.3.dist-info → acp_sdk-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.8.3
+Version: 0.9.0
 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.3.dist-info → acp_sdk-0.9.0.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=xQWBVJZuT7JmPS3dw6W1CidT9Uqi-XqZ6R-Xj04IefA,8718
 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=aRKbg-17HtxQE9fkI8-lWrOL7D6iUsLr7hipkh857yg,7318
+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=wvwpi83osmW7zQWxVnzyVMXIvzOswAfhKWHscVIldhA,6245
-acp_sdk/server/app.py,sha256=1S1mxECioL5NeGjGo5C8u94x7Ybvj79L_Aauu2352vA,7117
-acp_sdk/server/bundle.py,sha256=5Rq6E4WgmuwPQ4u-sViaHeu5loCLEUgojWav9LAghX4,7036
+acp_sdk/server/agent.py,sha256=6VBKn_qVXqUl79G8T7grwhnuLMwr67d4UGagMGX1hMs,6586
+acp_sdk/server/app.py,sha256=VR8UPR08SXebABvfvgdnjOR-mqV_Df8iSWdG_yG4wvg,7372
+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=BPFs5vFAvSL2Xq-446gJHuWmvr3xUdqMQu4OXD4JIU8,13599
 acp_sdk/server/session.py,sha256=ekz1o6Sy1tQZlpaoS_VgbvFuUQh2qpiHG71mvBdvhgc,662
 acp_sdk/server/telemetry.py,sha256=1BUxNg-xL_Vqgs27PDWNc3HikrQW2lidAtT_FKlp_Qk,1833
-acp_sdk/server/types.py,sha256=teBNRWSks8XP1SCQKGEtbNWQahVD3RAOPnysTxcQPxI,292
+acp_sdk/server/types.py,sha256=gLb5wCkMYhmu2laj_ymK-TPfN9LSjRgKOP1H_893UzA,304
 acp_sdk/server/utils.py,sha256=BhZKBNaLgczX6aYjxYva-6VI1bKmHtYQ5YDA5LrwF50,1831
-acp_sdk-0.8.3.dist-info/METADATA,sha256=Ytt81jup9-tzo-xCw3vKch0NiNWDmNKjatwzQiHwM-4,1651
-acp_sdk-0.8.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.8.3.dist-info/RECORD,,
+acp_sdk-0.9.0.dist-info/METADATA,sha256=p92B6qlLrhgAxulgcoBn7GBJP-TaQZ8MjsMgyO-L6EY,1650
+acp_sdk-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.9.0.dist-info/RECORD,,