acp-sdk 0.1.0rc7__tar.gz → 0.1.0rc8__tar.gz

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.1.0rc7
+Version: 0.1.0rc8
 Summary: Agent Communication Protocol SDK
 Requires-Python: <4.0,>=3.11
 Requires-Dist: opentelemetry-api>=1.31.1
@@ -47,7 +47,7 @@ The `client` submodule exposes [httpx]() based client with simple methods for co
 
 ```python
 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", inputs=[Message(TextMessagePart(content="Howdy!"))])
     print(run.output)
 ```
 
@@ -59,13 +59,13 @@ The `server` submodule exposes [fastapi] application factory that makes it easy
 server = Server()
 
 @server.agent()
-async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for part in input:
+    for message in inputs:
         await asyncio.sleep(0.5)
         yield {"thought": "I should echo everyting"}
         await asyncio.sleep(0.5)
-        yield Message(part)
+        yield message
 
 
 server.run()

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/README.md

@@ -28,7 +28,7 @@ The `client` submodule exposes [httpx]() based client with simple methods for co
 
 ```python
 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", inputs=[Message(TextMessagePart(content="Howdy!"))])
     print(run.output)
 ```
 
@@ -40,13 +40,13 @@ The `server` submodule exposes [fastapi] application factory that makes it easy
 server = Server()
 
 @server.agent()
-async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for part in input:
+    for message in inputs:
         await asyncio.sleep(0.5)
         yield {"thought": "I should echo everyting"}
         await asyncio.sleep(0.5)
-        yield Message(part)
+        yield message
 
 
 server.run()

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/examples/clients/advanced.py

@@ -13,8 +13,8 @@ async def example() -> None:
             # Additional client configuration
         )
     ) as client:
-        run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
-        print(run.output)
+        run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
+        print(run.outputs)
 
 
 if __name__ == "__main__":

acp_sdk-0.1.0rc8/examples/clients/session.py

@@ -0,0 +1,18 @@
+import asyncio
+
+from acp_sdk.client import Client
+from acp_sdk.models import (
+    Message,
+    TextMessagePart,
+)
+
+
+async def example() -> None:
+    async with Client(base_url="http://localhost:8000") as client, client.session() as session:
+        run = await session.run_sync(agent="historian", inputs=[Message(TextMessagePart(content="Howdy!"))])
+        run = await session.run_sync(agent="historian", inputs=[Message(TextMessagePart(content="Howdy again!"))])
+        print(run.outputs)
+
+
+if __name__ == "__main__":
+    asyncio.run(example())

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/examples/clients/simple.py

@@ -9,8 +9,8 @@ from acp_sdk.models import (
 
 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!")))
-        print(run.output)
+        run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
+        print(run.outputs)
 
 
 if __name__ == "__main__":

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/examples/clients/stream.py

@@ -6,7 +6,7 @@ from acp_sdk.models import Message, TextMessagePart
 
 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", inputs=[Message(TextMessagePart(content="Howdy!"))]):
             print(event)
 
 

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/examples/servers/awaiting.py

@@ -13,11 +13,11 @@ server = Server()
 
 
 @server.agent()
-async def awaiting(input: Message, context: Context) -> AsyncGenerator[Message | Await | Any, AwaitResume]:
+async def awaiting(inputs: list[Message], context: Context) -> AsyncGenerator[Message | Await | Any, AwaitResume]:
     """Greets and awaits for more data"""
     yield Message(TextMessagePart(content="Hello!"))
     data = yield Await()
     yield Message(TextMessagePart(content=f"Thanks for {data}"))
 
 
-server()
+server.run()

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/examples/servers/echo.py

@@ -10,13 +10,13 @@ server = Server()
 
 
 @server.agent()
-async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for part in input:
+    for message in inputs:
         await asyncio.sleep(0.5)
         yield {"thought": "I should echo everyting"}
         await asyncio.sleep(0.5)
-        yield Message(part)
+        yield message
 
 
-server()
+server.run()

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.1.0rc7"
+version = "0.1.0rc8"
 description = "Agent Communication Protocol SDK"
 readme = "README.md"
 authors = []

acp_sdk-0.1.0rc8/pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+testpaths = tests/e2e
+python_files = test_*.py
+python_functions = test_*
+addopts = -v --strict-markers

acp_sdk-0.1.0rc8/src/acp_sdk/__init__.py

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

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/client/client.py

@@ -1,4 +1,6 @@
-from collections.abc import AsyncIterator
+import uuid
+from collections.abc import AsyncGenerator, AsyncIterator
+from contextlib import asynccontextmanager
 from types import TracebackType
 from typing import Self
 
@@ -14,6 +16,7 @@ from acp_sdk.models import (
     AgentReadResponse,
     AgentsListResponse,
     AwaitResume,
+    CreatedEvent,
     Error,
     Message,
     Run,
@@ -25,12 +28,20 @@ from acp_sdk.models import (
     RunMode,
     RunResumeRequest,
     RunResumeResponse,
+    SessionId,
 )
 
 
 class Client:
-    def __init__(self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None) -> None:
+    def __init__(
+        self,
+        *,
+        base_url: httpx.URL | str = "",
+        session_id: SessionId | None = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
         self.base_url = base_url
+        self.session_id = session_id
 
         self._client = self._init_client(client)
 
@@ -51,6 +62,10 @@ class Client:
     ) -> None:
         await self._client.__aexit__(exc_type, exc_value, traceback)
 
+    @asynccontextmanager
+    async def session(self, session_id: SessionId | None = None) -> AsyncGenerator[Self]:
+        yield Client(client=self._client, session_id=session_id or uuid.uuid4())
+
     async def agents(self) -> AsyncIterator[Agent]:
         response = await self._client.get("/agents")
         self._raise_error(response)
@@ -62,30 +77,51 @@ class Client:
         self._raise_error(response)
         return AgentReadResponse.model_validate(response.json())
 
-    async def run_sync(self, *, agent: AgentName, input: Message) -> Run:
+    async def run_sync(self, *, agent: AgentName, inputs: list[Message]) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.SYNC).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.SYNC,
+                session_id=self.session_id,
+            ).model_dump_json(),
         )
         self._raise_error(response)
-        return RunCreateResponse.model_validate(response.json())
+        response = RunCreateResponse.model_validate(response.json())
+        self._set_session(response)
+        return response
 
-    async def run_async(self, *, agent: AgentName, input: Message) -> Run:
+    async def run_async(self, *, agent: AgentName, inputs: list[Message]) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.ASYNC).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.ASYNC,
+                session_id=self.session_id,
+            ).model_dump_json(),
         )
         self._raise_error(response)
-        return RunCreateResponse.model_validate(response.json())
+        response = RunCreateResponse.model_validate(response.json())
+        self._set_session(response)
+        return response
 
-    async def run_stream(self, *, agent: AgentName, input: Message) -> AsyncIterator[RunEvent]:
+    async def run_stream(self, *, agent: AgentName, inputs: list[Message]) -> AsyncIterator[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.STREAM).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.STREAM,
+                session_id=self.session_id,
+            ).model_dump_json(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
+                if isinstance(event, CreatedEvent):
+                    self._set_session(event.run)
                 yield event
 
     async def run_status(self, *, run_id: RunId) -> Run:
@@ -137,3 +173,6 @@ class Client:
             response.raise_for_status()
         except httpx.HTTPError:
             raise ACPError(Error.model_validate(response.json()))
+
+    def _set_session(self, run: Run) -> None:
+        self.session_id = run.session_id

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/models/models.py

@@ -91,13 +91,18 @@ class AwaitResume(BaseModel):
     pass
 
 
+class Artifact(BaseModel):
+    pass
+
+
 class Run(BaseModel):
     run_id: RunId = Field(default_factory=uuid.uuid4)
     agent_name: AgentName
     session_id: SessionId | None = None
     status: RunStatus = RunStatus.CREATED
     await_: Await | None = Field(None, alias="await")
-    output: Message | None = None
+    outputs: list[Message] = []
+    artifacts: list[Artifact] = []
     error: Error | None = None
 
     model_config = ConfigDict(populate_by_name=True)
@@ -117,6 +122,11 @@ class MessageEvent(BaseModel):
     message: Message
 
 
+class ArtifactEvent(BaseModel):
+    type: Literal["artifact"] = "artifact"
+    artifact: Artifact
+
+
 class AwaitEvent(BaseModel):
     type: Literal["await"] = "await"
     await_: Await | None = Field(alias="await")

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/models/schemas.py

@@ -14,7 +14,7 @@ class AgentReadResponse(Agent):
 class RunCreateRequest(BaseModel):
     agent_name: AgentName
     session_id: SessionId | None = None
-    input: Message
+    inputs: list[Message]
     mode: RunMode = RunMode.SYNC
 
 

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/agent.py

@@ -31,19 +31,14 @@ class Agent(abc.ABC):
 
     @abc.abstractmethod
     def run(
-        self, input: Message, context: Context
+        self, inputs: list[Message], context: Context
     ) -> (
         AsyncGenerator[RunYield, RunYieldResume] | Generator[RunYield, RunYieldResume] | Coroutine[RunYield] | RunYield
     ):
         pass
 
-    async def session(self, session_id: SessionId | None) -> SessionId | None:
-        if session_id:
-            raise NotImplementedError()
-        return None
-
     async def execute(
-        self, input: Message, session_id: SessionId | None, executor: ThreadPoolExecutor
+        self, inputs: list[Message], session_id: SessionId | None, executor: ThreadPoolExecutor
     ) -> AsyncGenerator[RunYield, RunYieldResume]:
         yield_queue: janus.Queue[RunYield] = janus.Queue()
         yield_resume_queue: janus.Queue[RunYieldResume] = janus.Queue()
@@ -53,13 +48,13 @@ class Agent(abc.ABC):
         )
 
         if inspect.isasyncgenfunction(self.run):
-            run = asyncio.create_task(self._run_async_gen(input, context))
+            run = asyncio.create_task(self._run_async_gen(inputs, context))
         elif inspect.iscoroutinefunction(self.run):
-            run = asyncio.create_task(self._run_coro(input, context))
+            run = asyncio.create_task(self._run_coro(inputs, context))
         elif inspect.isgeneratorfunction(self.run):
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, input, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, inputs, context)
         else:
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, input, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, inputs, context)
 
         try:
             while True:

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/app.py

@@ -1,4 +1,3 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
@@ -25,7 +24,7 @@ from acp_sdk.models import (
     RunReadResponse,
     RunResumeRequest,
     RunResumeResponse,
-    RunStatus,
+    SessionId,
 )
 from acp_sdk.models.errors import ACPError
 from acp_sdk.server.agent import Agent
@@ -38,6 +37,7 @@ from acp_sdk.server.errors import (
     http_exception_handler,
     validation_exception_handler,
 )
+from acp_sdk.server.session import Session
 from acp_sdk.server.utils import stream_sse
 
 
@@ -51,7 +51,7 @@ def create_app(*agents: Agent) -> FastAPI:
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
         nonlocal executor
-        with ThreadPoolExecutor(max_workers=5) as exec:
+        with ThreadPoolExecutor() as exec:
             executor = exec
             yield
 
@@ -61,6 +61,7 @@ def create_app(*agents: Agent) -> FastAPI:
 
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
     runs: dict[RunId, RunBundle] = {}
+    sessions: dict[SessionId, Session] = {}
 
     app.exception_handler(ACPError)(acp_error_handler)
     app.exception_handler(StarletteHTTPException)(http_exception_handler)
@@ -96,17 +97,20 @@ def create_app(*agents: Agent) -> FastAPI:
     @app.post("/runs")
     async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
+
+        session = sessions.get(request.session_id, Session()) if request.session_id else Session()
+        nonlocal executor
         bundle = RunBundle(
             agent=agent,
-            run=Run(
-                agent_name=agent.name,
-                session_id=request.session_id,
-            ),
+            run=Run(agent_name=agent.name, session_id=session.id),
+            inputs=request.inputs,
+            history=list(session.history()),
+            executor=executor,
         )
+        session.append(bundle)
 
-        nonlocal executor
-        bundle.task = asyncio.create_task(bundle.execute(request.input, executor=executor))
         runs[bundle.run.run_id] = bundle
+        sessions[session.id] = session
 
         headers = {Headers.RUN_ID: str(bundle.run.run_id)}
 
@@ -140,8 +144,7 @@ def create_app(*agents: Agent) -> FastAPI:
     @app.post("/runs/{run_id}")
     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_)
+        await bundle.resume(request.await_)
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
@@ -164,11 +167,10 @@ def create_app(*agents: Agent) -> FastAPI:
         bundle = find_run_bundle(run_id)
         if bundle.run.status.is_terminal:
             raise HTTPException(
-                status_code=403,
-                detail=f"Run with terminal status {bundle.run.status} can't be cancelled",
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Run in terminal status {bundle.run.status} can't be cancelled",
             )
-        bundle.task.cancel()
-        bundle.run.status = RunStatus.CANCELLING
+        await bundle.cancel()
         return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(bundle.run))
 
     return app

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/bundle.py

@@ -3,11 +3,12 @@ import logging
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 
-from opentelemetry import trace
 from pydantic import ValidationError
 
 from acp_sdk.models import (
     AnyModel,
+    Artifact,
+    ArtifactEvent,
     Await,
     AwaitEvent,
     AwaitResume,
@@ -27,20 +28,25 @@ from acp_sdk.models import (
 from acp_sdk.models.errors import ErrorCode
 from acp_sdk.server.agent import Agent
 from acp_sdk.server.logging import logger
+from acp_sdk.server.telemetry import get_tracer
 
 
 class RunBundle:
-    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None) -> None:
+    def __init__(
+        self, *, agent: Agent, run: Run, inputs: list[Message], history: list[Message], executor: ThreadPoolExecutor
+    ) -> None:
         self.agent = agent
         self.run = run
-        self.task = task
+        self.inputs = inputs
+        self.history = history
 
         self.stream_queue: asyncio.Queue[RunEvent] = asyncio.Queue()
-        self.composed_message = Message()
 
         self.await_queue: asyncio.Queue[AwaitResume] = asyncio.Queue(maxsize=1)
         self.await_or_terminate_event = asyncio.Event()
 
+        self.task = asyncio.create_task(self._execute(inputs, executor=executor))
+
     async def stream(self) -> AsyncGenerator[RunEvent]:
         while True:
             event = await self.stream_queue.get()
@@ -64,20 +70,27 @@ class RunBundle:
     async def resume(self, resume: AwaitResume) -> None:
         self.stream_queue = asyncio.Queue()
         await self.await_queue.put(resume)
+        self.run.status = RunStatus.IN_PROGRESS
+        self.run.await_ = None
+
+    async def cancel(self) -> None:
+        self.task.cancel()
+        self.run.status = RunStatus.CANCELLING
+        self.run.await_ = None
 
     async def join(self) -> None:
         await self.await_or_terminate_event.wait()
 
-    async def execute(self, input: Message, *, executor: ThreadPoolExecutor) -> None:
-        with trace.get_tracer(__name__).start_as_current_span("execute"):
+    async def _execute(self, inputs: list[Message], *, executor: ThreadPoolExecutor) -> None:
+        with get_tracer().start_as_current_span("run"):
             run_logger = logging.LoggerAdapter(logger, {"run_id": str(self.run.run_id)})
 
-            await self.emit(CreatedEvent(run=self.run))
             try:
-                self.run.session_id = await self.agent.session(self.run.session_id)
-                run_logger.info("Session loaded")
+                await self.emit(CreatedEvent(run=self.run))
 
-                generator = self.agent.execute(input=input, session_id=self.run.session_id, executor=executor)
+                generator = self.agent.execute(
+                    inputs=self.history + inputs, session_id=self.run.session_id, executor=executor
+                )
                 run_logger.info("Run started")
 
                 self.run.status = RunStatus.IN_PROGRESS
@@ -87,8 +100,11 @@ class RunBundle:
                 while True:
                     next = await generator.asend(await_resume)
                     if isinstance(next, Message):
-                        self.composed_message += next
+                        self.run.outputs.append(next)
                         await self.emit(MessageEvent(message=next))
+                    elif isinstance(next, Artifact):
+                        self.run.artifacts.append(next)
+                        await self.emit(ArtifactEvent(artifact=next))
                     elif isinstance(next, Await):
                         self.run.await_ = next
                         self.run.status = RunStatus.AWAITING
@@ -103,7 +119,6 @@ class RunBundle:
                         )
                         run_logger.info("Run awaited")
                         await_resume = await self.await_()
-                        self.run.status = RunStatus.IN_PROGRESS
                         await self.emit(InProgressEvent(run=self.run))
                         run_logger.info("Run resumed")
                     else:
@@ -113,7 +128,6 @@ class RunBundle:
                         except ValidationError:
                             raise TypeError("Invalid yield")
             except StopAsyncIteration:
-                self.run.output = self.composed_message
                 self.run.status = RunStatus.COMPLETED
                 await self.emit(CompletedEvent(run=self.run))
                 run_logger.info("Run completed")
@@ -126,6 +140,7 @@ class RunBundle:
                 self.run.status = RunStatus.FAILED
                 await self.emit(FailedEvent(run=self.run))
                 run_logger.exception("Run failed")
+                raise
             finally:
                 self.await_or_terminate_event.set()
                 await self.stream_queue.put(None)

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/server.py

@@ -7,7 +7,7 @@ from typing import Any, Callable
 import uvicorn
 import uvicorn.config
 
-from acp_sdk.models import Message
+from acp_sdk.models import Message, Metadata
 from acp_sdk.server.agent import Agent
 from acp_sdk.server.app import create_app
 from acp_sdk.server.context import Context
@@ -21,7 +21,13 @@ class Server:
         self._agents: list[Agent] = []
         self._server: uvicorn.Server | None = None
 
-    def agent(self, name: str | None = None, description: str | None = None) -> Callable:
+    def agent(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        *,
+        metadata: Metadata | None = None,
+    ) -> Callable:
         """Decorator to register an agent."""
 
         def decorator(fn: Callable) -> Callable:
@@ -49,6 +55,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
                         try:
                             gen: AsyncGenerator[RunYield, RunYieldResume] = (
@@ -72,6 +82,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
                         return await (fn(input, context) if has_context_param else fn(input))
 
@@ -87,6 +101,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
                         yield from (fn(input, context) if has_context_param else fn(input))
 
@@ -102,6 +120,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     def run(self, input: Message, context: Context) -> RunYield:
                         return fn(input, context) if has_context_param else fn(input)
 

acp_sdk-0.1.0rc8/src/acp_sdk/server/session.py

@@ -0,0 +1,21 @@
+import uuid
+from collections.abc import Iterator
+
+from acp_sdk.models import Message, SessionId
+from acp_sdk.models.models import RunStatus
+from acp_sdk.server.bundle import RunBundle
+
+
+class Session:
+    def __init__(self) -> None:
+        self.id: SessionId = uuid.uuid4()
+        self.bundles: list[RunBundle] = []
+
+    def append(self, bundle: RunBundle) -> None:
+        self.bundles.append(bundle)
+
+    def history(self) -> Iterator[Message]:
+        for bundle in self.bundles:
+            if bundle.run.status == RunStatus.COMPLETED:
+                yield from bundle.inputs
+                yield from bundle.run.outputs

{acp_sdk-0.1.0rc7 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/telemetry.py

@@ -1,5 +1,4 @@
 import logging
-from importlib.metadata import version
 
 from opentelemetry import metrics, trace
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
@@ -18,6 +17,8 @@ from opentelemetry.sdk.resources import (
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
+from acp_sdk.version import __version__
+
 root_logger = logging.getLogger()
 
 
@@ -28,7 +29,7 @@ def configure_telemetry() -> None:
         attributes={
             SERVICE_NAME: "acp-server",
             SERVICE_NAMESPACE: "acp",
-            SERVICE_VERSION: version("acp-sdk"),
+            SERVICE_VERSION: __version__,
         }
     )
 
@@ -50,3 +51,7 @@ def configure_telemetry() -> None:
     processor = BatchLogRecordProcessor(OTLPLogExporter())
     logger_provider.add_log_record_processor(processor)
     root_logger.addHandler(LoggingHandler(logger_provider=logger_provider))
+
+
+def get_tracer() -> trace.Tracer:
+    return trace.get_tracer("acp-sdk", __version__)

acp_sdk-0.1.0rc8/src/acp_sdk/version.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("acp-sdk")

acp_sdk-0.1.0rc8/tests/conftest.py

@@ -0,0 +1,4 @@
+pytest_plugins = [
+    "e2e.fixtures.client",
+    "e2e.fixtures.server",
+]

acp_sdk-0.1.0rc8/tests/e2e/config.py

@@ -0,0 +1,2 @@
+class Config:
+    PORT = 8000

acp_sdk-0.1.0rc8/tests/e2e/fixtures/client.py

@@ -0,0 +1,12 @@
+from collections.abc import AsyncIterator
+
+import pytest_asyncio
+from acp_sdk.client import Client
+
+from e2e.config import Config
+
+
+@pytest_asyncio.fixture
+async def client() -> AsyncIterator[Client]:
+    async with Client(base_url=f"http://localhost:{Config.PORT}") as client:
+        yield client

acp_sdk-0.1.0rc8/tests/e2e/fixtures/server.py

@@ -0,0 +1,38 @@
+import time
+from collections.abc import AsyncGenerator, AsyncIterator, Generator
+from threading import Thread
+
+import pytest
+from acp_sdk.models import Await, AwaitResume, Message, TextMessagePart
+from acp_sdk.server import Context, Server
+
+from e2e.config import Config
+
+
+@pytest.fixture(scope="module")
+def server() -> Generator[None]:
+    server = Server()
+
+    @server.agent()
+    async def echo(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+        for message in inputs:
+            yield message
+
+    @server.agent()
+    async def awaiter(inputs: list[Message], context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
+        yield Await()
+        yield Message(TextMessagePart(content="empty"))
+
+    @server.agent()
+    async def failer(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+        raise RuntimeError("Whoops")
+
+    thread = Thread(target=server.run, kwargs={"port": Config.PORT}, daemon=True)
+    thread.start()
+
+    time.sleep(1)
+
+    yield server
+
+    server.should_exit = True
+    thread.join(timeout=2)

acp_sdk-0.1.0rc8/tests/e2e/test_suites/test_runs.py

@@ -0,0 +1,89 @@
+import pytest
+from acp_sdk.client import Client
+from acp_sdk.models import AwaitResume, CompletedEvent, CreatedEvent, Message, RunStatus, TextMessagePart
+from acp_sdk.models.models import InProgressEvent
+from acp_sdk.server import Server
+
+inputs = [Message(TextMessagePart(content="Hello!"))]
+
+
+@pytest.mark.asyncio
+async def test_run_sync(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="echo", inputs=inputs)
+    assert run.status == RunStatus.COMPLETED
+    assert run.outputs == inputs
+
+
+@pytest.mark.asyncio
+async def test_run_async(server: Server, client: Client) -> None:
+    run = await client.run_async(agent="echo", inputs=inputs)
+    assert run.status == RunStatus.CREATED
+
+
+@pytest.mark.asyncio
+async def test_run_stream(server: Server, client: Client) -> None:
+    event_stream = [event async for event in client.run_stream(agent="echo", inputs=inputs)]
+    assert isinstance(event_stream[0], CreatedEvent)
+    assert isinstance(event_stream[-1], CompletedEvent)
+
+
+@pytest.mark.asyncio
+async def test_run_status(server: Server, client: Client) -> None:
+    run = await client.run_async(agent="echo", inputs=inputs)
+    while run.status in (RunStatus.CREATED, RunStatus.IN_PROGRESS):
+        run = await client.run_status(run_id=run.run_id)
+    assert run.status == RunStatus.COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_failure(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="failer", inputs=inputs)
+    assert run.status == RunStatus.FAILED
+
+
+@pytest.mark.asyncio
+async def test_run_cancel(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="awaiter", inputs=inputs)
+    assert run.status == RunStatus.AWAITING
+    run = await client.run_cancel(run_id=run.run_id)
+    assert run.status == RunStatus.CANCELLING
+
+
+@pytest.mark.asyncio
+async def test_run_resume_sync(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="awaiter", inputs=inputs)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    run = await client.run_resume_sync(run_id=run.run_id, await_=AwaitResume())
+    assert run.status == RunStatus.COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_run_resume_async(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="awaiter", inputs=inputs)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    run = await client.run_resume_async(run_id=run.run_id, await_=AwaitResume())
+    assert run.status == RunStatus.IN_PROGRESS
+
+
+@pytest.mark.asyncio
+async def test_run_resume_stream(server: Server, client: Client) -> None:
+    run = await client.run_sync(agent="awaiter", inputs=inputs)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    event_stream = [event async for event in client.run_resume_stream(run_id=run.run_id, await_=AwaitResume())]
+    assert isinstance(event_stream[0], InProgressEvent)
+    assert isinstance(event_stream[-1], CompletedEvent)
+
+
+@pytest.mark.asyncio
+async def test_run_session(server: Server, client: Client) -> None:
+    async with client.session() as session:
+        run = await session.run_sync(agent="echo", inputs=inputs)
+        assert run.outputs == inputs
+        run = await session.run_sync(agent="echo", inputs=inputs)
+        assert run.outputs == inputs + inputs + inputs

acp_sdk-0.1.0rc7/examples/servers/multi-echo.py

@@ -1,57 +0,0 @@
-from collections.abc import AsyncGenerator, Generator
-
-from acp_sdk.models import (
-    Message,
-)
-from acp_sdk.server import Agent, Context, RunYield, RunYieldResume, Server
-
-server = Server()
-
-
-@server.agent()
-async def async_gen_echo(input: Message) -> AsyncGenerator[RunYield, RunYieldResume]:
-    """Echoes everything"""
-    yield {"thought": "I should echo everyting"}
-    yield input
-
-
-@server.agent()
-async def async_echo(input: Message, context: Context) -> RunYield:
-    """Echoes everything"""
-    await context.yield_async({"thought": "I should echo everyting"})
-    return input
-
-
-@server.agent()
-def gen_echo(input: Message) -> Generator[RunYield, RunYieldResume]:
-    """Echoes everything"""
-    yield {"thought": "I should echo everyting"}
-    yield input
-
-
-@server.agent()
-def sync_echo(input: Message, context: Context) -> RunYield:
-    """Echoes everything"""
-    context.yield_sync({"thought": "I should echo everyting"})
-    return input
-
-
-class EchoAgent(Agent):
-    @property
-    def name(self) -> str:
-        return "instance_echo"
-
-    @property
-    def description(self) -> str:
-        return "Echoes everything"
-
-    async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
-        """Echoes everything"""
-        yield {"thought": "I should echo everyting"}
-        yield input
-
-
-server.register(EchoAgent())
-
-
-server()

acp_sdk-0.1.0rc7/src/acp_sdk/__init__.py

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

acp_sdk-0.1.0rc7/tests/test_e2e.py

@@ -1,113 +0,0 @@
-import time
-from collections.abc import AsyncGenerator, AsyncIterator, Generator
-from threading import Thread
-
-import pytest
-import pytest_asyncio
-from acp_sdk.client import Client
-from acp_sdk.models import Await, AwaitResume, CompletedEvent, CreatedEvent, Message, RunStatus, TextMessagePart
-from acp_sdk.models.models import InProgressEvent
-from acp_sdk.server import Context, Server
-
-PORT = 8000
-
-
-@pytest.fixture
-def server() -> Generator[None]:
-    server = Server()
-
-    @server.agent()
-    async def echo(input: Message, context: Context) -> AsyncIterator[Message]:
-        yield input
-
-    @server.agent()
-    async def awaiter(input: Message, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
-        yield Await()
-        yield Message(TextMessagePart(content="empty"))
-
-    thread = Thread(target=server.run, kwargs={"port": PORT}, daemon=True)
-    thread.start()
-
-    time.sleep(1)
-
-    yield
-
-    server.should_exit = True
-    thread.join(timeout=2)
-
-
-@pytest_asyncio.fixture
-async def client() -> AsyncIterator[Client]:
-    async with Client(base_url=f"http://localhost:{PORT}") as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_run_sync(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-    run = await client.run_sync(agent="echo", input=input)
-    assert run.status == RunStatus.COMPLETED
-    assert run.output == input
-
-
-@pytest.mark.asyncio
-async def test_run_async(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-    run = await client.run_async(agent="echo", input=input)
-    assert run.status == RunStatus.CREATED
-    assert run.output is None
-
-
-@pytest.mark.asyncio
-async def test_run_stream(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-    event_stream = [event async for event in client.run_stream(agent="echo", input=input)]
-    assert isinstance(event_stream[0], CreatedEvent)
-    assert isinstance(event_stream[-1], CompletedEvent)
-
-
-@pytest.mark.asyncio
-async def test_run_status(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-    run = await client.run_async(agent="echo", input=input)
-    while run.status in (RunStatus.CREATED, RunStatus.IN_PROGRESS):
-        run = await client.run_status(run_id=run.run_id)
-    assert run.status == RunStatus.COMPLETED
-
-
-@pytest.mark.asyncio
-async def test_run_resume_sync(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-
-    run = await client.run_sync(agent="awaiter", input=input)
-    assert run.status == RunStatus.AWAITING
-    assert run.await_ is not None
-
-    run = await client.run_resume_sync(run_id=run.run_id, await_=AwaitResume())
-    assert run.status == RunStatus.COMPLETED
-    assert run.output is not None
-
-
-@pytest.mark.asyncio
-async def test_run_resume_async(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-
-    run = await client.run_sync(agent="awaiter", input=input)
-    assert run.status == RunStatus.AWAITING
-    assert run.await_ is not None
-
-    run = await client.run_resume_async(run_id=run.run_id, await_=AwaitResume())
-    assert run.status == RunStatus.AWAITING
-
-
-@pytest.mark.asyncio
-async def test_run_resume_stream(server: Server, client: Client) -> None:
-    input = Message(TextMessagePart(content="Hello!"))
-
-    run = await client.run_sync(agent="awaiter", input=input)
-    assert run.status == RunStatus.AWAITING
-    assert run.await_ is not None
-
-    event_stream = [event async for event in client.run_resume_stream(run_id=run.run_id, await_=AwaitResume())]
-    assert isinstance(event_stream[0], InProgressEvent)
-    assert isinstance(event_stream[-1], CompletedEvent)