acp-sdk 0.1.0rc8__py3-none-any.whl → 0.2.0__py3-none-any.whl

acp_sdk/client/client.py

@@ -16,14 +16,14 @@ from acp_sdk.models import (
     AgentReadResponse,
     AgentsListResponse,
     AwaitResume,
-    CreatedEvent,
     Error,
+    Event,
     Message,
     Run,
     RunCancelResponse,
+    RunCreatedEvent,
     RunCreateRequest,
     RunCreateResponse,
-    RunEvent,
     RunId,
     RunMode,
     RunResumeRequest,
@@ -107,7 +107,7 @@ class Client:
         self._set_session(response)
         return response
 
-    async def run_stream(self, *, agent: AgentName, inputs: list[Message]) -> AsyncIterator[RunEvent]:
+    async def run_stream(self, *, agent: AgentName, inputs: list[Message]) -> AsyncIterator[Event]:
         async with aconnect_sse(
             self._client,
             "POST",
@@ -120,7 +120,7 @@ class Client:
             ).model_dump_json(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
-                if isinstance(event, CreatedEvent):
+                if isinstance(event, RunCreatedEvent):
                     self._set_session(event.run)
                 yield event
 
@@ -150,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",
@@ -163,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:

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"
 
 
@@ -91,56 +83,39 @@ 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")
+    await_request: AwaitRequest | None = None
     outputs: list[Message] = []
-    artifacts: list[Artifact] = []
     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 MessageEvent(BaseModel):
-    type: Literal["message"] = "message"
-    message: Message
+class MessagePartEvent(BaseModel):
+    type: Literal["message.part"] = "message.part"
+    part: MessagePart
 
 
 class ArtifactEvent(BaseModel):
-    type: Literal["artifact"] = "artifact"
-    artifact: Artifact
+    type: Literal["message.part"] = "message.part"
+    part: Artifact
 
 
-class AwaitEvent(BaseModel):
-    type: Literal["await"] = "await"
-    await_: Await | None = Field(alias="await")
+class MessageCompletedEvent(BaseModel):
+    type: Literal["message.completed"] = "message.completed"
+    message: Message
 
-    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 AwaitEvent(BaseModel):
+    type: Literal["await"] = "await"
+    await_request: AwaitRequest | None = None
 
 
 class GenericEvent(BaseModel):
@@ -148,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/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
 
@@ -98,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/bundle.py

@@ -7,25 +7,25 @@ from pydantic import ValidationError
 
 from acp_sdk.models import (
     AnyModel,
-    Artifact,
-    ArtifactEvent,
-    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
@@ -40,14 +40,14 @@ class RunBundle:
         self.inputs = inputs
         self.history = history
 
-        self.stream_queue: asyncio.Queue[RunEvent] = asyncio.Queue()
+        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()
 
         self.task = asyncio.create_task(self._execute(inputs, executor=executor))
 
-    async def stream(self) -> AsyncGenerator[RunEvent]:
+    async def stream(self) -> AsyncGenerator[Event]:
         while True:
             event = await self.stream_queue.get()
             if event is None:
@@ -55,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:
@@ -71,12 +71,12 @@ class RunBundle:
         self.stream_queue = asyncio.Queue()
         await self.await_queue.put(resume)
         self.run.status = RunStatus.IN_PROGRESS
-        self.run.await_ = None
+        self.run.await_request = None
 
     async def cancel(self) -> None:
         self.task.cancel()
         self.run.status = RunStatus.CANCELLING
-        self.run.await_ = None
+        self.run.await_request = None
 
     async def join(self) -> None:
         await self.await_or_terminate_event.wait()
@@ -85,8 +85,9 @@ class RunBundle:
         with get_tracer().start_as_current_span("run"):
             run_logger = logging.LoggerAdapter(logger, {"run_id": str(self.run.run_id)})
 
+            in_message = False
             try:
-                await self.emit(CreatedEvent(run=self.run))
+                await self.emit(RunCreatedEvent(run=self.run))
 
                 generator = self.agent.execute(
                     inputs=self.history + inputs, session_id=self.run.session_id, executor=executor
@@ -94,19 +95,30 @@ class RunBundle:
                 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):
+
+                    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(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
+                        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(
@@ -119,7 +131,7 @@ class RunBundle:
                         )
                         run_logger.info("Run awaited")
                         await_resume = await self.await_()
-                        await self.emit(InProgressEvent(run=self.run))
+                        await self.emit(RunInProgressEvent(run=self.run))
                         run_logger.info("Run resumed")
                     else:
                         try:
@@ -128,17 +140,19 @@ class RunBundle:
                         except ValidationError:
                             raise TypeError("Invalid yield")
             except StopAsyncIteration:
+                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:

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, Metadata
+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:
@@ -31,104 +29,7 @@ class Server:
         """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 ""
-
-                    @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] = (
-                                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 ""
-
-                    @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))
-
-                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 ""
-
-                    @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))
-
-                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 ""
-
-                    @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)
-
-                agent = DecoratedAgent()
-
+            agent = agent_decorator(name=name, description=description, metadata=metadata)(fn)
             self.register(agent)
             return fn
 

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-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.1.0rc8.dist-info → acp_sdk-0.2.0.dist-info}/RECORD

@@ -2,23 +2,23 @@ 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/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=LrOZIWwn_6SenSwzz2JeK7Q555vzqjBKFElCifxQgnk,4107
+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=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
-acp_sdk/server/agent.py,sha256=wMwyB3Ouz361DX-RDPFD61nymoUOTvBIJt3_JU9KmOw,3297
+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=VUOqzBhwsADkoyPWqXSZ2KG59S3q4LMDfpFVAssnGSM,5386
+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=6iCJZrMfIDtqEmxqFREpPbyAiuxVxbQD73QHiFJ6KpA,9307
+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=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
+acp_sdk/server/types.py,sha256=1bqMCjwZM3JzvJ1h4aBHWzjbldMQ45HqcezBD6hUoYo,175
 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.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.0rc8.dist-info/METADATA

@@ -1,74 +0,0 @@
-Metadata-Version: 2.4
-Name: acp-sdk
-Version: 0.1.0rc8
-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", inputs=[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(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
-
-
-server.run()
-```
-
-➡️ Explore more in our [examples library](/python/examples).