acp-sdk 0.7.0__tar.gz → 0.7.2__tar.gz

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.7.0
+Version: 0.7.2
 Summary: Agent Communication Protocol SDK
 Author: IBM Corp.
 Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>
@@ -44,9 +44,9 @@ Register an agent and run the server:
 server = Server()
 
 @server.agent()
-async def echo(inputs: list[Message]):
+async def echo(input: list[Message]):
     """Echoes everything"""
-    for message in inputs:
+    for message in input:
         yield message
 
 server.run(port=8000)
@@ -56,7 +56,7 @@ From another process, connect to the server and run the agent:
 
 ```py
 async with Client(base_url="http://localhost:8000") as client:
-    run = await client.run_sync(agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!")])])
+    run = await client.run_sync(agent="echo", input=[Message(parts=[MessagePart(content="Howdy!")])])
     print(run)
 
 ```

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/README.md

@@ -23,9 +23,9 @@ Register an agent and run the server:
 server = Server()
 
 @server.agent()
-async def echo(inputs: list[Message]):
+async def echo(input: list[Message]):
     """Echoes everything"""
-    for message in inputs:
+    for message in input:
         yield message
 
 server.run(port=8000)
@@ -35,7 +35,7 @@ From another process, connect to the server and run the agent:
 
 ```py
 async with Client(base_url="http://localhost:8000") as client:
-    run = await client.run_sync(agent="echo", inputs=[Message(parts=[MessagePart(content="Howdy!")])])
+    run = await client.run_sync(agent="echo", input=[Message(parts=[MessagePart(content="Howdy!")])])
     print(run)
 
 ```

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/docs/client.md

@@ -71,15 +71,15 @@ async with Client(base_url="http://localhost:8000") as client:
   message = Message(parts=[MessagePart(content="Hello")])
 
   # Async
-  run = await client.run_async(agent_name="agent", inputs=[message])
+  run = await client.run_async(agent="agent", input=[message])
   print(run.status)
 
   # Sync - waits for completion, failure, cancellation or await
-  run = await client.run_sync(agent_name="agent", inputs=[message])
+  run = await client.run_sync(agent="agent", input=[message])
   print(run.output)
   
   # Stream - as sync but also receives events
-  async for event in client.run_stream(agent_name="agent", inputs=[message])
+  async for event in client.run_stream(agent="agent", input=[message])
     print(event)
 ```
 
@@ -95,5 +95,5 @@ async with Client(base_url="http://localhost:8000" as client:
 
     async with client.session() as session:
         for agent in agents:
-            await session.run_sync(agent_name=agent.name, inputs=[Message(parts=[MessagePart(content="Hello!")])])
+            await session.run_sync(agent=agent.name, input=[Message(parts=[MessagePart(content="Hello!")])])
 ```

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/docs/server.md

@@ -47,9 +47,9 @@ server = Server()
 
 
 @server.agent()
-async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(input: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for message in inputs:
+    for message in input:
         await asyncio.sleep(0.5)
         yield {"thought": "I should echo everything"}
         await asyncio.sleep(0.5)
@@ -81,9 +81,9 @@ from acp_sdk.server import RunYield, RunYieldResume, agent, create_app
 
 
 @agent()
-async def echo(inputs: list[Message]) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(input: list[Message]) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for message in inputs:
+    for message in input:
         yield message
 
 

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/pyproject.toml

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

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/client/client.py

@@ -11,6 +11,8 @@ from httpx_sse import EventSource, aconnect_sse
 from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
 from pydantic import TypeAdapter
 
+from acp_sdk.client.types import Input
+from acp_sdk.client.utils import input_to_messages
 from acp_sdk.instrumentation import get_tracer
 from acp_sdk.models import (
     ACPError,
@@ -21,7 +23,6 @@ from acp_sdk.models import (
     AwaitResume,
     Error,
     Event,
-    Message,
     Run,
     RunCancelResponse,
     RunCreatedEvent,
@@ -33,9 +34,6 @@ from acp_sdk.models import (
     RunResumeResponse,
     SessionId,
 )
-from acp_sdk.models.models import MessagePart
-
-Input = list[Message] | Message | list[MessagePart] | MessagePart | list[str] | str
 
 
 class Client:
@@ -122,12 +120,17 @@ class Client:
         response = AgentReadResponse.model_validate(response.json())
         return Agent(**response.model_dump())
 
+    async def ping(self) -> bool:
+        response = await self._client.get("/healthcheck")
+        self._raise_error(response)
+        return response.json() == "OK"
+
     async def run_sync(self, input: Input, *, agent: AgentName) -> Run:
         response = await self._client.post(
             "/runs",
             content=RunCreateRequest(
                 agent_name=agent,
-                input=self._unify_inputs(input),
+                input=input_to_messages(input),
                 mode=RunMode.SYNC,
                 session_id=self._session_id,
             ).model_dump_json(),
@@ -142,7 +145,7 @@ class Client:
             "/runs",
             content=RunCreateRequest(
                 agent_name=agent,
-                input=self._unify_inputs(input),
+                input=input_to_messages(input),
                 mode=RunMode.ASYNC,
                 session_id=self._session_id,
             ).model_dump_json(),
@@ -159,7 +162,7 @@ class Client:
             "/runs",
             content=RunCreateRequest(
                 agent_name=agent,
-                input=self._unify_inputs(input),
+                input=input_to_messages(input),
                 mode=RunMode.STREAM,
                 session_id=self._session_id,
             ).model_dump_json(),
@@ -227,24 +230,3 @@ class Client:
 
     def _set_session(self, run: Run) -> None:
         self._session_id = run.session_id
-
-    def _unify_inputs(self, input: Input) -> list[Message]:
-        if isinstance(input, list):
-            if len(input) == 0:
-                return []
-            if all(isinstance(item, Message) for item in input):
-                return input
-            elif all(isinstance(item, MessagePart) for item in input):
-                return [Message(parts=input)]
-            elif all(isinstance(item, str) for item in input):
-                return [Message(parts=[MessagePart(content=content) for content in input])]
-            else:
-                raise RuntimeError("List with mixed types is not supported")
-        else:
-            if isinstance(input, str):
-                input = MessagePart(content=input)
-            if isinstance(input, MessagePart):
-                input = Message(parts=[input])
-            if isinstance(input, Message):
-                input = [input]
-            return input

acp_sdk-0.7.2/src/acp_sdk/client/types.py

@@ -0,0 +1,3 @@
+from acp_sdk.models import Message, MessagePart
+
+Input = list[Message] | Message | list[MessagePart] | MessagePart | list[str] | str

acp_sdk-0.7.2/src/acp_sdk/client/utils.py

@@ -0,0 +1,24 @@
+from acp_sdk.client.types import Input
+from acp_sdk.models.models import Message, MessagePart
+
+
+def input_to_messages(input: Input) -> list[Message]:
+    if isinstance(input, list):
+        if len(input) == 0:
+            return []
+        if all(isinstance(item, Message) for item in input):
+            return input
+        elif all(isinstance(item, MessagePart) for item in input):
+            return [Message(parts=input)]
+        elif all(isinstance(item, str) for item in input):
+            return [Message(parts=[MessagePart(content=content) for content in input])]
+        else:
+            raise TypeError("List with mixed types is not supported")
+    else:
+        if isinstance(input, str):
+            input = MessagePart(content=input)
+        if isinstance(input, MessagePart):
+            input = Message(parts=[input])
+        if isinstance(input, Message):
+            input = [input]
+        return input

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/models/models.py

@@ -47,6 +47,11 @@ class Dependency(BaseModel):
     name: str
 
 
+class Capability(BaseModel):
+    name: str
+    description: str
+
+
 class Metadata(BaseModel):
     annotations: AnyModel | None = None
     documentation: str | None = None
@@ -54,7 +59,8 @@ class Metadata(BaseModel):
     programming_language: str | None = None
     natural_languages: list[str] | None = None
     framework: str | None = None
-    use_cases: list[str] | None = None
+    capabilities: list[Capability] | None = None
+    domains: list[str] | None = None
     tags: list[str] | None = None
     created_at: datetime | None = None
     updated_at: datetime | None = None
@@ -93,7 +99,7 @@ class Message(BaseModel):
     def __add__(self, other: "Message") -> "Message":
         if not isinstance(other, Message):
             raise TypeError(f"Cannot concatenate Message with {type(other).__name__}")
-        return Message(*(self.parts + other.parts))
+        return Message(parts=self.parts + other.parts)
 
     def __str__(self) -> str:
         return "".join(

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/server/agent.py

@@ -32,14 +32,14 @@ class Agent(abc.ABC):
 
     @abc.abstractmethod
     def run(
-        self, inputs: list[Message], context: Context
+        self, input: list[Message], context: Context
     ) -> (
         AsyncGenerator[RunYield, RunYieldResume] | Generator[RunYield, RunYieldResume] | Coroutine[RunYield] | RunYield
     ):
         pass
 
     async def execute(
-        self, inputs: list[Message], session_id: SessionId | None, executor: ThreadPoolExecutor
+        self, input: 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()
@@ -49,13 +49,13 @@ class Agent(abc.ABC):
         )
 
         if inspect.isasyncgenfunction(self.run):
-            run = asyncio.create_task(self._run_async_gen(inputs, context))
+            run = asyncio.create_task(self._run_async_gen(input, context))
         elif inspect.iscoroutinefunction(self.run):
-            run = asyncio.create_task(self._run_coro(inputs, context))
+            run = asyncio.create_task(self._run_coro(input, context))
         elif inspect.isgeneratorfunction(self.run):
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, inputs, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, input, context)
         else:
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, inputs, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, input, context)
 
         try:
             while True:
@@ -66,7 +66,7 @@ class Agent(abc.ABC):
         finally:
             await run  # Raise exceptions
 
-    async def _run_async_gen(self, input: Message, context: Context) -> None:
+    async def _run_async_gen(self, input: list[Message], context: Context) -> None:
         try:
             gen: AsyncGenerator[RunYield, RunYieldResume] = self.run(input, context)
             value = None
@@ -77,13 +77,13 @@ class Agent(abc.ABC):
         finally:
             context.shutdown()
 
-    async def _run_coro(self, input: Message, context: Context) -> None:
+    async def _run_coro(self, input: list[Message], context: Context) -> None:
         try:
             await context.yield_async(await self.run(input, context))
         finally:
             context.shutdown()
 
-    def _run_gen(self, input: Message, context: Context) -> None:
+    def _run_gen(self, input: list[Message], context: Context) -> None:
         try:
             gen: Generator[RunYield, RunYieldResume] = self.run(input, context)
             value = None
@@ -94,7 +94,7 @@ class Agent(abc.ABC):
         finally:
             context.shutdown()
 
-    def _run_func(self, input: Message, context: Context) -> None:
+    def _run_func(self, input: list[Message], context: Context) -> None:
         try:
             context.yield_sync(self.run(input, context))
         finally:
@@ -139,7 +139,7 @@ def agent(
         if inspect.isasyncgenfunction(fn):
 
             class AsyncGenDecoratorAgent(DecoratorAgentBase):
-                async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+                async def run(self, input: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
                     try:
                         gen: AsyncGenerator[RunYield, RunYieldResume] = (
                             fn(input, context) if has_context_param else fn(input)
@@ -154,21 +154,21 @@ def agent(
         elif inspect.iscoroutinefunction(fn):
 
             class CoroDecoratorAgent(DecoratorAgentBase):
-                async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
+                async def run(self, input: list[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]:
+                def run(self, input: list[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:
+                def run(self, input: list[Message], context: Context) -> RunYield:
                     return fn(input, context) if has_context_param else fn(input)
 
             agent = FuncDecoratorAgent()

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/server/app.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 from enum import Enum
 
 from cachetools import TTLCache
-from fastapi import FastAPI, HTTPException, status
+from fastapi import Depends, FastAPI, HTTPException, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
@@ -47,7 +47,12 @@ class Headers(str, Enum):
     RUN_ID = "Run-ID"
 
 
-def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timedelta(hours=1)) -> FastAPI:
+def create_app(
+    *agents: Agent,
+    run_limit: int = 1000,
+    run_ttl: timedelta = timedelta(hours=1),
+    dependencies: list[Depends] | None = None,
+) -> FastAPI:
     executor: ThreadPoolExecutor
 
     @asynccontextmanager
@@ -57,7 +62,10 @@ def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timed
             executor = exec
             yield
 
-    app = FastAPI(lifespan=lifespan)
+    app = FastAPI(
+        lifespan=lifespan,
+        dependencies=dependencies,
+    )
 
     FastAPIInstrumentor.instrument_app(app)
 
@@ -96,6 +104,10 @@ def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timed
         agent = find_agent(name)
         return AgentModel(name=agent.name, description=agent.description, metadata=agent.metadata)
 
+    @app.get("/healthcheck")
+    async def healthcheck() -> str:
+        return "OK"
+
     @app.post("/runs")
     async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
@@ -105,7 +117,7 @@ def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timed
         bundle = RunBundle(
             agent=agent,
             run=Run(agent_name=agent.name, session_id=session.id),
-            inputs=request.input,
+            input=request.input,
             history=list(session.history()),
             executor=executor,
         )

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/server/bundle.py

@@ -35,11 +35,11 @@ from acp_sdk.server.logging import logger
 
 class RunBundle:
     def __init__(
-        self, *, agent: Agent, run: Run, inputs: list[Message], history: list[Message], executor: ThreadPoolExecutor
+        self, *, agent: Agent, run: Run, input: list[Message], history: list[Message], executor: ThreadPoolExecutor
     ) -> None:
         self.agent = agent
         self.run = run
-        self.inputs = inputs
+        self.input = input
         self.history = history
 
         self.stream_queue: asyncio.Queue[Event] = asyncio.Queue()
@@ -47,7 +47,7 @@ class RunBundle:
         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))
+        self.task = asyncio.create_task(self._execute(input, executor=executor))
 
     async def stream(self) -> AsyncGenerator[Event]:
         while True:
@@ -83,7 +83,7 @@ class RunBundle:
     async def join(self) -> None:
         await self.await_or_terminate_event.wait()
 
-    async def _execute(self, inputs: list[Message], *, executor: ThreadPoolExecutor) -> None:
+    async def _execute(self, input: 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)})
 
@@ -99,7 +99,7 @@ class RunBundle:
                 await self.emit(RunCreatedEvent(run=self.run))
 
                 generator = self.agent.execute(
-                    inputs=self.history + inputs, session_id=self.run.session_id, executor=executor
+                    input=self.history + input, session_id=self.run.session_id, executor=executor
                 )
                 run_logger.info("Run started")
 

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/server/server.py

@@ -4,6 +4,7 @@ from collections.abc import Awaitable
 from datetime import timedelta
 from typing import Any, Callable
 
+import requests
 import uvicorn
 import uvicorn.config
 
@@ -12,7 +13,9 @@ 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.logging import configure_logger as configure_logger_func
+from acp_sdk.server.logging import logger
 from acp_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
+from acp_sdk.server.utils import async_request_with_retry
 
 
 class Server:
@@ -43,6 +46,7 @@ class Server:
         self,
         configure_logger: bool = True,
         configure_telemetry: bool = False,
+        self_registration: bool = True,
         run_limit: int = 1000,
         run_ttl: timedelta = timedelta(hours=1),
         host: str = "127.0.0.1",
@@ -158,7 +162,14 @@ class Server:
             h11_max_incomplete_event_size,
         )
         self._server = uvicorn.Server(config)
-        self._server.run()
+
+        asyncio.run(self._serve(self_registration=self_registration))
+
+    async def _serve(self, self_registration: bool = True) -> None:
+        registration_task = asyncio.create_task(self._register_agent()) if self_registration else None
+        await self._server.serve()
+        if registration_task:
+            registration_task.cancel()
 
     @property
     def should_exit(self) -> bool:
@@ -167,3 +178,45 @@ class Server:
     @should_exit.setter
     def should_exit(self, value: bool) -> None:
         self._server.should_exit = value
+
+    async def _register_agent(self) -> None:
+        """If not in PRODUCTION mode, register agent to the beeai platform and provide missing env variables"""
+        if os.getenv("PRODUCTION_MODE", False):
+            logger.debug("Agent is not automatically registered in the production mode.")
+            return
+
+        url = os.getenv("PLATFORM_URL", "http://127.0.0.1:8333")
+        for agent in self._agents:
+            request_data = {
+                "location": f"http://{self._server.config.host}:{self._server.config.port}",
+                "id": agent.name,
+            }
+            try:
+                await async_request_with_retry(
+                    lambda client, data=request_data: client.post(
+                        f"{url}/api/v1/provider/register/unmanaged", json=data
+                    )
+                )
+                logger.info("Agent registered to the beeai server.")
+
+                # check missing env keyes
+                envs_request = await async_request_with_retry(lambda client: client.get(f"{url}/api/v1/env"))
+                envs = envs_request.get("env")
+
+                # register all available envs
+                missing_keyes = []
+                for env in agent.metadata.model_dump().get("env", []):
+                    server_env = envs.get(env.get("name"))
+                    if server_env:
+                        logger.debug(f"Env variable {env['name']} = '{server_env}' added dynamically")
+                        os.environ[env["name"]] = server_env
+                    elif env.get("required"):
+                        missing_keyes.append(env)
+                if len(missing_keyes):
+                    logger.error(f"Can not run agent, missing required env variables: {missing_keyes}")
+                    raise Exception("Missing env variables")
+
+            except requests.exceptions.ConnectionError as e:
+                logger.warning(f"Can not reach server, check if running on {url} : {e}")
+            except (requests.exceptions.HTTPError, Exception) as e:
+                logger.warning(f"Agent can not be registered to beeai server: {e}")

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/src/acp_sdk/server/session.py

@@ -17,5 +17,5 @@ class Session:
     def history(self) -> Iterator[Message]:
         for bundle in self.bundles:
             if bundle.run.status == RunStatus.COMPLETED:
-                yield from bundle.inputs
+                yield from bundle.input
                 yield from bundle.run.output

acp_sdk-0.7.2/src/acp_sdk/server/utils.py

@@ -0,0 +1,49 @@
+import asyncio
+from collections.abc import AsyncGenerator, Coroutine
+from typing import Any, Callable
+
+import httpx
+import requests
+from pydantic import BaseModel
+
+from acp_sdk.server.bundle import RunBundle
+from acp_sdk.server.logging import logger
+
+
+def encode_sse(model: BaseModel) -> str:
+    return f"data: {model.model_dump_json()}\n\n"
+
+
+async def stream_sse(bundle: RunBundle) -> AsyncGenerator[str]:
+    async for event in bundle.stream():
+        yield encode_sse(event)
+
+
+async def async_request_with_retry(
+    request_func: Callable[[httpx.AsyncClient], Coroutine[Any, Any, httpx.Response]],
+    max_retries: int = 5,
+    backoff_factor: float = 1,
+) -> dict[str, Any]:
+    async with httpx.AsyncClient() as client:
+        retries = 0
+        while retries < max_retries:
+            try:
+                response = await request_func(client)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code in [429, 500, 502, 503, 504, 509]:
+                    retries += 1
+                    backoff = backoff_factor * (2 ** (retries - 1))
+                    logger.warning(f"Request retry (try {retries}/{max_retries}), waiting {backoff} seconds...")
+                    await asyncio.sleep(backoff)
+                else:
+                    logger.debug("A non-retryable error was encountered.")
+                    raise
+            except httpx.RequestError:
+                retries += 1
+                backoff = backoff_factor * (2 ** (retries - 1))
+                logger.warning(f"Request retry (try {retries}/{max_retries}), waiting {backoff} seconds...")
+                await asyncio.sleep(backoff)
+
+        raise requests.exceptions.ConnectionError(f"Request failed after {max_retries} retries.")

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/tests/e2e/fixtures/server.py

@@ -17,36 +17,36 @@ def server(request: pytest.FixtureRequest) -> Generator[None]:
     server = Server()
 
     @server.agent()
-    async def echo(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
-        for message in inputs:
+    async def echo(input: list[Message], context: Context) -> AsyncIterator[Message]:
+        for message in input:
             yield message
 
     @server.agent()
     async def awaiter(
-        inputs: list[Message], context: Context
+        input: list[Message], context: Context
     ) -> AsyncGenerator[Message | MessageAwaitRequest, AwaitResume]:
         yield MessageAwaitRequest(message=Message(parts=[]))
         yield MessagePart(content="empty", content_type="text/plain")
 
     @server.agent()
-    async def failer(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+    async def failer(input: list[Message], context: Context) -> AsyncIterator[Message]:
         yield Error(code=ErrorCode.INVALID_INPUT, message="Wrong question buddy!")
 
     @server.agent()
-    async def sessioner(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+    async def sessioner(input: list[Message], context: Context) -> AsyncIterator[Message]:
         assert context.session_id is not None
 
         yield MessagePart(content=str(context.session_id), content_type="text/plain")
 
     @server.agent()
-    async def mime_types(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+    async def mime_types(input: list[Message], context: Context) -> AsyncIterator[Message]:
         yield MessagePart(content="<h1>HTML Content</h1>", content_type="text/html")
         yield MessagePart(content='{"key": "value"}', content_type="application/json")
         yield MessagePart(content="console.log('Hello');", content_type="application/javascript")
         yield MessagePart(content="body { color: red; }", content_type="text/css")
 
     @server.agent()
-    async def base64_encoding(inputs: list[Message], context: Context) -> AsyncIterator[Message]:
+    async def base64_encoding(input: list[Message], context: Context) -> AsyncIterator[Message]:
         yield Message(
             parts=[
                 MessagePart(
@@ -61,7 +61,7 @@ def server(request: pytest.FixtureRequest) -> Generator[None]:
         )
 
     @server.agent()
-    async def artifact_producer(inputs: list[Message], context: Context) -> AsyncGenerator[Message | Artifact, None]:
+    async def artifact_producer(input: list[Message], context: Context) -> AsyncGenerator[Message | Artifact, None]:
         yield MessagePart(content="Processing with artifacts", content_type="text/plain")
         yield Artifact(name="text-result.txt", content_type="text/plain", content="This is a text artifact result")
         yield Artifact(

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/tests/e2e/test_suites/test_runs.py

@@ -19,33 +19,33 @@ from acp_sdk.models import (
 from acp_sdk.models.errors import ACPError
 from acp_sdk.server import Server
 
-inputs = [Message(parts=[MessagePart(content="Hello!")])]
+input = [Message(parts=[MessagePart(content="Hello!")])]
 await_resume = MessageAwaitResume(message=Message(parts=[]))
 
 
 @pytest.mark.asyncio
 async def test_run_sync(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="echo", input=inputs)
+    run = await client.run_sync(agent="echo", input=input)
     assert run.status == RunStatus.COMPLETED
-    assert run.output == inputs
+    assert run.output == input
 
 
 @pytest.mark.asyncio
 async def test_run_async(server: Server, client: Client) -> None:
-    run = await client.run_async(agent="echo", input=inputs)
+    run = await client.run_async(agent="echo", input=input)
     assert run.status == RunStatus.CREATED
 
 
 @pytest.mark.asyncio
 async def test_run_stream(server: Server, client: Client) -> None:
-    event_stream = [event async for event in client.run_stream(agent="echo", input=inputs)]
+    event_stream = [event async for event in client.run_stream(agent="echo", input=input)]
     assert isinstance(event_stream[0], RunCreatedEvent)
     assert isinstance(event_stream[-1], RunCompletedEvent)
 
 
 @pytest.mark.asyncio
 async def test_run_status(server: Server, client: Client) -> None:
-    run = await client.run_async(agent="echo", input=inputs)
+    run = await client.run_async(agent="echo", input=input)
     while run.status in (RunStatus.CREATED, RunStatus.IN_PROGRESS):
         run = await client.run_status(run_id=run.run_id)
     assert run.status == RunStatus.COMPLETED
@@ -53,7 +53,7 @@ async def test_run_status(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_failure(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="failer", input=inputs)
+    run = await client.run_sync(agent="failer", input=input)
     assert run.status == RunStatus.FAILED
     assert run.error is not None
     assert run.error.code == ErrorCode.INVALID_INPUT
@@ -61,7 +61,7 @@ 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=inputs)
+    run = await client.run_sync(agent="awaiter", input=input)
     assert run.status == RunStatus.AWAITING
     run = await client.run_cancel(run_id=run.run_id)
     assert run.status == RunStatus.CANCELLING
@@ -69,7 +69,7 @@ async def test_run_cancel(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_run_resume_sync(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="awaiter", input=inputs)
+    run = await client.run_sync(agent="awaiter", input=input)
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
@@ -79,7 +79,7 @@ async def test_run_resume_sync(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_run_resume_async(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="awaiter", input=inputs)
+    run = await client.run_sync(agent="awaiter", input=input)
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
@@ -89,7 +89,7 @@ async def test_run_resume_async(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_run_resume_stream(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="awaiter", input=inputs)
+    run = await client.run_sync(agent="awaiter", input=input)
     assert run.status == RunStatus.AWAITING
     assert run.await_request is not None
 
@@ -101,15 +101,15 @@ async def test_run_resume_stream(server: Server, client: Client) -> None:
 @pytest.mark.asyncio
 async def test_run_session(server: Server, client: Client) -> None:
     async with client.session() as session:
-        run = await session.run_sync(agent="echo", input=inputs)
-        assert run.output == inputs
-        run = await session.run_sync(agent="echo", input=inputs)
-        assert run.output == inputs + inputs + inputs
+        run = await session.run_sync(agent="echo", input=input)
+        assert run.output == input
+        run = await session.run_sync(agent="echo", input=input)
+        assert run.output == input + input + input
 
 
 @pytest.mark.asyncio
 async def test_mime_types(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="mime_types", input=inputs)
+    run = await client.run_sync(agent="mime_types", input=input)
     assert run.status == RunStatus.COMPLETED
     assert len(run.output) == 1
 
@@ -130,7 +130,7 @@ async def test_mime_types(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_base64_encoding(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="base64_encoding", input=inputs)
+    run = await client.run_sync(agent="base64_encoding", input=input)
     assert run.status == RunStatus.COMPLETED
     assert len(run.output) == 1
 
@@ -150,7 +150,7 @@ async def test_base64_encoding(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_artifacts(server: Server, client: Client) -> None:
-    run = await client.run_sync(agent="artifact_producer", input=inputs)
+    run = await client.run_sync(agent="artifact_producer", input=input)
     assert run.status == RunStatus.COMPLETED
 
     assert len(run.output) == 1
@@ -179,7 +179,7 @@ async def test_artifacts(server: Server, client: Client) -> None:
 
 @pytest.mark.asyncio
 async def test_artifact_streaming(server: Server, client: Client) -> None:
-    events = [event async for event in client.run_stream(agent="artifact_producer", input=inputs)]
+    events = [event async for event in client.run_stream(agent="artifact_producer", input=input)]
 
     assert isinstance(events[0], RunCreatedEvent)
     assert isinstance(events[-1], RunCompletedEvent)
@@ -201,7 +201,7 @@ async def test_artifact_streaming(server: Server, client: Client) -> None:
 @pytest.mark.asyncio
 @pytest.mark.parametrize("server", [timedelta(seconds=5)], indirect=True)
 async def test_run_ttl(server: Server, client: Client) -> None:
-    run = await client.run_async(agent="echo", input=inputs)
+    run = await client.run_async(agent="echo", input=input)
     run = await client.run_status(run_id=run.run_id)
     await asyncio.sleep(6)
     try:
@@ -218,10 +218,10 @@ async def test_run_ttl(server: Server, client: Client) -> None:
 @pytest.mark.parametrize("server", [timedelta(seconds=5)], indirect=True)
 async def test_session_ttl(server: Server, client: Client) -> None:
     async with client.session() as session:
-        run = await session.run_sync(agent="echo", input=inputs)
+        run = await session.run_sync(agent="echo", input=input)
         await asyncio.sleep(3)
-        run = await session.run_sync(agent="echo", input=inputs)
+        run = await session.run_sync(agent="echo", input=input)
         assert len(run.output) == 3
         await asyncio.sleep(3)
-        run = await session.run_sync(agent="echo", input=inputs)
+        run = await session.run_sync(agent="echo", input=input)
         assert len(run.output) == 7  # First run shall be forgotten

acp_sdk-0.7.2/tests/unit/client/test_client.py

@@ -0,0 +1,145 @@
+import json
+import uuid
+
+import pytest
+from acp_sdk.client import Client
+from acp_sdk.models import Agent, AgentsListResponse, Message, MessagePart, Run, RunCompletedEvent
+from acp_sdk.models.models import MessageAwaitResume
+from pytest_httpx import HTTPXMock
+
+mock_agent = Agent(name="mock")
+mock_agents = [mock_agent]
+mock_run = Run(
+    agent_name=mock_agent.name, session_id=uuid.uuid4(), output=[Message(parts=[MessagePart(content="Hello!")])]
+)
+
+
+@pytest.mark.asyncio
+async def test_agents(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(
+        url="http://test/agents", method="GET", content=AgentsListResponse(agents=mock_agents).model_dump_json()
+    )
+
+    async with Client(base_url="http://test") as client:
+        agents = [agent async for agent in client.agents()]
+        assert agents == mock_agents
+
+
+@pytest.mark.asyncio
+async def test_agent(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(
+        url=f"http://test/agents/{mock_agent.name}", method="GET", content=mock_agent.model_dump_json()
+    )
+
+    async with Client(base_url="http://test") as client:
+        agent = await client.agent(name=mock_agent.name)
+        assert agent == mock_agent
+
+
+@pytest.mark.asyncio
+async def test_run_sync(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(url="http://test/runs", method="POST", content=mock_run.model_dump_json())
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_sync("Howdy!", agent=mock_run.agent_name)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_async(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(url="http://test/runs", method="POST", content=mock_run.model_dump_json())
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_async("Howdy!", agent=mock_run.agent_name)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_stream(httpx_mock: HTTPXMock) -> None:
+    mock_event = RunCompletedEvent(run=mock_run)
+    httpx_mock.add_response(
+        url="http://test/runs",
+        method="POST",
+        headers={"content-type": "text/event-stream"},
+        content=f"data: {mock_event.model_dump_json()}\n\n",
+    )
+
+    async with Client(base_url="http://test") as client:
+        async for event in client.run_stream("Howdy!", agent=mock_run.agent_name):
+            assert event == mock_event
+
+
+@pytest.mark.asyncio
+async def test_run_status(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(url=f"http://test/runs/{mock_run.run_id}", method="GET", content=mock_run.model_dump_json())
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_status(run_id=mock_run.run_id)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_cancel(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(
+        url=f"http://test/runs/{mock_run.run_id}/cancel", method="POST", content=mock_run.model_dump_json()
+    )
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_cancel(run_id=mock_run.run_id)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_resume_sync(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(
+        url=f"http://test/runs/{mock_run.run_id}", method="POST", content=mock_run.model_dump_json()
+    )
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_resume_sync(MessageAwaitResume(message=Message(parts=[])), run_id=mock_run.run_id)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_resume_async(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(
+        url=f"http://test/runs/{mock_run.run_id}", method="POST", content=mock_run.model_dump_json()
+    )
+
+    async with Client(base_url="http://test") as client:
+        run = await client.run_resume_async(MessageAwaitResume(message=Message(parts=[])), run_id=mock_run.run_id)
+        assert run == mock_run
+
+
+@pytest.mark.asyncio
+async def test_run_resume_stream(httpx_mock: HTTPXMock) -> None:
+    mock_event = RunCompletedEvent(run=mock_run)
+    httpx_mock.add_response(
+        url=f"http://test/runs/{mock_run.run_id}",
+        method="POST",
+        headers={"content-type": "text/event-stream"},
+        content=f"data: {mock_event.model_dump_json()}\n\n",
+    )
+
+    async with Client(base_url="http://test") as client:
+        async for event in client.run_resume_stream(
+            MessageAwaitResume(message=Message(parts=[])), run_id=mock_run.run_id
+        ):
+            assert event == mock_event
+
+
+@pytest.mark.asyncio
+async def test_session(httpx_mock: HTTPXMock) -> None:
+    httpx_mock.add_response(url="http://test/runs", method="POST", content=mock_run.model_dump_json(), is_reusable=True)
+
+    async with Client(base_url="http://test") as client, client.session(mock_run.session_id) as session:
+        assert session._session_id == mock_run.session_id
+        await session.run_sync("Howdy!", agent=mock_run.agent_name)
+        await client.run_sync("Howdy!", agent=mock_run.agent_name)
+
+    requests = httpx_mock.get_requests()
+    body = json.loads(requests[0].content)
+    assert body["session_id"] == str(mock_run.session_id)
+
+    body = json.loads(requests[1].content)
+    assert body["session_id"] is None

acp_sdk-0.7.2/tests/unit/client/test_utils.py

@@ -0,0 +1,30 @@
+import pytest
+from acp_sdk.client.types import Input
+from acp_sdk.client.utils import input_to_messages
+from acp_sdk.models import Message, MessagePart
+
+
+@pytest.mark.parametrize(
+    "input,messages",
+    [
+        ([], []),
+        ("Hello", [Message(parts=[MessagePart(content="Hello")])]),
+        (["Hello"], [Message(parts=[MessagePart(content="Hello")])]),
+        (MessagePart(content="Hello"), [Message(parts=[MessagePart(content="Hello")])]),
+        ([MessagePart(content="Hello")], [Message(parts=[MessagePart(content="Hello")])]),
+        (Message(parts=[MessagePart(content="Hello")]), [Message(parts=[MessagePart(content="Hello")])]),
+        ([Message(parts=[MessagePart(content="Hello")])], [Message(parts=[MessagePart(content="Hello")])]),
+    ],
+)
+def test_input_to_messages(input: Input, messages: list[Message]) -> None:
+    result = input_to_messages(input)
+    assert result == messages
+
+
+@pytest.mark.parametrize(
+    "input",
+    [["foo", Message(parts=[])], ["foo", MessagePart(content="foo")], [Message(parts=[]), MessagePart(content="foo")]],
+)
+def test_input_to_messages_mixed_input(input: Input) -> None:
+    with pytest.raises(TypeError):
+        input_to_messages(["foo", Message(parts=[])])

{acp_sdk-0.7.0 → acp_sdk-0.7.2}/tests/unit/models/test_models.py

@@ -2,6 +2,25 @@ import pytest
 from acp_sdk.models.models import Message, MessagePart
 
 
+@pytest.mark.parametrize(
+    "first,second,result",
+    [
+        (
+            Message(parts=[MessagePart(content_type="text/plain", content="Foo")]),
+            Message(parts=[MessagePart(content_type="text/plain", content="Bar")]),
+            Message(
+                parts=[
+                    MessagePart(content_type="text/plain", content="Foo"),
+                    MessagePart(content_type="text/plain", content="Bar"),
+                ]
+            ),
+        )
+    ],
+)
+def test_message_add(first: Message, second: Message, result: Message) -> None:
+    assert first + second == result
+
+
 @pytest.mark.parametrize(
     "uncompressed,compressed",
     [

acp_sdk-0.7.0/src/acp_sdk/server/utils.py

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

acp_sdk-0.7.0/tests/unit/client/test_client.py

@@ -1,36 +0,0 @@
-import pytest
-from acp_sdk.client import Client
-from acp_sdk.models import Message, MessagePart, Run, RunCompletedEvent
-from pytest_httpx import HTTPXMock
-
-mock_run = Run(agent_name="mock", output=[Message(parts=[MessagePart(content="Hello!")])])
-
-
-@pytest.mark.asyncio
-async def test_run_sync(httpx_mock: HTTPXMock) -> None:
-    httpx_mock.add_response(content=mock_run.model_dump_json())
-
-    async with Client(base_url="http://localhost:8000") as client:
-        run = await client.run_sync("Howdy!", agent="mock")
-        assert run == mock_run
-
-
-@pytest.mark.asyncio
-async def test_run_async(httpx_mock: HTTPXMock) -> None:
-    httpx_mock.add_response(content=mock_run.model_dump_json())
-
-    async with Client(base_url="http://localhost:8000") as client:
-        run = await client.run_async("Howdy!", agent="mock")
-        assert run == mock_run
-
-
-@pytest.mark.asyncio
-async def test_run_stream(httpx_mock: HTTPXMock) -> None:
-    mock_event = RunCompletedEvent(run=mock_run)
-    httpx_mock.add_response(
-        headers={"content-type": "text/event-stream"}, content=f"data: {mock_event.model_dump_json()}\n\n"
-    )
-
-    async with Client(base_url="http://localhost:8000") as client:
-        async for event in client.run_stream("Howdy!", agent="mock"):
-            assert event == mock_event