acp-sdk 0.1.0rc5__tar.gz → 0.1.0rc7__tar.gz

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.1.0rc5
+Version: 0.1.0rc7
 Summary: Agent Communication Protocol SDK
 Requires-Python: <4.0,>=3.11
 Requires-Dist: opentelemetry-api>=1.31.1
@@ -56,23 +56,19 @@ async with Client(base_url="http://localhost:8000") as client:
 The `server` submodule exposes [fastapi] application factory that makes it easy to expose any agent over ACP.
 
 ```python
-class EchoAgent(Agent):
-    @property
-    def name(self) -> str:
-        return "echo"
+server = Server()
 
-    @property
-    def description(self) -> str:
-        return "Echoes everything"
+@server.agent()
+async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for part in input:
+        await asyncio.sleep(0.5)
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield Message(part)
 
-    async def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
-        for part in input:
-            await asyncio.sleep(0.5)
-            yield {"thought": "I should echo everyting"}
-            yield Message(part)
 
-
-serve(EchoAgent())
+server.run()
 ```
 
 ➡️ Explore more in our [examples library](/python/examples).

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/README.md

@@ -37,23 +37,19 @@ async with Client(base_url="http://localhost:8000") as client:
 The `server` submodule exposes [fastapi] application factory that makes it easy to expose any agent over ACP.
 
 ```python
-class EchoAgent(Agent):
-    @property
-    def name(self) -> str:
-        return "echo"
+server = Server()
 
-    @property
-    def description(self) -> str:
-        return "Echoes everything"
+@server.agent()
+async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for part in input:
+        await asyncio.sleep(0.5)
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield Message(part)
 
-    async def run(self, input: Message, *, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
-        for part in input:
-            await asyncio.sleep(0.5)
-            yield {"thought": "I should echo everyting"}
-            yield Message(part)
 
-
-serve(EchoAgent())
+server.run()
 ```
 
 ➡️ Explore more in our [examples library](/python/examples).

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/examples/servers/awaiting.py

@@ -20,4 +20,4 @@ async def awaiting(input: Message, context: Context) -> AsyncGenerator[Message |
     yield Message(TextMessagePart(content=f"Thanks for {data}"))
 
 
-server.run()
+server()

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/examples/servers/echo.py

@@ -19,4 +19,4 @@ async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, Run
         yield Message(part)
 
 
-server.run()
+server()

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/examples/servers/multi-echo.py

@@ -5,13 +5,11 @@ from acp_sdk.models import (
 )
 from acp_sdk.server import Agent, Context, RunYield, RunYieldResume, Server
 
-# This example showcases several ways to create echo agent using decoratos.
-
 server = Server()
 
 
 @server.agent()
-async def async_gen_echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def async_gen_echo(input: Message) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
     yield {"thought": "I should echo everyting"}
     yield input
@@ -25,10 +23,10 @@ async def async_echo(input: Message, context: Context) -> RunYield:
 
 
 @server.agent()
-def gen_echo(input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
+def gen_echo(input: Message) -> Generator[RunYield, RunYieldResume]:
     """Echoes everything"""
     yield {"thought": "I should echo everyting"}
-    return input
+    yield input
 
 
 @server.agent()
@@ -41,7 +39,7 @@ def sync_echo(input: Message, context: Context) -> RunYield:
 class EchoAgent(Agent):
     @property
     def name(self) -> str:
-        return "class_echo"
+        return "instance_echo"
 
     @property
     def description(self) -> str:
@@ -56,4 +54,4 @@ class EchoAgent(Agent):
 server.register(EchoAgent())
 
 
-server.run()
+server()

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.1.0rc5"
+version = "0.1.0rc7"
 description = "Agent Communication Protocol SDK"
 readme = "README.md"
 authors = []

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/src/acp_sdk/models/models.py

@@ -58,8 +58,8 @@ class Message(RootModel):
 
 
 AgentName = str
-SessionId = str
-RunId = str
+SessionId = uuid.UUID
+RunId = uuid.UUID
 
 
 class RunMode(str, Enum):
@@ -92,7 +92,7 @@ class AwaitResume(BaseModel):
 
 
 class Run(BaseModel):
-    run_id: RunId = str(uuid.uuid4())
+    run_id: RunId = Field(default_factory=uuid.uuid4)
     agent_name: AgentName
     session_id: SessionId | None = None
     status: RunStatus = RunStatus.CREATED

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/src/acp_sdk/models/schemas.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from acp_sdk.models.models import Agent, AgentName, AwaitResume, Message, Run, RunMode, SessionId
 
@@ -26,6 +26,8 @@ class RunResumeRequest(BaseModel):
     await_: AwaitResume = Field(alias="await")
     mode: RunMode
 
+    model_config = ConfigDict(populate_by_name=True)
+
 
 class RunResumeResponse(Run):
     pass

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/src/acp_sdk/server/app.py

@@ -2,8 +2,10 @@ import asyncio
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
+from enum import Enum
 
 from fastapi import FastAPI, HTTPException, status
+from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 
@@ -39,6 +41,10 @@ from acp_sdk.server.errors import (
 from acp_sdk.server.utils import stream_sse
 
 
+class Headers(str, Enum):
+    RUN_ID = "Run-ID"
+
+
 def create_app(*agents: Agent) -> FastAPI:
     executor: ThreadPoolExecutor
 
@@ -102,19 +108,26 @@ def create_app(*agents: Agent) -> FastAPI:
         bundle.task = asyncio.create_task(bundle.execute(request.input, executor=executor))
         runs[bundle.run.run_id] = bundle
 
+        headers = {Headers.RUN_ID: str(bundle.run.run_id)}
+
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
                     stream_sse(bundle),
+                    headers=headers,
                     media_type="text/event-stream",
                 )
             case RunMode.SYNC:
                 await bundle.join()
-                return bundle.run
+                return JSONResponse(
+                    headers=headers,
+                    content=jsonable_encoder(bundle.run),
+                )
             case RunMode.ASYNC:
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
-                    content=bundle.run.model_dump(),
+                    headers=headers,
+                    content=jsonable_encoder(bundle.run),
                 )
             case _:
                 raise NotImplementedError()
@@ -141,7 +154,7 @@ def create_app(*agents: Agent) -> FastAPI:
             case RunMode.ASYNC:
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
-                    content=bundle.run.model_dump(),
+                    content=jsonable_encoder(bundle.run),
                 )
             case _:
                 raise NotImplementedError()
@@ -156,6 +169,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=jsonable_encoder(bundle.run))
 
     return app

{acp_sdk-0.1.0rc5 → acp_sdk-0.1.0rc7}/src/acp_sdk/server/bundle.py

@@ -70,7 +70,7 @@ class RunBundle:
 
     async def execute(self, input: Message, *, executor: ThreadPoolExecutor) -> None:
         with trace.get_tracer(__name__).start_as_current_span("execute"):
-            run_logger = logging.LoggerAdapter(logger, {"run_id": self.run.run_id})
+            run_logger = logging.LoggerAdapter(logger, {"run_id": str(self.run.run_id)})
 
             await self.emit(CreatedEvent(run=self.run))
             try:

acp_sdk-0.1.0rc7/src/acp_sdk/server/server.py

@@ -0,0 +1,243 @@
+import asyncio
+import inspect
+import os
+from collections.abc import AsyncGenerator, Awaitable, Coroutine, Generator
+from typing import Any, Callable
+
+import uvicorn
+import uvicorn.config
+
+from acp_sdk.models import Message
+from acp_sdk.server.agent import Agent
+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:
+    def __init__(self) -> None:
+        self._agents: list[Agent] = []
+        self._server: uvicorn.Server | None = None
+
+    def agent(self, name: str | None = None, description: str | None = None) -> Callable:
+        """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 ""
+
+                    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 ""
+
+                    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 ""
+
+                    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 ""
+
+                    def run(self, input: Message, context: Context) -> RunYield:
+                        return fn(input, context) if has_context_param else fn(input)
+
+                agent = DecoratedAgent()
+
+            self.register(agent)
+            return fn
+
+        return decorator
+
+    def register(self, *agents: Agent) -> None:
+        self._agents.extend(agents)
+
+    def run(
+        self,
+        configure_logger: bool = True,
+        configure_telemetry: bool = False,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        uds: str | None = None,
+        fd: int | None = None,
+        loop: uvicorn.config.LoopSetupType = "auto",
+        http: type[asyncio.Protocol] | uvicorn.config.HTTPProtocolType = "auto",
+        ws: type[asyncio.Protocol] | uvicorn.config.WSProtocolType = "auto",
+        ws_max_size: int = 16 * 1024 * 1024,
+        ws_max_queue: int = 32,
+        ws_ping_interval: float | None = 20.0,
+        ws_ping_timeout: float | None = 20.0,
+        ws_per_message_deflate: bool = True,
+        lifespan: uvicorn.config.LifespanType = "auto",
+        env_file: str | os.PathLike[str] | None = None,
+        log_config: dict[str, Any]
+        | str
+        | uvicorn.config.RawConfigParser
+        | uvicorn.config.IO[Any]
+        | None = uvicorn.config.LOGGING_CONFIG,
+        log_level: str | int | None = None,
+        access_log: bool = True,
+        use_colors: bool | None = None,
+        interface: uvicorn.config.InterfaceType = "auto",
+        reload: bool = False,
+        reload_dirs: list[str] | str | None = None,
+        reload_delay: float = 0.25,
+        reload_includes: list[str] | str | None = None,
+        reload_excludes: list[str] | str | None = None,
+        workers: int | None = None,
+        proxy_headers: bool = True,
+        server_header: bool = True,
+        date_header: bool = True,
+        forwarded_allow_ips: list[str] | str | None = None,
+        root_path: str = "",
+        limit_concurrency: int | None = None,
+        limit_max_requests: int | None = None,
+        backlog: int = 2048,
+        timeout_keep_alive: int = 5,
+        timeout_notify: int = 30,
+        timeout_graceful_shutdown: int | None = None,
+        callback_notify: Callable[..., Awaitable[None]] | None = None,
+        ssl_keyfile: str | os.PathLike[str] | None = None,
+        ssl_certfile: str | os.PathLike[str] | None = None,
+        ssl_keyfile_password: str | None = None,
+        ssl_version: int = uvicorn.config.SSL_PROTOCOL_VERSION,
+        ssl_cert_reqs: int = uvicorn.config.ssl.CERT_NONE,
+        ssl_ca_certs: str | None = None,
+        ssl_ciphers: str = "TLSv1",
+        headers: list[tuple[str, str]] | None = None,
+        factory: bool = False,
+        h11_max_incomplete_event_size: int | None = None,
+    ) -> None:
+        if self._server:
+            raise RuntimeError("The server is already running")
+
+        import uvicorn
+
+        if configure_logger:
+            configure_logger_func()
+        if configure_telemetry:
+            configure_telemetry_func()
+
+        config = uvicorn.Config(
+            create_app(*self._agents),
+            host,
+            port,
+            uds,
+            fd,
+            loop,
+            http,
+            ws,
+            ws_max_size,
+            ws_max_queue,
+            ws_ping_interval,
+            ws_ping_timeout,
+            ws_per_message_deflate,
+            lifespan,
+            env_file,
+            log_config,
+            log_level,
+            access_log,
+            use_colors,
+            interface,
+            reload,
+            reload_dirs,
+            reload_delay,
+            reload_includes,
+            reload_excludes,
+            workers,
+            proxy_headers,
+            server_header,
+            date_header,
+            forwarded_allow_ips,
+            root_path,
+            limit_concurrency,
+            limit_max_requests,
+            backlog,
+            timeout_keep_alive,
+            timeout_notify,
+            timeout_graceful_shutdown,
+            callback_notify,
+            ssl_keyfile,
+            ssl_certfile,
+            ssl_keyfile_password,
+            ssl_version,
+            ssl_cert_reqs,
+            ssl_ca_certs,
+            ssl_ciphers,
+            headers,
+            factory,
+            h11_max_incomplete_event_size,
+        )
+        self._server = uvicorn.Server(config)
+        self._server.run()
+
+    @property
+    def should_exit(self) -> bool:
+        return self._server.should_exit if self._server else False
+
+    @should_exit.setter
+    def should_exit(self, value: bool) -> None:
+        self._server.should_exit = value

acp_sdk-0.1.0rc7/tests/test_e2e.py

@@ -0,0 +1,113 @@
+import time
+from collections.abc import AsyncGenerator, AsyncIterator, Generator
+from threading import Thread
+
+import pytest
+import pytest_asyncio
+from acp_sdk.client import Client
+from acp_sdk.models import Await, AwaitResume, CompletedEvent, CreatedEvent, Message, RunStatus, TextMessagePart
+from acp_sdk.models.models import InProgressEvent
+from acp_sdk.server import Context, Server
+
+PORT = 8000
+
+
+@pytest.fixture
+def server() -> Generator[None]:
+    server = Server()
+
+    @server.agent()
+    async def echo(input: Message, context: Context) -> AsyncIterator[Message]:
+        yield input
+
+    @server.agent()
+    async def awaiter(input: Message, context: Context) -> AsyncGenerator[Message | Await, AwaitResume]:
+        yield Await()
+        yield Message(TextMessagePart(content="empty"))
+
+    thread = Thread(target=server.run, kwargs={"port": PORT}, daemon=True)
+    thread.start()
+
+    time.sleep(1)
+
+    yield
+
+    server.should_exit = True
+    thread.join(timeout=2)
+
+
+@pytest_asyncio.fixture
+async def client() -> AsyncIterator[Client]:
+    async with Client(base_url=f"http://localhost:{PORT}") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_run_sync(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+    run = await client.run_sync(agent="echo", input=input)
+    assert run.status == RunStatus.COMPLETED
+    assert run.output == input
+
+
+@pytest.mark.asyncio
+async def test_run_async(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+    run = await client.run_async(agent="echo", input=input)
+    assert run.status == RunStatus.CREATED
+    assert run.output is None
+
+
+@pytest.mark.asyncio
+async def test_run_stream(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+    event_stream = [event async for event in client.run_stream(agent="echo", input=input)]
+    assert isinstance(event_stream[0], CreatedEvent)
+    assert isinstance(event_stream[-1], CompletedEvent)
+
+
+@pytest.mark.asyncio
+async def test_run_status(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+    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
+
+
+@pytest.mark.asyncio
+async def test_run_resume_sync(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+
+    run = await client.run_sync(agent="awaiter", input=input)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    run = await client.run_resume_sync(run_id=run.run_id, await_=AwaitResume())
+    assert run.status == RunStatus.COMPLETED
+    assert run.output is not None
+
+
+@pytest.mark.asyncio
+async def test_run_resume_async(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+
+    run = await client.run_sync(agent="awaiter", input=input)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    run = await client.run_resume_async(run_id=run.run_id, await_=AwaitResume())
+    assert run.status == RunStatus.AWAITING
+
+
+@pytest.mark.asyncio
+async def test_run_resume_stream(server: Server, client: Client) -> None:
+    input = Message(TextMessagePart(content="Hello!"))
+
+    run = await client.run_sync(agent="awaiter", input=input)
+    assert run.status == RunStatus.AWAITING
+    assert run.await_ is not None
+
+    event_stream = [event async for event in client.run_resume_stream(run_id=run.run_id, await_=AwaitResume())]
+    assert isinstance(event_stream[0], InProgressEvent)
+    assert isinstance(event_stream[-1], CompletedEvent)

acp_sdk-0.1.0rc5/src/acp_sdk/server/server.py

@@ -1,120 +0,0 @@
-import inspect
-from collections.abc import AsyncGenerator, Coroutine, Generator
-from typing import Any, Callable
-
-from acp_sdk.models import Message
-from acp_sdk.server.agent import Agent
-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:
-    def __init__(self) -> None:
-        self.agents: list[Agent] = []
-
-    def agent(self, name: str | None = None, description: str | None = None) -> Callable:
-        """Decorator to register an agent."""
-
-        def decorator(fn: Callable) -> Callable:
-            # check agent's function signature
-            signature = inspect.signature(fn)
-            parameters = list(signature.parameters.values())
-
-            # validate agent's function
-            if inspect.isasyncgenfunction(fn):
-                if len(parameters) != 2:
-                    raise TypeError(
-                        "The agent generator function must have one 'input' argument and one 'context' argument"
-                    )
-            else:
-                if len(parameters) != 2:
-                    raise TypeError("The agent function must have one 'input' argument and one 'context' argument")
-
-            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 ""
-
-                    async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
-                        try:
-                            gen: AsyncGenerator[RunYield, RunYieldResume] = fn(input, context)
-                            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 ""
-
-                    async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
-                        return await fn(input, context)
-
-                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 ""
-
-                    def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
-                        yield from fn(input, context)
-
-                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 ""
-
-                    def run(self, input: Message, context: Context) -> RunYield:
-                        return fn(input, context)
-
-                agent = DecoratedAgent()
-
-            self.register(agent)
-            return fn
-
-        return decorator
-
-    def register(self, *agents: Agent) -> None:
-        self.agents.extend(agents)
-
-    def run(self, configure_logger: bool = True, configure_telemetry: bool = False, **kwargs: dict[str, Any]) -> None:
-        import uvicorn
-
-        if configure_logger:
-            configure_logger_func()
-        if configure_telemetry:
-            configure_telemetry_func()
-
-        uvicorn.run(create_app(*self.agents), **kwargs)