acp-sdk 0.8.2__tar.gz → 0.8.4__tar.gz

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/PKG-INFO

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

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/pyproject.toml

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

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/src/acp_sdk/models/models.py

@@ -1,3 +1,4 @@
+import asyncio
 import uuid
 from datetime import datetime, timezone
 from enum import Enum
@@ -5,7 +6,7 @@ from typing import Any, Literal, Optional, Union
 
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field
 
-from acp_sdk.models.errors import Error
+from acp_sdk.models.errors import ACPError, Error
 
 
 class AnyModel(BaseModel):
@@ -95,7 +96,7 @@ class Artifact(MessagePart):
 
 class Message(BaseModel):
     parts: list[MessagePart]
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    created_at: datetime | None = Field(default_factory=lambda: datetime.now(timezone.utc))
     completed_at: datetime | None = Field(default_factory=lambda: datetime.now(timezone.utc))
 
     def __add__(self, other: "Message") -> "Message":
@@ -103,8 +104,10 @@ class Message(BaseModel):
             raise TypeError(f"Cannot concatenate Message with {type(other).__name__}")
         return Message(
             parts=self.parts + other.parts,
-            created_at=min(self.created_at, other.created_at),
-            completed_at=max(self.completed_at, other.completed_at),
+            created_at=min(self.created_at, other.created_at) if self.created_at and other.created_at else None,
+            completed_at=max(self.completed_at, other.completed_at)
+            if self.completed_at and other.completed_at
+            else None,
         )
 
     def __str__(self) -> str:
@@ -194,6 +197,15 @@ class Run(BaseModel):
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     finished_at: datetime | None = None
 
+    def raise_for_status(self) -> "Run":
+        match self.status:
+            case RunStatus.CANCELLED:
+                raise asyncio.CancelledError()
+            case RunStatus.FAILED:
+                raise ACPError(error=self.error)
+            case _:
+                return self
+
 
 class MessageCreatedEvent(BaseModel):
     type: Literal["message.created"] = "message.created"

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/src/acp_sdk/server/agent.py

@@ -58,13 +58,13 @@ class Agent(abc.ABC):
             run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, input, context)
 
         try:
-            while True:
+            while not run.done() or yield_queue.async_q.qsize() > 0:
                 value = yield await yield_queue.async_q.get()
+                if isinstance(value, Exception):
+                    raise value
                 await yield_resume_queue.async_q.put(value)
         except janus.AsyncQueueShutDown:
             pass
-        finally:
-            await run  # Raise exceptions
 
     async def _run_async_gen(self, input: list[Message], context: Context) -> None:
         try:
@@ -74,12 +74,16 @@ class Agent(abc.ABC):
                 value = await context.yield_async(await gen.asend(value))
         except StopAsyncIteration:
             pass
+        except Exception as e:
+            await context.yield_async(e)
         finally:
             context.shutdown()
 
     async def _run_coro(self, input: list[Message], context: Context) -> None:
         try:
             await context.yield_async(await self.run(input, context))
+        except Exception as e:
+            await context.yield_async(e)
         finally:
             context.shutdown()
 
@@ -91,12 +95,16 @@ class Agent(abc.ABC):
                 value = context.yield_sync(gen.send(value))
         except StopIteration:
             pass
+        except Exception as e:
+            context.yield_sync(e)
         finally:
             context.shutdown()
 
     def _run_func(self, input: list[Message], context: Context) -> None:
         try:
             context.yield_sync(self.run(input, context))
+        except Exception as e:
+            context.yield_sync(e)
         finally:
             context.shutdown()
 

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/src/acp_sdk/server/types.py

@@ -5,5 +5,5 @@ from pydantic import BaseModel
 from acp_sdk.models import AwaitRequest, AwaitResume, Message
 from acp_sdk.models.models import MessagePart
 
-RunYield = Message | MessagePart | str | AwaitRequest | BaseModel | dict[str | Any] | None
+RunYield = Message | MessagePart | str | AwaitRequest | BaseModel | dict[str | Any] | None | Exception
 RunYieldResume = AwaitResume | None

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/tests/e2e/fixtures/server.py

@@ -1,3 +1,4 @@
+import asyncio
 import base64
 import time
 from collections.abc import AsyncGenerator, AsyncIterator, Generator
@@ -21,6 +22,12 @@ def server(request: pytest.FixtureRequest) -> Generator[None]:
         for message in input:
             yield message
 
+    @server.agent()
+    async def slow_echo(input: list[Message], context: Context) -> AsyncIterator[Message]:
+        for message in input:
+            await asyncio.sleep(1)
+            yield message
+
     @server.agent()
     async def awaiter(
         input: list[Message], context: Context

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/tests/e2e/test_suites/test_runs.py

@@ -5,18 +5,20 @@ from datetime import timedelta
 import pytest
 from acp_sdk.client import Client
 from acp_sdk.models import (
+    ACPError,
+    AgentName,
     ArtifactEvent,
     ErrorCode,
     Message,
     MessageAwaitResume,
     MessagePart,
     MessagePartEvent,
+    RunCancelledEvent,
     RunCompletedEvent,
     RunCreatedEvent,
     RunInProgressEvent,
     RunStatus,
 )
-from acp_sdk.models.errors import ACPError
 from acp_sdk.server import Server
 
 input = [Message(parts=[MessagePart(content="Hello!")])]
@@ -78,11 +80,26 @@ async def test_failure(server: Server, client: Client) -> None:
 
 
 @pytest.mark.asyncio
-async def test_run_cancel(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="awaiter", input=input)
-    assert run.status == RunStatus.AWAITING
+@pytest.mark.parametrize("agent", ["awaiter", "slow_echo"])
+async def test_run_cancel(server: Server, client: Client, agent: AgentName) -> None:
+    run = await client.run_async(agent=agent, input=input)
     run = await client.run_cancel(run_id=run.run_id)
     assert run.status == RunStatus.CANCELLING
+    await asyncio.sleep(2)
+    run = await client.run_status(run_id=run.run_id)
+    assert run.status == RunStatus.CANCELLED
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("agent", ["slow_echo"])
+async def test_run_cancel_stream(server: Server, client: Client, agent: AgentName) -> None:
+    last_event = None
+    async for event in client.run_stream(agent=agent, input=input):
+        last_event = event
+        if isinstance(event, RunCreatedEvent):
+            run = await client.run_cancel(run_id=event.run.run_id)
+            assert run.status == RunStatus.CANCELLING
+    assert isinstance(last_event, RunCancelledEvent)
 
 
 @pytest.mark.asyncio

{acp_sdk-0.8.2 → acp_sdk-0.8.4}/tests/unit/models/test_models.py

@@ -1,5 +1,8 @@
+import asyncio
+
 import pytest
-from acp_sdk.models.models import Message, MessagePart
+from acp_sdk.models.errors import ACPError, Error, ErrorCode
+from acp_sdk.models.models import Message, MessagePart, Run, RunStatus
 
 timestamp = "2021-09-09T22:02:47.89Z"
 
@@ -26,7 +29,27 @@ timestamp = "2021-09-09T22:02:47.89Z"
                 created_at=timestamp,
                 completed_at=timestamp,
             ),
-        )
+        ),
+        (
+            Message(
+                parts=[MessagePart(content_type="text/plain", content="Foo")],
+                created_at=None,
+                completed_at=timestamp,
+            ),
+            Message(
+                parts=[MessagePart(content_type="text/plain", content="Bar")],
+                created_at=timestamp,
+                completed_at=None,
+            ),
+            Message(
+                parts=[
+                    MessagePart(content_type="text/plain", content="Foo"),
+                    MessagePart(content_type="text/plain", content="Bar"),
+                ],
+                created_at=None,
+                completed_at=None,
+            ),
+        ),
     ],
 )
 def test_message_add(first: Message, second: Message, result: Message) -> None:
@@ -76,3 +99,40 @@ def test_message_add(first: Message, second: Message, result: Message) -> None:
 )
 def test_message_compress(uncompressed: Message, compressed: Message) -> None:
     assert uncompressed.compress() == compressed
+
+
+@pytest.mark.parametrize(
+    "run,error",
+    [
+        (
+            Run(agent_name="foo", status=RunStatus.CANCELLED),
+            asyncio.CancelledError,
+        ),
+        (
+            Run(
+                agent_name="foo",
+                status=RunStatus.FAILED,
+                error=Error(code=ErrorCode.SERVER_ERROR, message="Unspecified"),
+            ),
+            ACPError,
+        ),
+        (
+            Run(agent_name="foo"),
+            None,
+        ),
+        (
+            Run(agent_name="foo", status=RunStatus.IN_PROGRESS),
+            None,
+        ),
+        (
+            Run(agent_name="foo", status=RunStatus.COMPLETED),
+            None,
+        ),
+    ],
+)
+def test_run_raise_on_status_raise(run: Run, error: type[Exception] | None) -> None:
+    if error:
+        with pytest.raises(error):
+            run.raise_for_status()
+    else:
+        run.raise_for_status()