acp-sdk 0.2.1__tar.gz → 0.2.3__tar.gz

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.2.1
+Version: 0.2.3
 Summary: Agent Communication Protocol SDK
 Author: IBM Corp.
 Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/examples/clients/advanced.py

@@ -13,7 +13,9 @@ async def example() -> None:
             # Additional client configuration
         )
     ) as client:
-        run = await client.run_sync(agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!")])])
+        run = await client.run_sync(
+            agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!", content_type="text/plain")])]
+        )
         print(run)
 
 

acp_sdk-0.2.3/examples/clients/session.py

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

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/examples/clients/simple.py

@@ -12,7 +12,7 @@ async def example() -> None:
         run = await client.run_sync(
             agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!", content_type="text/plain")])]
         )
-        print(run.outputs)
+        print(run)
 
 
 if __name__ == "__main__":

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.2.1"
+version = "0.2.3"
 description = "Agent Communication Protocol SDK"
 license = "Apache-2.0"
 readme = "README.md"

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/src/acp_sdk/client/client.py

@@ -39,16 +39,14 @@ class Client:
         base_url: httpx.URL | str = "",
         session_id: SessionId | None = None,
         client: httpx.AsyncClient | None = None,
+        instrument: bool = True,
     ) -> None:
         self.base_url = base_url
         self.session_id = session_id
 
-        self._client = self._init_client(client)
-
-    def _init_client(self, client: httpx.AsyncClient | None = None) -> httpx.AsyncClient:
-        client = client or httpx.AsyncClient(base_url=self.base_url)
-        HTTPXClientInstrumentor.instrument_client(client)
-        return client
+        self._client = client or httpx.AsyncClient(base_url=self.base_url)
+        if instrument:
+            HTTPXClientInstrumentor.instrument_client(self._client)
 
     async def __aenter__(self) -> Self:
         await self._client.__aenter__()
@@ -64,7 +62,7 @@ class Client:
 
     @asynccontextmanager
     async def session(self, session_id: SessionId | None = None) -> AsyncGenerator[Self]:
-        yield Client(client=self._client, session_id=session_id or uuid.uuid4())
+        yield Client(client=self._client, session_id=session_id or uuid.uuid4(), instrument=False)
 
     async def agents(self) -> AsyncIterator[Agent]:
         response = await self._client.get("/agents")
@@ -134,28 +132,28 @@ class Client:
         self._raise_error(response)
         return RunCancelResponse.model_validate(response.json())
 
-    async def run_resume_sync(self, *, run_id: RunId, await_: AwaitResume) -> Run:
+    async def run_resume_sync(self, *, run_id: RunId, await_resume: AwaitResume) -> Run:
         response = await self._client.post(
             f"/runs/{run_id}",
-            json=RunResumeRequest(await_resume=await_, mode=RunMode.SYNC).model_dump(),
+            json=RunResumeRequest(await_resume=await_resume, mode=RunMode.SYNC).model_dump(),
         )
         self._raise_error(response)
         return RunResumeResponse.model_validate(response.json())
 
-    async def run_resume_async(self, *, run_id: RunId, await_: AwaitResume) -> Run:
+    async def run_resume_async(self, *, run_id: RunId, await_resume: AwaitResume) -> Run:
         response = await self._client.post(
             f"/runs/{run_id}",
-            json=RunResumeRequest(await_resume=await_, mode=RunMode.ASYNC).model_dump(),
+            json=RunResumeRequest(await_resume=await_resume, mode=RunMode.ASYNC).model_dump(),
         )
         self._raise_error(response)
         return RunResumeResponse.model_validate(response.json())
 
-    async def run_resume_stream(self, *, run_id: RunId, await_: AwaitResume) -> AsyncIterator[Event]:
+    async def run_resume_stream(self, *, run_id: RunId, await_resume: AwaitResume) -> AsyncIterator[Event]:
         async with aconnect_sse(
             self._client,
             "POST",
             f"/runs/{run_id}",
-            json=RunResumeRequest(await_resume=await_, mode=RunMode.STREAM).model_dump(),
+            json=RunResumeRequest(await_resume=await_resume, mode=RunMode.STREAM).model_dump(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
                 yield event

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/src/acp_sdk/models/models.py

@@ -113,9 +113,9 @@ class MessageCompletedEvent(BaseModel):
     message: Message
 
 
-class AwaitEvent(BaseModel):
-    type: Literal["await"] = "await"
-    await_request: AwaitRequest | None = None
+class RunAwaitingEvent(BaseModel):
+    type: Literal["run.awaiting"] = "run.awaiting"
+    run: Run
 
 
 class GenericEvent(BaseModel):
@@ -155,7 +155,7 @@ Event = Union[
     ArtifactEvent,
     MessagePartEvent,
     MessageCompletedEvent,
-    AwaitEvent,
+    RunAwaitingEvent,
     GenericEvent,
     RunCancelledEvent,
     RunFailedEvent,

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/src/acp_sdk/server/bundle.py

@@ -6,17 +6,21 @@ from concurrent.futures import ThreadPoolExecutor
 from pydantic import ValidationError
 
 from acp_sdk.models import (
+    ACPError,
     AnyModel,
-    AwaitEvent,
     AwaitRequest,
     AwaitResume,
     Error,
+    ErrorCode,
     Event,
     GenericEvent,
     Message,
+    MessageCompletedEvent,
     MessageCreatedEvent,
+    MessagePart,
     MessagePartEvent,
     Run,
+    RunAwaitingEvent,
     RunCancelledEvent,
     RunCompletedEvent,
     RunCreatedEvent,
@@ -24,8 +28,6 @@ from acp_sdk.models import (
     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
@@ -120,15 +122,7 @@ class RunBundle:
                     elif isinstance(next, AwaitRequest):
                         self.run.await_request = next
                         self.run.status = RunStatus.AWAITING
-                        await self.emit(
-                            AwaitEvent.model_validate(
-                                {
-                                    "run_id": self.run.run_id,
-                                    "type": "await",
-                                    "await": next,
-                                }
-                            )
-                        )
+                        await self.emit(RunAwaitingEvent(run=self.run))
                         run_logger.info("Run awaited")
                         await_resume = await self.await_()
                         await self.emit(RunInProgressEvent(run=self.run))
@@ -150,7 +144,10 @@ class RunBundle:
                 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))
+                if isinstance(e, ACPError):
+                    self.run.error = e.error
+                else:
+                    self.run.error = Error(code=ErrorCode.SERVER_ERROR, message=str(e))
                 self.run.status = RunStatus.FAILED
                 await self.emit(RunFailedEvent(run=self.run))
                 run_logger.exception("Run failed")

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/tests/e2e/fixtures/server.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncGenerator, AsyncIterator, Generator
 from threading import Thread
 
 import pytest
-from acp_sdk.models import Artifact, AwaitRequest, AwaitResume, Message, MessagePart
+from acp_sdk.models import ACPError, Artifact, AwaitRequest, AwaitResume, Error, ErrorCode, Message, MessagePart
 from acp_sdk.server import Context, Server
 
 from e2e.config import Config
@@ -26,7 +26,7 @@ def server() -> Generator[None]:
 
     @server.agent()
     async def failer(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
-        raise RuntimeError("Whoops")
+        raise ACPError(Error(code=ErrorCode.INVALID_INPUT, message="Wrong question buddy!"))
 
     @server.agent()
     async def sessioner(inputs: list[Message], context: Context) -> AsyncIterator[Message]:

{acp_sdk-0.2.1 → acp_sdk-0.2.3}/tests/e2e/test_suites/test_runs.py

@@ -5,6 +5,7 @@ from acp_sdk.client import Client
 from acp_sdk.models import (
     ArtifactEvent,
     AwaitResume,
+    ErrorCode,
     Message,
     MessageCreatedEvent,
     MessagePart,
@@ -50,6 +51,8 @@ async def test_run_status(server: Server, client: Client) -> None:
 async def test_failure(server: Server, client: Client) -> None:
     run = await client.run_sync(agent="failer", inputs=inputs)
     assert run.status == RunStatus.FAILED
+    assert run.error is not None
+    assert run.error.code == ErrorCode.INVALID_INPUT
 
 
 @pytest.mark.asyncio
@@ -66,7 +69,7 @@ async def test_run_resume_sync(server: Server, client: Client) -> None:
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
-    run = await client.run_resume_sync(run_id=run.run_id, await_=AwaitResume())
+    run = await client.run_resume_sync(run_id=run.run_id, await_resume=AwaitResume())
     assert run.status == RunStatus.COMPLETED
 
 
@@ -76,7 +79,7 @@ async def test_run_resume_async(server: Server, client: Client) -> None:
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
-    run = await client.run_resume_async(run_id=run.run_id, await_=AwaitResume())
+    run = await client.run_resume_async(run_id=run.run_id, await_resume=AwaitResume())
     assert run.status == RunStatus.IN_PROGRESS
 
 
@@ -86,7 +89,7 @@ async def test_run_resume_stream(server: Server, client: Client) -> None:
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
-    event_stream = [event async for event in client.run_resume_stream(run_id=run.run_id, await_=AwaitResume())]
+    event_stream = [event async for event in client.run_resume_stream(run_id=run.run_id, await_resume=AwaitResume())]
     assert isinstance(event_stream[0], RunInProgressEvent)
     assert isinstance(event_stream[-1], RunCompletedEvent)
 

acp_sdk-0.2.1/examples/clients/session.py

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