acp-sdk 0.1.0rc7__py3-none-any.whl → 0.2.0__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
 
@@ -15,22 +17,31 @@ from acp_sdk.models import (
     AgentsListResponse,
     AwaitResume,
     Error,
+    Event,
     Message,
     Run,
     RunCancelResponse,
+    RunCreatedEvent,
     RunCreateRequest,
     RunCreateResponse,
-    RunEvent,
     RunId,
     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[Event]:
         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, RunCreatedEvent):
+                    self._set_session(event.run)
                 yield event
 
     async def run_status(self, *, run_id: RunId) -> Run:
@@ -114,7 +150,7 @@ class Client:
         self._raise_error(response)
         return RunResumeResponse.model_validate(response.json())
 
-    async def run_resume_stream(self, *, run_id: RunId, await_: AwaitResume) -> AsyncIterator[RunEvent]:
+    async def run_resume_stream(self, *, run_id: RunId, await_: AwaitResume) -> AsyncIterator[Event]:
         async with aconnect_sse(
             self._client,
             "POST",
@@ -127,9 +163,9 @@ class Client:
     async def _validate_stream(
         self,
         event_source: EventSource,
-    ) -> AsyncIterator[RunEvent]:
+    ) -> AsyncIterator[Event]:
         async for event in event_source.aiter_sse():
-            event = TypeAdapter(RunEvent).validate_json(event.data)
+            event = TypeAdapter(Event).validate_json(event.data)
             yield event
 
     def _raise_error(self, response: httpx.Response) -> None:
@@ -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

@@ -1,9 +1,8 @@
 import uuid
-from collections.abc import Iterator
 from enum import Enum
-from typing import Any, Literal, Union
+from typing import Any, Literal, Optional, Union
 
-from pydantic import AnyUrl, BaseModel, ConfigDict, Field, RootModel
+from pydantic import AnyUrl, BaseModel, ConfigDict, Field
 
 from acp_sdk.models.errors import Error
 
@@ -16,45 +15,38 @@ class AnyModel(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
-class MessagePartBase(BaseModel):
-    type: Literal["text", "image", "artifact"]
+class MessagePart(BaseModel):
+    name: Optional[str] = None
+    content_type: str
+    content: Optional[str] = None
+    content_encoding: Optional[Literal["plain", "base64"]] = "plain"
+    content_url: Optional[AnyUrl] = None
 
+    model_config = ConfigDict(extra="forbid")
 
-class TextMessagePart(MessagePartBase):
-    type: Literal["text"] = "text"
-    content: str
+    def model_post_init(self, __context: Any) -> None:
+        if self.content is None and self.content_url is None:
+            raise ValueError("Either content or content_url must be provided")
+        if self.content is not None and self.content_url is not None:
+            raise ValueError("Only one of content or content_url can be provided")
 
 
-class ImageMessagePart(MessagePartBase):
-    type: Literal["image"] = "image"
-    content_url: AnyUrl
-
-
-class ArtifactMessagePart(MessagePartBase):
-    type: Literal["artifact"] = "artifact"
+class Artifact(MessagePart):
     name: str
-    content_url: AnyUrl
-
-
-MessagePart = Union[TextMessagePart, ImageMessagePart, ArtifactMessagePart]
 
 
-class Message(RootModel):
-    root: list[MessagePart]
-
-    def __init__(self, *items: MessagePart) -> None:
-        super().__init__(root=list(items))
-
-    def __iter__(self) -> Iterator[MessagePart]:
-        return iter(self.root)
+class Message(BaseModel):
+    parts: list[MessagePart]
 
     def __add__(self, other: "Message") -> "Message":
         if not isinstance(other, Message):
             raise TypeError(f"Cannot concatenate Message with {type(other).__name__}")
-        return Message(*(self.root + other.root))
+        return Message(*(self.parts + other.parts))
 
     def __str__(self) -> str:
-        return "".join(str(part) for part in self.root if isinstance(part, TextMessagePart))
+        return "".join(
+            part.content for part in self.parts if part.content is not None and part.content_type == "text/plain"
+        )
 
 
 AgentName = str
@@ -83,7 +75,7 @@ class RunStatus(str, Enum):
         return self in terminal_states
 
 
-class Await(BaseModel):
+class AwaitRequest(BaseModel):
     type: Literal["placeholder"] = "placeholder"
 
 
@@ -96,41 +88,34 @@ class Run(BaseModel):
     agent_name: AgentName
     session_id: SessionId | None = None
     status: RunStatus = RunStatus.CREATED
-    await_: Await | None = Field(None, alias="await")
-    output: Message | None = None
+    await_request: AwaitRequest | None = None
+    outputs: list[Message] = []
     error: Error | None = None
 
-    model_config = ConfigDict(populate_by_name=True)
 
-    def model_dump_json(
-        self,
-        **kwargs: dict[str, Any],
-    ) -> str:
-        return super().model_dump_json(
-            by_alias=True,
-            **kwargs,
-        )
+class MessageCreatedEvent(BaseModel):
+    type: Literal["message.created"] = "message.created"
+    message: Message
+
+
+class MessagePartEvent(BaseModel):
+    type: Literal["message.part"] = "message.part"
+    part: MessagePart
+
 
+class ArtifactEvent(BaseModel):
+    type: Literal["message.part"] = "message.part"
+    part: Artifact
 
-class MessageEvent(BaseModel):
-    type: Literal["message"] = "message"
+
+class MessageCompletedEvent(BaseModel):
+    type: Literal["message.completed"] = "message.completed"
     message: Message
 
 
 class AwaitEvent(BaseModel):
     type: Literal["await"] = "await"
-    await_: Await | None = Field(alias="await")
-
-    model_config = ConfigDict(populate_by_name=True)
-
-    def model_dump_json(
-        self,
-        **kwargs: dict[str, Any],
-    ) -> str:
-        return super().model_dump_json(
-            by_alias=True,
-            **kwargs,
-        )
+    await_request: AwaitRequest | None = None
 
 
 class GenericEvent(BaseModel):
@@ -138,40 +123,44 @@ class GenericEvent(BaseModel):
     generic: AnyModel
 
 
-class CreatedEvent(BaseModel):
-    type: Literal["created"] = "created"
+class RunCreatedEvent(BaseModel):
+    type: Literal["run.created"] = "run.created"
     run: Run
 
 
-class InProgressEvent(BaseModel):
-    type: Literal["in-progress"] = "in-progress"
+class RunInProgressEvent(BaseModel):
+    type: Literal["run.in-progress"] = "run.in-progress"
     run: Run
 
 
-class FailedEvent(BaseModel):
-    type: Literal["failed"] = "failed"
+class RunFailedEvent(BaseModel):
+    type: Literal["run.failed"] = "run.failed"
     run: Run
 
 
-class CancelledEvent(BaseModel):
-    type: Literal["cancelled"] = "cancelled"
+class RunCancelledEvent(BaseModel):
+    type: Literal["run.cancelled"] = "run.cancelled"
     run: Run
 
 
-class CompletedEvent(BaseModel):
-    type: Literal["completed"] = "completed"
+class RunCompletedEvent(BaseModel):
+    type: Literal["run.completed"] = "run.completed"
     run: Run
 
 
-RunEvent = Union[
-    CreatedEvent,
-    InProgressEvent,
-    MessageEvent,
+Event = Union[
+    RunCreatedEvent,
+    RunInProgressEvent,
+    MessageCreatedEvent,
+    ArtifactEvent,
+    MessagePartEvent,
+    MessageCompletedEvent,
     AwaitEvent,
     GenericEvent,
-    CancelledEvent,
-    FailedEvent,
-    CompletedEvent,
+    RunCancelledEvent,
+    RunFailedEvent,
+    RunCompletedEvent,
+    MessagePartEvent,
 ]
 
 

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

@@ -1,4 +1,5 @@
 from acp_sdk.server.agent import Agent as Agent
+from acp_sdk.server.agent import agent as agent
 from acp_sdk.server.app import create_app as create_app
 from acp_sdk.server.context import Context as Context
 from acp_sdk.server.server import Server as Server

acp_sdk/server/agent.py

@@ -3,6 +3,7 @@ import asyncio
 import inspect
 from collections.abc import AsyncGenerator, Coroutine, Generator
 from concurrent.futures import ThreadPoolExecutor
+from typing import Callable
 
 import janus
 
@@ -31,19 +32,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 +49,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:
@@ -103,3 +99,80 @@ class Agent(abc.ABC):
             context.yield_sync(self.run(input, context))
         finally:
             context.shutdown()
+
+
+def agent(
+    name: str | None = None,
+    description: str | None = None,
+    *,
+    metadata: Metadata | None = None,
+) -> Callable[[Callable], Agent]:
+    """Decorator to create an agent."""
+
+    def decorator(fn: Callable) -> Agent:
+        signature = inspect.signature(fn)
+        parameters = list(signature.parameters.values())
+
+        if len(parameters) == 0:
+            raise TypeError("The agent function must have at least 'input' argument")
+        if len(parameters) > 2:
+            raise TypeError("The agent function must have only 'input' and 'context' arguments")
+        if len(parameters) == 2 and parameters[1].name != "context":
+            raise TypeError("The second argument of the agent function must be 'context'")
+
+        has_context_param = len(parameters) == 2
+
+        class DecoratorAgentBase(Agent):
+            @property
+            def name(self) -> str:
+                return name or fn.__name__
+
+            @property
+            def description(self) -> str:
+                return description or fn.__doc__ or ""
+
+            @property
+            def metadata(self) -> Metadata:
+                return metadata or Metadata()
+
+        agent: Agent
+        if inspect.isasyncgenfunction(fn):
+
+            class AsyncGenDecoratorAgent(DecoratorAgentBase):
+                async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+                    try:
+                        gen: AsyncGenerator[RunYield, RunYieldResume] = (
+                            fn(input, context) if has_context_param else fn(input)
+                        )
+                        value = None
+                        while True:
+                            value = yield await gen.asend(value)
+                    except StopAsyncIteration:
+                        pass
+
+            agent = AsyncGenDecoratorAgent()
+        elif inspect.iscoroutinefunction(fn):
+
+            class CoroDecoratorAgent(DecoratorAgentBase):
+                async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
+                    return await (fn(input, context) if has_context_param else fn(input))
+
+            agent = CoroDecoratorAgent()
+        elif inspect.isgeneratorfunction(fn):
+
+            class GenDecoratorAgent(DecoratorAgentBase):
+                def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
+                    yield from (fn(input, context) if has_context_param else fn(input))
+
+            agent = GenDecoratorAgent()
+        else:
+
+            class FuncDecoratorAgent(DecoratorAgentBase):
+                def run(self, input: Message, context: Context) -> RunYield:
+                    return fn(input, context) if has_context_param else fn(input)
+
+            agent = FuncDecoratorAgent()
+
+        return agent
+
+    return decorator

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

@@ -3,45 +3,51 @@ 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,
-    Await,
     AwaitEvent,
+    AwaitRequest,
     AwaitResume,
-    CancelledEvent,
-    CompletedEvent,
-    CreatedEvent,
     Error,
-    FailedEvent,
+    Event,
     GenericEvent,
-    InProgressEvent,
     Message,
-    MessageEvent,
+    MessageCreatedEvent,
+    MessagePartEvent,
     Run,
-    RunEvent,
+    RunCancelledEvent,
+    RunCompletedEvent,
+    RunCreatedEvent,
+    RunFailedEvent,
+    RunInProgressEvent,
     RunStatus,
 )
 from acp_sdk.models.errors import ErrorCode
+from acp_sdk.models.models import MessageCompletedEvent, MessagePart
 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.stream_queue: asyncio.Queue[Event] = asyncio.Queue()
 
         self.await_queue: asyncio.Queue[AwaitResume] = asyncio.Queue(maxsize=1)
         self.await_or_terminate_event = asyncio.Event()
 
-    async def stream(self) -> AsyncGenerator[RunEvent]:
+        self.task = asyncio.create_task(self._execute(inputs, executor=executor))
+
+    async def stream(self) -> AsyncGenerator[Event]:
         while True:
             event = await self.stream_queue.get()
             if event is None:
@@ -49,7 +55,7 @@ class RunBundle:
             yield event
             self.stream_queue.task_done()
 
-    async def emit(self, event: RunEvent) -> None:
+    async def emit(self, event: Event) -> None:
         await self.stream_queue.put(event)
 
     async def await_(self) -> AwaitResume:
@@ -64,33 +70,55 @@ 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_request = None
+
+    async def cancel(self) -> None:
+        self.task.cancel()
+        self.run.status = RunStatus.CANCELLING
+        self.run.await_request = 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))
+            in_message = False
             try:
-                self.run.session_id = await self.agent.session(self.run.session_id)
-                run_logger.info("Session loaded")
+                await self.emit(RunCreatedEvent(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
-                await self.emit(InProgressEvent(run=self.run))
+                await self.emit(RunInProgressEvent(run=self.run))
 
                 await_resume = None
                 while True:
                     next = await generator.asend(await_resume)
-                    if isinstance(next, Message):
-                        self.composed_message += next
-                        await self.emit(MessageEvent(message=next))
-                    elif isinstance(next, Await):
-                        self.run.await_ = next
+
+                    if isinstance(next, MessagePart):
+                        if not in_message:
+                            self.run.outputs.append(Message(parts=[]))
+                            in_message = True
+                            await self.emit(MessageCreatedEvent(message=self.run.outputs[-1]))
+                        self.run.outputs[-1].parts.append(next)
+                        await self.emit(MessagePartEvent(part=next))
+                    elif isinstance(next, Message):
+                        if in_message:
+                            await self.emit(MessageCompletedEvent(message=self.run.outputs[-1]))
+                            in_message = False
+                        self.run.outputs.append(next)
+                        await self.emit(MessageCreatedEvent(message=next))
+                        for part in next.parts:
+                            await self.emit(MessagePartEvent(part=part))
+                        await self.emit(MessageCompletedEvent(message=next))
+                    elif isinstance(next, AwaitRequest):
+                        self.run.await_request = next
                         self.run.status = RunStatus.AWAITING
                         await self.emit(
                             AwaitEvent.model_validate(
@@ -103,8 +131,7 @@ 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))
+                        await self.emit(RunInProgressEvent(run=self.run))
                         run_logger.info("Run resumed")
                     else:
                         try:
@@ -113,19 +140,21 @@ class RunBundle:
                         except ValidationError:
                             raise TypeError("Invalid yield")
             except StopAsyncIteration:
-                self.run.output = self.composed_message
+                if in_message:
+                    await self.emit(MessageCompletedEvent(message=self.run.outputs[-1]))
                 self.run.status = RunStatus.COMPLETED
-                await self.emit(CompletedEvent(run=self.run))
+                await self.emit(RunCompletedEvent(run=self.run))
                 run_logger.info("Run completed")
             except asyncio.CancelledError:
                 self.run.status = RunStatus.CANCELLED
-                await self.emit(CancelledEvent(run=self.run))
+                await self.emit(RunCancelledEvent(run=self.run))
                 run_logger.info("Run cancelled")
             except Exception as e:
                 self.run.error = Error(code=ErrorCode.SERVER_ERROR, message=str(e))
                 self.run.status = RunStatus.FAILED
-                await self.emit(FailedEvent(run=self.run))
+                await self.emit(RunFailedEvent(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,19 +1,17 @@
 import asyncio
-import inspect
 import os
-from collections.abc import AsyncGenerator, Awaitable, Coroutine, Generator
+from collections.abc import Awaitable
 from typing import Any, Callable
 
 import uvicorn
 import uvicorn.config
 
-from acp_sdk.models import Message
+from acp_sdk.models import Metadata
 from acp_sdk.server.agent import Agent
+from acp_sdk.server.agent import agent as agent_decorator
 from acp_sdk.server.app import create_app
-from acp_sdk.server.context import Context
 from acp_sdk.server.logging import configure_logger as configure_logger_func
 from acp_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
-from acp_sdk.server.types import RunYield, RunYieldResume
 
 
 class Server:
@@ -21,92 +19,17 @@ 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:
-            signature = inspect.signature(fn)
-            parameters = list(signature.parameters.values())
-
-            if len(parameters) == 0:
-                raise TypeError("The agent function must have at least 'input' argument")
-            if len(parameters) > 2:
-                raise TypeError("The agent function must have only 'input' and 'context' arguments")
-            if len(parameters) == 2 and parameters[1].name != "context":
-                raise TypeError("The second argument of the agent function must be 'context'")
-
-            has_context_param = len(parameters) == 2
-
-            agent: Agent
-            if inspect.isasyncgenfunction(fn):
-
-                class DecoratedAgent(Agent):
-                    @property
-                    def name(self) -> str:
-                        return name or fn.__name__
-
-                    @property
-                    def description(self) -> str:
-                        return description or fn.__doc__ or ""
-
-                    async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
-                        try:
-                            gen: AsyncGenerator[RunYield, RunYieldResume] = (
-                                fn(input, context) if has_context_param else fn(input)
-                            )
-                            value = None
-                            while True:
-                                value = yield await gen.asend(value)
-                        except StopAsyncIteration:
-                            pass
-
-                agent = DecoratedAgent()
-            elif inspect.iscoroutinefunction(fn):
-
-                class DecoratedAgent(Agent):
-                    @property
-                    def name(self) -> str:
-                        return name or fn.__name__
-
-                    @property
-                    def description(self) -> str:
-                        return description or fn.__doc__ or ""
-
-                    async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
-                        return await (fn(input, context) if has_context_param else fn(input))
-
-                agent = DecoratedAgent()
-            elif inspect.isgeneratorfunction(fn):
-
-                class DecoratedAgent(Agent):
-                    @property
-                    def name(self) -> str:
-                        return name or fn.__name__
-
-                    @property
-                    def description(self) -> str:
-                        return description or fn.__doc__ or ""
-
-                    def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
-                        yield from (fn(input, context) if has_context_param else fn(input))
-
-                agent = DecoratedAgent()
-            else:
-
-                class DecoratedAgent(Agent):
-                    @property
-                    def name(self) -> str:
-                        return name or fn.__name__
-
-                    @property
-                    def description(self) -> str:
-                        return description or fn.__doc__ or ""
-
-                    def run(self, input: Message, context: Context) -> RunYield:
-                        return fn(input, context) if has_context_param else fn(input)
-
-                agent = DecoratedAgent()
-
+            agent = agent_decorator(name=name, description=description, metadata=metadata)(fn)
             self.register(agent)
             return fn
 

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

@@ -1,6 +1,6 @@
 from typing import Any
 
-from acp_sdk.models import Await, AwaitResume, Message
+from acp_sdk.models import AwaitRequest, AwaitResume, Message
 
-RunYield = Message | Await | dict[str | Any]
+RunYield = Message | AwaitRequest | dict[str | Any]
 RunYieldResume = AwaitResume | None

acp_sdk/version.py

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

acp_sdk-0.2.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: acp-sdk
+Version: 0.2.0
+Summary: Agent Communication Protocol SDK
+Author: IBM Corp.
+Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>
+License-Expression: Apache-2.0
+Requires-Python: <4.0,>=3.11
+Requires-Dist: opentelemetry-api>=1.31.1
+Requires-Dist: pydantic>=2.11.1
+Provides-Extra: client
+Requires-Dist: httpx-sse>=0.4.0; extra == 'client'
+Requires-Dist: httpx>=0.28.1; extra == 'client'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.52b1; extra == 'client'
+Provides-Extra: server
+Requires-Dist: fastapi[standard]>=0.115.8; extra == 'server'
+Requires-Dist: janus>=2.0.0; extra == 'server'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31.1; extra == 'server'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.52b1; extra == 'server'
+Requires-Dist: opentelemetry-sdk>=1.31.1; extra == 'server'
+Description-Content-Type: text/markdown
+
+# Agent Communication Protocol SDK for Python
+
+Agent Communication Protocol SDK for Python provides allows developers to serve and consume agents over the Agent Communication Protocol.
+
+## Prerequisites
+
+✅ Python >= 3.11
+
+## Installation
+
+Install to use client:
+
+```shell
+pip install acp-sdk[client]
+```
+
+Install to use server:
+
+```shell
+pip install acp-sdk[server]
+```
+
+Install to use models only:
+
+```shell
+pip install acp-sdk
+```
+
+## Overview
+
+### Core
+
+The core of the SDK exposes [pydantic](https://docs.pydantic.dev/) data models corresponding to REST API requests, responses, resources, events and errors.
+
+
+### Client
+
+The `client` submodule exposes [httpx](https://www.python-httpx.org/) based client with simple methods for communication over ACP.
+
+```python
+async with Client(base_url="http://localhost:8000") as client:
+    run = await client.run_sync(agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!")])])
+    print(run)
+
+```
+
+### Server
+
+The `server` submodule exposes `Agent` class and `agent` decorator together with [fastapi](https://fastapi.tiangolo.com/) application factory, making it easy to expose agents over ACP. Additionaly, it exposes [uvicorn](https://www.uvicorn.org/) based server to serve agents with set up logging, [opentelemetry](https://opentelemetry.io/) and more.
+
+```python
+server = Server()
+
+@server.agent()
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for message in inputs:
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield message
+
+
+server.run()
+```
+
+➡️ Explore more in our [examples library](/python/examples).
+
+## Architecture
+
+The architecture of the SDK is outlined in the following segment. It focuses on central parts of the SDK without going into much detail.
+
+### Models
+
+The core of the SDK contains pydantic models for requests, responses, resources, events and errors. Users of the SDK are meant to use these models directly or indirectly.
+
+### Server
+
+The server module consists of 3 parts:
+  
+  1. Agent interface
+  2. FastAPI application factory
+  3. Uvicorn based server
+
+Each part builds on top of the previous one. Not all parts need to be used, e.g. users are advised to bring their own ASGI server for production deployments.
+
+### Client
+
+The client module consists of httpx based client with session support. The client is meant to be thin and mimic the REST API. Exception is session management which has been abstracted into a context manager.
+
+
+  

acp_sdk-0.2.0.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=yXEtwdCxBCXwNz7xeeD7gPT9J7SYG2rb8QAjhuYhTlY,6131
+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=NCYYKKnWU1OSHQ0r1lSP_y4Z5cY3Agx-jmwfEwF3dLw,4001
+acp_sdk/models/schemas.py,sha256=LNs3oN1pQ4GD0ceV3-k6X6R39eu33nsAfnW6uEgOP0c,735
+acp_sdk/server/__init__.py,sha256=mxBBBFaZuMEUENRMLwp1XZkuLeT9QghcFmNvjnqvAAU,377
+acp_sdk/server/agent.py,sha256=fGky5MIuknw-Gy-THqhWLt9I9-gUyNIar8qEAvZb3uQ,6195
+acp_sdk/server/app.py,sha256=Ys5EN4MzmrwrpBGvycEP5dKEIYkDZmeBMMV1Aq58AU0,5897
+acp_sdk/server/bundle.py,sha256=BOOGuzEPS4bp6dhflcsQkyawllbsWoS3l6JqwKqI9n0,6312
+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=-eT3fmnEsBUN44Spi2EP2eV0l4RAlKa8bzqxnhz16SM,5399
+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=1bqMCjwZM3JzvJ1h4aBHWzjbldMQ45HqcezBD6hUoYo,175
+acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
+acp_sdk-0.2.0.dist-info/METADATA,sha256=B9sMxk3P4tBEoVCkEeKD_95EuohKvErdLR3VTU0JiKQ,3463
+acp_sdk-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.2.0.dist-info/RECORD,,

acp_sdk-0.1.0rc7.dist-info/METADATA

@@ -1,74 +0,0 @@
-Metadata-Version: 2.4
-Name: acp-sdk
-Version: 0.1.0rc7
-Summary: Agent Communication Protocol SDK
-Requires-Python: <4.0,>=3.11
-Requires-Dist: opentelemetry-api>=1.31.1
-Requires-Dist: pydantic>=2.11.1
-Provides-Extra: client
-Requires-Dist: httpx-sse>=0.4.0; extra == 'client'
-Requires-Dist: httpx>=0.28.1; extra == 'client'
-Requires-Dist: opentelemetry-instrumentation-httpx>=0.52b1; extra == 'client'
-Provides-Extra: server
-Requires-Dist: fastapi[standard]>=0.115.8; extra == 'server'
-Requires-Dist: janus>=2.0.0; extra == 'server'
-Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31.1; extra == 'server'
-Requires-Dist: opentelemetry-instrumentation-fastapi>=0.52b1; extra == 'server'
-Requires-Dist: opentelemetry-sdk>=1.31.1; extra == 'server'
-Description-Content-Type: text/markdown
-
-# Agent Communication Protocol SDK for Python
-
-Agent Communication Protocol SDK for Python provides allows developers to serve and consume agents over the Agent Communication Protocol.
-
-## Prerequisites
-
-✅ Python >= 3.11
-
-## Installation
-
-Install to use client:
-
-```shell
-pip install acp-sdk[client]
-```
-
-Install to use server:
-
-```shell
-pip install acp-sdk[server]
-```
-
-## Overview
-
-### Client
-
-The `client` submodule exposes [httpx]() based client with simple methods for communication over ACP.
-
-```python
-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)
-```
-
-### Server
-
-The `server` submodule exposes [fastapi] application factory that makes it easy to expose any agent over ACP.
-
-```python
-server = Server()
-
-@server.agent()
-async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
-    """Echoes everything"""
-    for part in input:
-        await asyncio.sleep(0.5)
-        yield {"thought": "I should echo everyting"}
-        await asyncio.sleep(0.5)
-        yield Message(part)
-
-
-server.run()
-```
-
-➡️ Explore more in our [examples library](/python/examples).

acp_sdk-0.1.0rc7.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=JhjI_M9GO-1lMrpZJo0IChDVrzUfnDyH5R5hFcqkXEE,3936
-acp_sdk/models/schemas.py,sha256=TM_0aRsBj_9G__zzWPYDx4wAXsGs2RUH57IOTi4--Ek,728
-acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
-acp_sdk/server/agent.py,sha256=SZfJK634d4s8fRh0u1Tc56l58XCRHAh3hq5Hcabh6tI,3442
-acp_sdk/server/app.py,sha256=rf8I2qcaaXoM-36Za8vs3Re7gygcTSMs4MXbMUBJENU,5803
-acp_sdk/server/bundle.py,sha256=LZzinifpbKxEBivoxOSdxUmzEcu3XNAkCiIJc2Ivveg,4987
-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=B1XGptw2kTgaB52klI4aNqDAlmyT2rNpMtKDSCxyVc4,8665
-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.0rc7.dist-info/METADATA,sha256=IoDvdN2USySSWbm7I05iIuuRz-7vCzaBtsnilmgW5IQ,2033
-acp_sdk-0.1.0rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.1.0rc7.dist-info/RECORD,,