acp-sdk 0.1.0rc6__py3-none-any.whl → 0.1.0rc8__py3-none-any.whl

acp_sdk/__init__.py

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

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/models/models.py

@@ -58,8 +58,8 @@ class Message(RootModel):
 
 
 AgentName = str
-SessionId = str
-RunId = str
+SessionId = uuid.UUID
+RunId = uuid.UUID
 
 
 class RunMode(str, Enum):
@@ -91,13 +91,18 @@ class AwaitResume(BaseModel):
     pass
 
 
+class Artifact(BaseModel):
+    pass
+
+
 class Run(BaseModel):
-    run_id: RunId = str(uuid.uuid4())
+    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/models/schemas.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from acp_sdk.models.models import Agent, AgentName, AwaitResume, Message, Run, RunMode, SessionId
 
@@ -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
 
 
@@ -26,6 +26,8 @@ class RunResumeRequest(BaseModel):
     await_: AwaitResume = Field(alias="await")
     mode: RunMode
 
+    model_config = ConfigDict(populate_by_name=True)
+
 
 class RunResumeResponse(Run):
     pass

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/server/app.py

@@ -1,9 +1,10 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
+from enum import Enum
 
 from fastapi import FastAPI, HTTPException, status
+from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 
@@ -23,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
@@ -36,16 +37,21 @@ 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
 
 
+class Headers(str, Enum):
+    RUN_ID = "Run-ID"
+
+
 def create_app(*agents: Agent) -> FastAPI:
     executor: ThreadPoolExecutor
 
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
         nonlocal executor
-        with ThreadPoolExecutor(max_workers=5) as exec:
+        with ThreadPoolExecutor() as exec:
             executor = exec
             yield
 
@@ -55,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)
@@ -90,31 +97,41 @@ 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)}
 
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
                     stream_sse(bundle),
+                    headers=headers,
                     media_type="text/event-stream",
                 )
             case RunMode.SYNC:
                 await bundle.join()
-                return bundle.run
+                return JSONResponse(
+                    headers=headers,
+                    content=jsonable_encoder(bundle.run),
+                )
             case RunMode.ASYNC:
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
-                    content=bundle.run.model_dump(),
+                    headers=headers,
+                    content=jsonable_encoder(bundle.run),
                 )
             case _:
                 raise NotImplementedError()
@@ -127,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(
@@ -141,7 +157,7 @@ def create_app(*agents: Agent) -> FastAPI:
             case RunMode.ASYNC:
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
-                    content=bundle.run.model_dump(),
+                    content=jsonable_encoder(bundle.run),
                 )
             case _:
                 raise NotImplementedError()
@@ -151,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
-        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump())
+        await bundle.cancel()
+        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(bundle.run))
 
     return app

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"):
-            run_logger = logging.LoggerAdapter(logger, {"run_id": self.run.run_id})
+    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/server/server.py

@@ -1,8 +1,13 @@
+import asyncio
 import inspect
-from collections.abc import AsyncGenerator, Coroutine, Generator
+import os
+from collections.abc import AsyncGenerator, Awaitable, Coroutine, Generator
 from typing import Any, Callable
 
-from acp_sdk.models import Message
+import uvicorn
+import uvicorn.config
+
+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
@@ -13,9 +18,16 @@ from acp_sdk.server.types import RunYield, RunYieldResume
 
 class Server:
     def __init__(self) -> None:
-        self.agents: list[Agent] = []
+        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:
@@ -43,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] = (
@@ -66,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))
 
@@ -81,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))
 
@@ -96,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)
 
@@ -107,11 +135,67 @@ class Server:
         return decorator
 
     def register(self, *agents: Agent) -> None:
-        self.agents.extend(agents)
+        self._agents.extend(agents)
 
-    def __call__(
-        self, configure_logger: bool = True, configure_telemetry: bool = False, **kwargs: dict[str, Any]
+    def run(
+        self,
+        configure_logger: bool = True,
+        configure_telemetry: bool = False,
+        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:
+        if self._server:
+            raise RuntimeError("The server is already running")
+
         import uvicorn
 
         if configure_logger:
@@ -119,4 +203,63 @@ class Server:
         if configure_telemetry:
             configure_telemetry_func()
 
-        uvicorn.run(create_app(*self.agents), **kwargs)
+        config = uvicorn.Config(
+            create_app(*self._agents),
+            host,
+            port,
+            uds,
+            fd,
+            loop,
+            http,
+            ws,
+            ws_max_size,
+            ws_max_queue,
+            ws_ping_interval,
+            ws_ping_timeout,
+            ws_per_message_deflate,
+            lifespan,
+            env_file,
+            log_config,
+            log_level,
+            access_log,
+            use_colors,
+            interface,
+            reload,
+            reload_dirs,
+            reload_delay,
+            reload_includes,
+            reload_excludes,
+            workers,
+            proxy_headers,
+            server_header,
+            date_header,
+            forwarded_allow_ips,
+            root_path,
+            limit_concurrency,
+            limit_max_requests,
+            backlog,
+            timeout_keep_alive,
+            timeout_notify,
+            timeout_graceful_shutdown,
+            callback_notify,
+            ssl_keyfile,
+            ssl_certfile,
+            ssl_keyfile_password,
+            ssl_version,
+            ssl_cert_reqs,
+            ssl_ca_certs,
+            ssl_ciphers,
+            headers,
+            factory,
+            h11_max_incomplete_event_size,
+        )
+        self._server = uvicorn.Server(config)
+        self._server.run()
+
+    @property
+    def should_exit(self) -> bool:
+        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

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/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/version.py

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

{acp_sdk-0.1.0rc6.dist-info → acp_sdk-0.1.0rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.1.0rc6
+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)
 ```
 
@@ -56,23 +56,19 @@ async with Client(base_url="http://localhost:8000") as client:
 The `server` submodule exposes [fastapi] application factory that makes it easy to expose any agent over ACP.
 
 ```python
-class EchoAgent(Agent):
-    @property
-    def name(self) -> str:
-        return "echo"
+server = Server()
 
-    @property
-    def description(self) -> str:
-        return "Echoes everything"
+@server.agent()
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for message in inputs:
+        await asyncio.sleep(0.5)
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield message
 
-    async def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
-        for part in input:
-            await asyncio.sleep(0.5)
-            yield {"thought": "I should echo everyting"}
-            yield Message(part)
 
-
-serve(EchoAgent())
+server.run()
 ```
 
 ➡️ Explore more in our [examples library](/python/examples).

acp_sdk-0.1.0rc8.dist-info/RECORD

@@ -0,0 +1,24 @@
+acp_sdk/__init__.py,sha256=tXdAUM9zcmdSKCAkVrOCrGcXcuVS-yuvQUoQwTe9pek,98
+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=phsFdVMdVmTcfmzUQUgqzzvq4zNvmEUgW2eL9cFJY2g,6140
+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=LrOZIWwn_6SenSwzz2JeK7Q555vzqjBKFElCifxQgnk,4107
+acp_sdk/models/schemas.py,sha256=LNs3oN1pQ4GD0ceV3-k6X6R39eu33nsAfnW6uEgOP0c,735
+acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
+acp_sdk/server/agent.py,sha256=wMwyB3Ouz361DX-RDPFD61nymoUOTvBIJt3_JU9KmOw,3297
+acp_sdk/server/app.py,sha256=Ys5EN4MzmrwrpBGvycEP5dKEIYkDZmeBMMV1Aq58AU0,5897
+acp_sdk/server/bundle.py,sha256=VUOqzBhwsADkoyPWqXSZ2KG59S3q4LMDfpFVAssnGSM,5386
+acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
+acp_sdk/server/errors.py,sha256=fWlgVsQ5hs_AXwzc-wvy6QgoDWEMRUBlSrfJfhHHMyE,2085
+acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
+acp_sdk/server/server.py,sha256=6iCJZrMfIDtqEmxqFREpPbyAiuxVxbQD73QHiFJ6KpA,9307
+acp_sdk/server/session.py,sha256=0cDr924HC5x2bBNbK9NSKVHAt5A_mi5dK8P4jP_ugq0,629
+acp_sdk/server/telemetry.py,sha256=WIEHK8syOTG9SyWi3Y-cos7CsCF5-IHGiyL9bCaUN0E,1921
+acp_sdk/server/types.py,sha256=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
+acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
+acp_sdk-0.1.0rc8.dist-info/METADATA,sha256=hrIiPuTocgUWerNeGvolLPMY1DgqFqpTshMswZr7sQw,2041
+acp_sdk-0.1.0rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.1.0rc8.dist-info/RECORD,,

acp_sdk-0.1.0rc6.dist-info/RECORD

@@ -1,22 +0,0 @@
-acp_sdk/__init__.py,sha256=XlcAbmvJfvJK5tmOFdxXP19aDwxxdG_jygsTCvXtjTk,43
-acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
-acp_sdk/client/client.py,sha256=W6iXxH65UUODnvt3tnvgdqT_pP1meZUF2HwJpWCM0BM,5029
-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=ACZPQp-wm43tdlx83hrX7QmdtBRWVXvU5bsotUOidHM,3908
-acp_sdk/models/schemas.py,sha256=a0T29vfy93uVIce3ikbd3GSTdKBokMmfXWNVRJD3Eb8,662
-acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
-acp_sdk/server/agent.py,sha256=SZfJK634d4s8fRh0u1Tc56l58XCRHAh3hq5Hcabh6tI,3442
-acp_sdk/server/app.py,sha256=7alacNo9y_f0-BjZI0dm_rzSweW-n5YiuY0hrVtEIR8,5420
-acp_sdk/server/bundle.py,sha256=ZVkIOwWfYgi-VyGYSMKr9WrG_WzYbej-LD-YPUWQdeg,4982
-acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
-acp_sdk/server/errors.py,sha256=fWlgVsQ5hs_AXwzc-wvy6QgoDWEMRUBlSrfJfhHHMyE,2085
-acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
-acp_sdk/server/server.py,sha256=H-oh-cRpo9NR7_Mdt7ECRXrGnk8mfAAb7pp94XLGoAs,4637
-acp_sdk/server/telemetry.py,sha256=EwmtUrWMYid7XHiX76V1J6CigJPa2NrzEPOX0fBoY3o,1838
-acp_sdk/server/types.py,sha256=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
-acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
-acp_sdk-0.1.0rc6.dist-info/METADATA,sha256=t5zWJsU-C67HQNzCFyo561s7epz4KQvsFjlqUIkF9xw,2147
-acp_sdk-0.1.0rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.1.0rc6.dist-info/RECORD,,