acp-sdk 1.0.0rc1__py3-none-any.whl → 1.0.0rc2__py3-none-any.whl

acp_sdk/client/__init__.py

@@ -1 +1 @@
-from acp_sdk.client.client import Client
+from acp_sdk.client.client import Client as Client

acp_sdk/client/client.py

@@ -1,10 +1,11 @@
+from collections.abc import AsyncIterator
 from types import TracebackType
-from typing import AsyncIterator
+from typing import Self
 
 import httpx
 from httpx_sse import EventSource, aconnect_sse
-
 from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+from pydantic import TypeAdapter
 
 from acp_sdk.models import (
     Agent,
@@ -13,9 +14,9 @@ from acp_sdk.models import (
     AgentsListResponse,
     AwaitResume,
     Message,
+    Run,
     RunCancelResponse,
     RunCreateRequest,
-    Run,
     RunCreateResponse,
     RunEvent,
     RunId,
@@ -23,23 +24,20 @@ from acp_sdk.models import (
     RunResumeRequest,
     RunResumeResponse,
 )
-from pydantic import TypeAdapter
 
 
 class Client:
-    def __init__(
-        self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None
-    ):
+    def __init__(self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None) -> None:
         self.base_url = base_url
 
         self._client = self._init_client(client)
 
-    def _init_client(self, client: httpx.AsyncClient | None = None):
+    def _init_client(self, client: httpx.AsyncClient | None = None) -> Self:
         client = client or httpx.AsyncClient(base_url=self.base_url)
         HTTPXClientInstrumentor.instrument_client(client)
         return client
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Self:
         await self._client.__aenter__()
         return self
 
@@ -48,7 +46,7 @@ class Client:
         exc_type: type[BaseException] | None = None,
         exc_value: BaseException | None = None,
         traceback: TracebackType | None = None,
-    ):
+    ) -> None:
         await self._client.__aexit__(exc_type, exc_value, traceback)
 
     async def agents(self) -> AsyncIterator[Agent]:
@@ -63,31 +61,23 @@ class Client:
     async def run_sync(self, *, agent: AgentName, input: Message) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.SYNC
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.SYNC).model_dump(),
         )
         return RunCreateResponse.model_validate(response.json())
 
     async def run_async(self, *, agent: AgentName, input: Message) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.ASYNC
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.ASYNC).model_dump(),
         )
         return RunCreateResponse.model_validate(response.json())
 
-    async def run_stream(
-        self, *, agent: AgentName, input: Message
-    ) -> AsyncIterator[RunEvent]:
+    async def run_stream(self, *, agent: AgentName, input: Message) -> AsyncIterator[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",
             "/runs",
-            json=RunCreateRequest(
-                agent_name=agent, input=input, mode=RunMode.STREAM
-            ).model_dump(),
+            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.STREAM).model_dump(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
                 yield event
@@ -114,9 +104,7 @@ class Client:
         )
         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[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",

acp_sdk/models.py

@@ -1,6 +1,7 @@
-from enum import Enum
-from typing import Annotated, Literal, Union
 import uuid
+from collections.abc import Iterator
+from enum import Enum
+from typing import Any, Literal, Union
 
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field, RootModel
 
@@ -40,24 +41,19 @@ MessagePart = Union[TextMessagePart, ImageMessagePart, ArtifactMessagePart]
 class Message(RootModel):
     root: list[MessagePart]
 
-    def __init__(self, *items: MessagePart):
+    def __init__(self, *items: MessagePart) -> None:
         super().__init__(root=list(items))
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[MessagePart]:
         return iter(self.root)
 
-    def __getitem__(self, item):
-        return self.root[item]
-
     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))
 
-    def __str__(self):
-        return "".join(
-            str(part) for part in self.root if isinstance(part, TextMessagePart)
-        )
+    def __str__(self) -> str:
+        return "".join(str(part) for part in self.root if isinstance(part, TextMessagePart))
 
 
 AgentName = str
@@ -107,8 +103,8 @@ class Run(BaseModel):
 
     def model_dump_json(
         self,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> str:
         return super().model_dump_json(
             by_alias=True,
             **kwargs,
@@ -128,8 +124,8 @@ class AwaitEvent(BaseModel):
 
     def model_dump_json(
         self,
-        **kwargs,
-    ):
+        **kwargs: dict[str, Any],
+    ) -> str:
         return super().model_dump_json(
             by_alias=True,
             **kwargs,

acp_sdk/server/__init__.py

@@ -1,2 +1,2 @@
-from acp_sdk.server.server import create_app
-from acp_sdk.server.agent import Agent
+from acp_sdk.server.agent import Agent as Agent
+from acp_sdk.server.server import create_app as create_app

acp_sdk/server/agent.py

@@ -1,11 +1,11 @@
 import abc
-from typing import AsyncGenerator
+from collections.abc import AsyncGenerator
 
 from acp_sdk.models import (
     AgentName,
-    Message,
     Await,
     AwaitResume,
+    Message,
     SessionId,
 )
 from acp_sdk.server.context import Context
@@ -21,9 +21,7 @@ class Agent(abc.ABC):
         return ""
 
     @abc.abstractmethod
-    def run(
-        self, input: Message, *, context: Context
-    ) -> AsyncGenerator[Message | Await, AwaitResume]:
+    def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
         pass
 
     async def session(self, session_id: SessionId | None) -> SessionId | None:

acp_sdk/server/bundle.py

@@ -1,15 +1,16 @@
 import asyncio
 import logging
+from collections.abc import AsyncGenerator
 
 from opentelemetry import trace
 from pydantic import ValidationError
 
-from acp_sdk.server.agent import Agent
 from acp_sdk.models import (
     ACPError,
     AnyModel,
     Await,
     AwaitEvent,
+    AwaitResume,
     CancelledEvent,
     CompletedEvent,
     CreatedEvent,
@@ -19,17 +20,17 @@ from acp_sdk.models import (
     Message,
     MessageEvent,
     Run,
-    AwaitResume,
     RunEvent,
     RunStatus,
 )
+from acp_sdk.server.agent import Agent
 from acp_sdk.server.context import Context
 
 logger = logging.getLogger("uvicorn.error")
 
 
 class RunBundle:
-    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None):
+    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None) -> None:
         self.agent = agent
         self.run = run
         self.task = task
@@ -40,20 +41,19 @@ class RunBundle:
         self.await_queue: asyncio.Queue[AwaitResume] = asyncio.Queue(maxsize=1)
         self.await_or_terminate_event = asyncio.Event()
 
-    async def stream(self):
-        try:
-            while True:
-                event = await self.stream_queue.get()
-                yield event
-                self.stream_queue.task_done()
-        except asyncio.QueueShutDown:
-            pass
+    async def stream(self) -> AsyncGenerator[RunEvent]:
+        while True:
+            event = await self.stream_queue.get()
+            if event is None:
+                break
+            yield event
+            self.stream_queue.task_done()
 
-    async def emit(self, event: RunEvent):
+    async def emit(self, event: RunEvent) -> None:
         await self.stream_queue.put(event)
 
     async def await_(self) -> AwaitResume:
-        self.stream_queue.shutdown()
+        await self.stream_queue.put(None)
         self.await_queue.empty()
         self.await_or_terminate_event.set()
         self.await_or_terminate_event.clear()
@@ -61,14 +61,14 @@ class RunBundle:
         self.await_queue.task_done()
         return resume
 
-    async def resume(self, resume: AwaitResume):
+    async def resume(self, resume: AwaitResume) -> None:
         self.stream_queue = asyncio.Queue()
         await self.await_queue.put(resume)
 
-    async def join(self):
+    async def join(self) -> None:
         await self.await_or_terminate_event.wait()
 
-    async def execute(self, input: Message):
+    async def execute(self, input: Message) -> None:
         with trace.get_tracer(__name__).start_as_current_span("execute"):
             run_logger = logging.LoggerAdapter(logger, {"run_id": self.run.run_id})
 
@@ -77,9 +77,7 @@ class RunBundle:
                 self.run.session_id = await self.agent.session(self.run.session_id)
                 run_logger.info("Session loaded")
 
-                generator = self.agent.run(
-                    input=input, context=Context(session_id=self.run.session_id)
-                )
+                generator = self.agent.run(input=input, context=Context(session_id=self.run.session_id))
                 run_logger.info("Run started")
 
                 self.run.status = RunStatus.IN_PROGRESS
@@ -130,4 +128,4 @@ class RunBundle:
                 run_logger.exception("Run failed")
             finally:
                 self.await_or_terminate_event.set()
-                self.stream_queue.shutdown()
+                await self.stream_queue.put(None)

acp_sdk/server/context.py

@@ -2,5 +2,5 @@ from acp_sdk.models import SessionId
 
 
 class Context:
-    def __init__(self, *, session_id: SessionId | None = None):
+    def __init__(self, *, session_id: SessionId | None = None) -> None:
         self.session_id = session_id

acp_sdk/server/server.py

@@ -1,17 +1,16 @@
 import asyncio
 
-from acp_sdk.server.telemetry import configure_telemetry
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-
 from fastapi import FastAPI, HTTPException, status
 from fastapi.responses import JSONResponse, StreamingResponse
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 
-from acp_sdk.server.agent import Agent
 from acp_sdk.models import (
-    AgentName,
     Agent as AgentModel,
-    AgentsListResponse,
+)
+from acp_sdk.models import (
+    AgentName,
     AgentReadResponse,
+    AgentsListResponse,
     Run,
     RunCancelResponse,
     RunCreateRequest,
@@ -23,7 +22,9 @@ from acp_sdk.models import (
     RunResumeResponse,
     RunStatus,
 )
+from acp_sdk.server.agent import Agent
 from acp_sdk.server.bundle import RunBundle
+from acp_sdk.server.telemetry import configure_telemetry
 from acp_sdk.server.utils import stream_sse
 
 
@@ -34,36 +35,33 @@ def create_app(*agents: Agent) -> FastAPI:
     FastAPIInstrumentor.instrument_app(app)
 
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
-    runs: dict[RunId, RunBundle] = dict()
+    runs: dict[RunId, RunBundle] = {}
 
-    def find_run_bundle(run_id: RunId):
-        bundle = runs.get(run_id, None)
+    def find_run_bundle(run_id: RunId) -> RunBundle:
+        bundle = runs.get(run_id)
         if not bundle:
             raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
         return bundle
 
-    def find_agent(agent_name: AgentName):
+    def find_agent(agent_name: AgentName) -> Agent:
         agent = agents.get(agent_name, None)
         if not agent:
             raise HTTPException(status_code=404, detail=f"Agent {agent_name} not found")
         return agent
 
     @app.get("/agents")
-    async def list() -> AgentsListResponse:
+    async def list_agents() -> AgentsListResponse:
         return AgentsListResponse(
-            agents=[
-                AgentModel(name=agent.name, description=agent.description)
-                for agent in agents.values()
-            ]
+            agents=[AgentModel(name=agent.name, description=agent.description) for agent in agents.values()]
         )
 
     @app.get("/agents/{name}")
-    async def read(name: AgentName) -> AgentReadResponse:
+    async def read_agent(name: AgentName) -> AgentReadResponse:
         agent = find_agent(name)
         return AgentModel(name=agent.name, description=agent.description)
 
     @app.post("/runs")
-    async def create(request: RunCreateRequest) -> RunCreateResponse:
+    async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
         bundle = RunBundle(
             agent=agent,
@@ -94,12 +92,12 @@ def create_app(*agents: Agent) -> FastAPI:
                 raise NotImplementedError()
 
     @app.get("/runs/{run_id}")
-    async def read(run_id: RunId) -> RunReadResponse:
+    async def read_run(run_id: RunId) -> RunReadResponse:
         bundle = find_run_bundle(run_id)
         return bundle.run
 
     @app.post("/runs/{run_id}")
-    async def resume(run_id: RunId, request: RunResumeRequest) -> RunResumeResponse:
+    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_)
@@ -121,7 +119,7 @@ def create_app(*agents: Agent) -> FastAPI:
                 raise NotImplementedError()
 
     @app.post("/runs/{run_id}/cancel")
-    async def cancel(run_id: RunId) -> RunCancelResponse:
+    async def cancel_run(run_id: RunId) -> RunCancelResponse:
         bundle = find_run_bundle(run_id)
         if bundle.run.status.is_terminal:
             raise HTTPException(
@@ -130,8 +128,6 @@ def create_app(*agents: Agent) -> FastAPI:
             )
         bundle.task.cancel()
         bundle.run.status = RunStatus.CANCELLING
-        return JSONResponse(
-            status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump()
-        )
+        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump())
 
     return app

acp_sdk/server/telemetry.py

@@ -1,22 +1,23 @@
 import logging
 from importlib.metadata import version
+from typing import Any
 
 from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.resources import (
-    Resource,
     SERVICE_NAME,
     SERVICE_NAMESPACE,
     SERVICE_VERSION,
+    Resource,
 )
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExportResult
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
 logger = logging.getLogger("uvicorn.error")
 
 
 class SilentOTLPSpanExporter(OTLPSpanExporter):
-    def export(self, spans):
+    def export(self, spans: Any) -> SpanExportResult:
         try:
             return super().export(spans)
         except Exception as e:
@@ -24,7 +25,7 @@ class SilentOTLPSpanExporter(OTLPSpanExporter):
             return SpanExportResult.FAILURE
 
 
-def configure_telemetry():
+def configure_telemetry() -> None:
     current_provider = trace.get_tracer_provider()
 
     # Detect default provider and override

acp_sdk/server/utils.py

@@ -1,12 +1,14 @@
+from collections.abc import AsyncGenerator
+
 from pydantic import BaseModel
 
 from acp_sdk.server.bundle import RunBundle
 
 
-def encode_sse(model: BaseModel):
+def encode_sse(model: BaseModel) -> str:
     return f"data: {model.model_dump_json()}\n\n"
 
 
-async def stream_sse(bundle: RunBundle):
+async def stream_sse(bundle: RunBundle) -> AsyncGenerator[str]:
     async for event in bundle.stream():
         yield encode_sse(event)

{acp_sdk-1.0.0rc1.dist-info → acp_sdk-1.0.0rc2.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 1.0.0rc1
+Version: 1.0.0rc2
 Summary: Agent Communication Protocol SDK
-Requires-Python: <4.0,>=3.13
+Requires-Python: <4.0,>=3.11
 Requires-Dist: opentelemetry-api>=1.31.1
 Requires-Dist: pydantic>=2.11.1
 Provides-Extra: client

acp_sdk-1.0.0rc2.dist-info/RECORD

@@ -0,0 +1,15 @@
+acp_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acp_sdk/models.py,sha256=atSddtsQvNfiEIKHTckMwzahlTaOyyjuX6rrtD1Dft8,4345
+acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
+acp_sdk/client/client.py,sha256=os14f1Q4TAMoXuhjpbrh67bBYpQS7KyT4H7a-WFN07Q,4489
+acp_sdk/server/__init__.py,sha256=iClvo3yLpMKLoUTTR9JeL_eR7R9YLFFcHTyFpg4xWfg,107
+acp_sdk/server/agent.py,sha256=yo31fL0H7boaHllICXAiXApHgBLD8fJfs1osJWUheuI,682
+acp_sdk/server/bundle.py,sha256=R3D5cPSoId6CZrs-ag3aUuxiK6sVdLw2EmOdMl3SoGg,4892
+acp_sdk/server/context.py,sha256=oILWXHNTXq3mLX0RM7jiIKMC19dEiw7AYy6X0L6OUXg,163
+acp_sdk/server/server.py,sha256=XvIznmda5UjjOUP37XRHDwKzVf-seKjVwkfshbKRuCo,4446
+acp_sdk/server/telemetry.py,sha256=rM22-0_SXtJn9T_xDmXalATAR1cwV8COJDY6EAg0jeE,1439
+acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
+acp_sdk-1.0.0rc2.dist-info/METADATA,sha256=vGTZlnl6Ucgg4iPLxItlrAu446pJYitlKMLBuYNgEUI,1350
+acp_sdk-1.0.0rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-1.0.0rc2.dist-info/RECORD,,

acp_sdk-1.0.0rc1.dist-info/RECORD

@@ -1,15 +0,0 @@
-acp_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-acp_sdk/models.py,sha256=0B_jdMxM7sYO9USTZzM1hvCS-qsO6lUKfqLTpGdkRQQ,4315
-acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-acp_sdk/client/__init__.py,sha256=h3uraY7H5vbtiz5i3N9kIpjF_bu7Nor6LJu_li-aiVc,41
-acp_sdk/client/client.py,sha256=EDcV6DhnDFJF58zAyzi4cgoNkb3znMSw7dZkiN7KKbY,4557
-acp_sdk/server/__init__.py,sha256=2bgh6BqT6I0w9GmN8GWdHa52HL64ZpbcICbxKZbInNY,84
-acp_sdk/server/agent.py,sha256=G3gmUDzb_msK0w4EuUe8hTbZRFCb8xy-bqpVFIAx9sU,687
-acp_sdk/server/bundle.py,sha256=cZmd39uYkykKOyQpVcXHtH_-N2y9PJX9jWEvO9bzlA8,4841
-acp_sdk/server/context.py,sha256=h8SY0-1DMHAMluOMni981EXXM2kAuBQcqrofK-qyi4s,155
-acp_sdk/server/server.py,sha256=dUZ-aDsNzSHnEeY3vOtbixrgr86JT2JUkTue6_9IVak,4443
-acp_sdk/server/telemetry.py,sha256=ZxiZUJm9PuZoc6rIl0MvaQkzIX3E4ENiwsxxqDZtfRo,1383
-acp_sdk/server/utils.py,sha256=VoqEZ1fZ7_NYSKmDIwBz2UwSL17NKTZ5k760ALgimE4,277
-acp_sdk-1.0.0rc1.dist-info/METADATA,sha256=0ddoScvUqT8HuRpVgBFNdtxQt8gxzyMU7ujyimZ5s1c,1350
-acp_sdk-1.0.0rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-1.0.0rc1.dist-info/RECORD,,