acp-sdk 0.8.3__tar.gz → 0.9.0__tar.gz

{acp_sdk-0.8.3 → acp_sdk-0.9.0}/PKG-INFO

@@ -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 → acp_sdk-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.8.3"
+version = "0.9.0"
 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.3 → acp_sdk-0.9.0}/src/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-0.8.3 → acp_sdk-0.9.0}/src/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-0.8.3 → acp_sdk-0.9.0}/src/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-0.8.3 → acp_sdk-0.9.0}/src/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-0.8.3 → acp_sdk-0.9.0}/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.3 → acp_sdk-0.9.0}/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,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-0.8.3 → acp_sdk-0.9.0}/src/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 → acp_sdk-0.9.0}/tests/e2e/fixtures/server.py

@@ -1,3 +1,4 @@
+import asyncio
 import base64
 import time
 from collections.abc import AsyncGenerator, AsyncIterator, Generator
@@ -6,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
@@ -21,6 +23,12 @@ def server(request: pytest.FixtureRequest) -> Generator[None]:
         for message in input:
             yield message
 
+    @server.agent()
+    async def slow_echo(input: list[Message], context: Context) -> AsyncIterator[Message]:
+        for message in input:
+            await asyncio.sleep(1)
+            yield message
+
     @server.agent()
     async def awaiter(
         input: list[Message], context: Context
@@ -31,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.3 → acp_sdk-0.9.0}/tests/e2e/test_suites/test_runs.py

@@ -5,18 +5,20 @@ from datetime import timedelta
 import pytest
 from acp_sdk.client import Client
 from acp_sdk.models import (
+    ACPError,
+    AgentName,
     ArtifactEvent,
     ErrorCode,
     Message,
     MessageAwaitResume,
     MessagePart,
     MessagePartEvent,
+    RunCancelledEvent,
     RunCompletedEvent,
     RunCreatedEvent,
     RunInProgressEvent,
     RunStatus,
 )
-from acp_sdk.models.errors import ACPError
 from acp_sdk.server import Server
 
 input = [Message(parts=[MessagePart(content="Hello!")])]
@@ -70,19 +72,35 @@ 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
 
 
 @pytest.mark.asyncio
-async def test_run_cancel(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="awaiter", input=input)
-    assert run.status == RunStatus.AWAITING
+@pytest.mark.parametrize("agent", ["awaiter", "slow_echo"])
+async def test_run_cancel(server: Server, client: Client, agent: AgentName) -> None:
+    run = await client.run_async(agent=agent, input=input)
     run = await client.run_cancel(run_id=run.run_id)
     assert run.status == RunStatus.CANCELLING
+    await asyncio.sleep(2)
+    run = await client.run_status(run_id=run.run_id)
+    assert run.status == RunStatus.CANCELLED
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("agent", ["slow_echo"])
+async def test_run_cancel_stream(server: Server, client: Client, agent: AgentName) -> None:
+    last_event = None
+    async for event in client.run_stream(agent=agent, input=input):
+        last_event = event
+        if isinstance(event, RunCreatedEvent):
+            run = await client.run_cancel(run_id=event.run.run_id)
+            assert run.status == RunStatus.CANCELLING
+    assert isinstance(last_event, RunCancelledEvent)
 
 
 @pytest.mark.asyncio

{acp_sdk-0.8.3 → acp_sdk-0.9.0}/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.8.3 → acp_sdk-0.9.0}/tests/unit/models/test_models.py

@@ -1,5 +1,8 @@
+import asyncio
+
 import pytest
-from acp_sdk.models.models import Message, MessagePart
+from acp_sdk.models.errors import ACPError, Error, ErrorCode
+from acp_sdk.models.models import Message, MessagePart, Run, RunStatus
 
 timestamp = "2021-09-09T22:02:47.89Z"
 
@@ -96,3 +99,40 @@ def test_message_add(first: Message, second: Message, result: Message) -> None:
 )
 def test_message_compress(uncompressed: Message, compressed: Message) -> None:
     assert uncompressed.compress() == compressed
+
+
+@pytest.mark.parametrize(
+    "run,error",
+    [
+        (
+            Run(agent_name="foo", status=RunStatus.CANCELLED),
+            asyncio.CancelledError,
+        ),
+        (
+            Run(
+                agent_name="foo",
+                status=RunStatus.FAILED,
+                error=Error(code=ErrorCode.SERVER_ERROR, message="Unspecified"),
+            ),
+            ACPError,
+        ),
+        (
+            Run(agent_name="foo"),
+            None,
+        ),
+        (
+            Run(agent_name="foo", status=RunStatus.IN_PROGRESS),
+            None,
+        ),
+        (
+            Run(agent_name="foo", status=RunStatus.COMPLETED),
+            None,
+        ),
+    ],
+)
+def test_run_raise_on_status_raise(run: Run, error: type[Exception] | None) -> None:
+    if error:
+        with pytest.raises(error):
+            run.raise_for_status()
+    else:
+        run.raise_for_status()

acp_sdk-0.9.0/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