acp-sdk 0.1.0rc6__tar.gz → 0.1.0rc8__tar.gz

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.1.0rc6
+Version: 0.1.0rc8
 Summary: Agent Communication Protocol SDK
 Requires-Python: <4.0,>=3.11
 Requires-Dist: opentelemetry-api>=1.31.1
@@ -47,7 +47,7 @@ The `client` submodule exposes [httpx]() based client with simple methods for co
 
 ```python
 async with Client(base_url="http://localhost:8000") as client:
-    run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
+    run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
     print(run.output)
 ```
 
@@ -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(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for message in inputs:
+        await asyncio.sleep(0.5)
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield message
 
-    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.0rc6 → acp_sdk-0.1.0rc8}/README.md

@@ -28,7 +28,7 @@ The `client` submodule exposes [httpx]() based client with simple methods for co
 
 ```python
 async with Client(base_url="http://localhost:8000") as client:
-    run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
+    run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
     print(run.output)
 ```
 
@@ -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(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+    """Echoes everything"""
+    for message in inputs:
+        await asyncio.sleep(0.5)
+        yield {"thought": "I should echo everyting"}
+        await asyncio.sleep(0.5)
+        yield message
 
-    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.0rc6 → acp_sdk-0.1.0rc8}/examples/clients/advanced.py

@@ -13,8 +13,8 @@ async def example() -> None:
             # Additional client configuration
         )
     ) as client:
-        run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
-        print(run.output)
+        run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
+        print(run.outputs)
 
 
 if __name__ == "__main__":

acp_sdk-0.1.0rc8/examples/clients/session.py

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

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/examples/clients/simple.py

@@ -9,8 +9,8 @@ from acp_sdk.models import (
 
 async def example() -> None:
     async with Client(base_url="http://localhost:8000") as client:
-        run = await client.run_sync(agent="echo", input=Message(TextMessagePart(content="Howdy!")))
-        print(run.output)
+        run = await client.run_sync(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))])
+        print(run.outputs)
 
 
 if __name__ == "__main__":

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/examples/clients/stream.py

@@ -6,7 +6,7 @@ from acp_sdk.models import Message, TextMessagePart
 
 async def example() -> None:
     async with Client(base_url="http://localhost:8000") as client:
-        async for event in client.run_stream(agent="echo", input=Message(TextMessagePart(content="Howdy!"))):
+        async for event in client.run_stream(agent="echo", inputs=[Message(TextMessagePart(content="Howdy!"))]):
             print(event)
 
 

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/examples/servers/awaiting.py

@@ -13,11 +13,11 @@ server = Server()
 
 
 @server.agent()
-async def awaiting(input: Message, context: Context) -> AsyncGenerator[Message | Await | Any, AwaitResume]:
+async def awaiting(inputs: list[Message], context: Context) -> AsyncGenerator[Message | Await | Any, AwaitResume]:
     """Greets and awaits for more data"""
     yield Message(TextMessagePart(content="Hello!"))
     data = yield Await()
     yield Message(TextMessagePart(content=f"Thanks for {data}"))
 
 
-server()
+server.run()

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/examples/servers/echo.py

@@ -10,13 +10,13 @@ server = Server()
 
 
 @server.agent()
-async def echo(input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
+async def echo(inputs: list[Message], context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
     """Echoes everything"""
-    for part in input:
+    for message in inputs:
         await asyncio.sleep(0.5)
         yield {"thought": "I should echo everyting"}
         await asyncio.sleep(0.5)
-        yield Message(part)
+        yield message
 
 
-server()
+server.run()

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/pyproject.toml

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

acp_sdk-0.1.0rc8/pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+testpaths = tests/e2e
+python_files = test_*.py
+python_functions = test_*
+addopts = -v --strict-markers

acp_sdk-0.1.0rc8/src/acp_sdk/__init__.py

@@ -0,0 +1,2 @@
+from acp_sdk.models import *  # noqa: F403
+from acp_sdk.version import __version__ as __version__

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/src/acp_sdk/client/client.py

@@ -1,4 +1,6 @@
-from collections.abc import AsyncIterator
+import uuid
+from collections.abc import AsyncGenerator, AsyncIterator
+from contextlib import asynccontextmanager
 from types import TracebackType
 from typing import Self
 
@@ -14,6 +16,7 @@ from acp_sdk.models import (
     AgentReadResponse,
     AgentsListResponse,
     AwaitResume,
+    CreatedEvent,
     Error,
     Message,
     Run,
@@ -25,12 +28,20 @@ from acp_sdk.models import (
     RunMode,
     RunResumeRequest,
     RunResumeResponse,
+    SessionId,
 )
 
 
 class Client:
-    def __init__(self, *, base_url: httpx.URL | str = "", client: httpx.AsyncClient | None = None) -> None:
+    def __init__(
+        self,
+        *,
+        base_url: httpx.URL | str = "",
+        session_id: SessionId | None = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
         self.base_url = base_url
+        self.session_id = session_id
 
         self._client = self._init_client(client)
 
@@ -51,6 +62,10 @@ class Client:
     ) -> None:
         await self._client.__aexit__(exc_type, exc_value, traceback)
 
+    @asynccontextmanager
+    async def session(self, session_id: SessionId | None = None) -> AsyncGenerator[Self]:
+        yield Client(client=self._client, session_id=session_id or uuid.uuid4())
+
     async def agents(self) -> AsyncIterator[Agent]:
         response = await self._client.get("/agents")
         self._raise_error(response)
@@ -62,30 +77,51 @@ class Client:
         self._raise_error(response)
         return AgentReadResponse.model_validate(response.json())
 
-    async def run_sync(self, *, agent: AgentName, input: Message) -> Run:
+    async def run_sync(self, *, agent: AgentName, inputs: list[Message]) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.SYNC).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.SYNC,
+                session_id=self.session_id,
+            ).model_dump_json(),
         )
         self._raise_error(response)
-        return RunCreateResponse.model_validate(response.json())
+        response = RunCreateResponse.model_validate(response.json())
+        self._set_session(response)
+        return response
 
-    async def run_async(self, *, agent: AgentName, input: Message) -> Run:
+    async def run_async(self, *, agent: AgentName, inputs: list[Message]) -> Run:
         response = await self._client.post(
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.ASYNC).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.ASYNC,
+                session_id=self.session_id,
+            ).model_dump_json(),
         )
         self._raise_error(response)
-        return RunCreateResponse.model_validate(response.json())
+        response = RunCreateResponse.model_validate(response.json())
+        self._set_session(response)
+        return response
 
-    async def run_stream(self, *, agent: AgentName, input: Message) -> AsyncIterator[RunEvent]:
+    async def run_stream(self, *, agent: AgentName, inputs: list[Message]) -> AsyncIterator[RunEvent]:
         async with aconnect_sse(
             self._client,
             "POST",
             "/runs",
-            json=RunCreateRequest(agent_name=agent, input=input, mode=RunMode.STREAM).model_dump(),
+            content=RunCreateRequest(
+                agent_name=agent,
+                inputs=inputs,
+                mode=RunMode.STREAM,
+                session_id=self.session_id,
+            ).model_dump_json(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
+                if isinstance(event, CreatedEvent):
+                    self._set_session(event.run)
                 yield event
 
     async def run_status(self, *, run_id: RunId) -> Run:
@@ -137,3 +173,6 @@ class Client:
             response.raise_for_status()
         except httpx.HTTPError:
             raise ACPError(Error.model_validate(response.json()))
+
+    def _set_session(self, run: Run) -> None:
+        self.session_id = run.session_id

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/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):
@@ -91,13 +91,18 @@ class AwaitResume(BaseModel):
     pass
 
 
+class Artifact(BaseModel):
+    pass
+
+
 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
     await_: Await | None = Field(None, alias="await")
-    output: Message | None = None
+    outputs: list[Message] = []
+    artifacts: list[Artifact] = []
     error: Error | None = None
 
     model_config = ConfigDict(populate_by_name=True)
@@ -117,6 +122,11 @@ class MessageEvent(BaseModel):
     message: Message
 
 
+class ArtifactEvent(BaseModel):
+    type: Literal["artifact"] = "artifact"
+    artifact: Artifact
+
+
 class AwaitEvent(BaseModel):
     type: Literal["await"] = "await"
     await_: Await | None = Field(alias="await")

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/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
 
@@ -14,7 +14,7 @@ class AgentReadResponse(Agent):
 class RunCreateRequest(BaseModel):
     agent_name: AgentName
     session_id: SessionId | None = None
-    input: Message
+    inputs: list[Message]
     mode: RunMode = RunMode.SYNC
 
 
@@ -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.0rc6 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/agent.py

@@ -31,19 +31,14 @@ class Agent(abc.ABC):
 
     @abc.abstractmethod
     def run(
-        self, input: Message, context: Context
+        self, inputs: list[Message], context: Context
     ) -> (
         AsyncGenerator[RunYield, RunYieldResume] | Generator[RunYield, RunYieldResume] | Coroutine[RunYield] | RunYield
     ):
         pass
 
-    async def session(self, session_id: SessionId | None) -> SessionId | None:
-        if session_id:
-            raise NotImplementedError()
-        return None
-
     async def execute(
-        self, input: Message, session_id: SessionId | None, executor: ThreadPoolExecutor
+        self, inputs: 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()
@@ -53,13 +48,13 @@ class Agent(abc.ABC):
         )
 
         if inspect.isasyncgenfunction(self.run):
-            run = asyncio.create_task(self._run_async_gen(input, context))
+            run = asyncio.create_task(self._run_async_gen(inputs, context))
         elif inspect.iscoroutinefunction(self.run):
-            run = asyncio.create_task(self._run_coro(input, context))
+            run = asyncio.create_task(self._run_coro(inputs, context))
         elif inspect.isgeneratorfunction(self.run):
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, input, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_gen, inputs, context)
         else:
-            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, input, context)
+            run = asyncio.get_running_loop().run_in_executor(executor, self._run_func, inputs, context)
 
         try:
             while True:

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/app.py

@@ -1,9 +1,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
 
@@ -23,7 +24,7 @@ from acp_sdk.models import (
     RunReadResponse,
     RunResumeRequest,
     RunResumeResponse,
-    RunStatus,
+    SessionId,
 )
 from acp_sdk.models.errors import ACPError
 from acp_sdk.server.agent import Agent
@@ -36,16 +37,21 @@ from acp_sdk.server.errors import (
     http_exception_handler,
     validation_exception_handler,
 )
+from acp_sdk.server.session import Session
 from acp_sdk.server.utils import stream_sse
 
 
+class Headers(str, Enum):
+    RUN_ID = "Run-ID"
+
+
 def create_app(*agents: Agent) -> FastAPI:
     executor: ThreadPoolExecutor
 
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
         nonlocal executor
-        with ThreadPoolExecutor(max_workers=5) as exec:
+        with ThreadPoolExecutor() as exec:
             executor = exec
             yield
 
@@ -55,6 +61,7 @@ def create_app(*agents: Agent) -> FastAPI:
 
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
     runs: dict[RunId, RunBundle] = {}
+    sessions: dict[SessionId, Session] = {}
 
     app.exception_handler(ACPError)(acp_error_handler)
     app.exception_handler(StarletteHTTPException)(http_exception_handler)
@@ -90,31 +97,41 @@ def create_app(*agents: Agent) -> FastAPI:
     @app.post("/runs")
     async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
+
+        session = sessions.get(request.session_id, Session()) if request.session_id else Session()
+        nonlocal executor
         bundle = RunBundle(
             agent=agent,
-            run=Run(
-                agent_name=agent.name,
-                session_id=request.session_id,
-            ),
+            run=Run(agent_name=agent.name, session_id=session.id),
+            inputs=request.inputs,
+            history=list(session.history()),
+            executor=executor,
         )
+        session.append(bundle)
 
-        nonlocal executor
-        bundle.task = asyncio.create_task(bundle.execute(request.input, executor=executor))
         runs[bundle.run.run_id] = bundle
+        sessions[session.id] = session
+
+        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()
@@ -127,8 +144,7 @@ def create_app(*agents: Agent) -> FastAPI:
     @app.post("/runs/{run_id}")
     async def resume_run(run_id: RunId, request: RunResumeRequest) -> RunResumeResponse:
         bundle = find_run_bundle(run_id)
-        bundle.stream_queue = asyncio.Queue()  # TODO improve
-        await bundle.await_queue.put(request.await_)
+        await bundle.resume(request.await_)
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
@@ -141,7 +157,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()
@@ -151,11 +167,10 @@ def create_app(*agents: Agent) -> FastAPI:
         bundle = find_run_bundle(run_id)
         if bundle.run.status.is_terminal:
             raise HTTPException(
-                status_code=403,
-                detail=f"Run with terminal status {bundle.run.status} can't be cancelled",
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Run in terminal status {bundle.run.status} can't be cancelled",
             )
-        bundle.task.cancel()
-        bundle.run.status = RunStatus.CANCELLING
-        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=bundle.run.model_dump())
+        await bundle.cancel()
+        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(bundle.run))
 
     return app

{acp_sdk-0.1.0rc6 → acp_sdk-0.1.0rc8}/src/acp_sdk/server/bundle.py

@@ -3,11 +3,12 @@ import logging
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 
-from opentelemetry import trace
 from pydantic import ValidationError
 
 from acp_sdk.models import (
     AnyModel,
+    Artifact,
+    ArtifactEvent,
     Await,
     AwaitEvent,
     AwaitResume,
@@ -27,20 +28,25 @@ from acp_sdk.models import (
 from acp_sdk.models.errors import ErrorCode
 from acp_sdk.server.agent import Agent
 from acp_sdk.server.logging import logger
+from acp_sdk.server.telemetry import get_tracer
 
 
 class RunBundle:
-    def __init__(self, *, agent: Agent, run: Run, task: asyncio.Task | None = None) -> None:
+    def __init__(
+        self, *, agent: Agent, run: Run, inputs: list[Message], history: list[Message], executor: ThreadPoolExecutor
+    ) -> None:
         self.agent = agent
         self.run = run
-        self.task = task
+        self.inputs = inputs
+        self.history = history
 
         self.stream_queue: asyncio.Queue[RunEvent] = asyncio.Queue()
-        self.composed_message = Message()
 
         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))
+
     async def stream(self) -> AsyncGenerator[RunEvent]:
         while True:
             event = await self.stream_queue.get()
@@ -64,20 +70,27 @@ class RunBundle:
     async def resume(self, resume: AwaitResume) -> None:
         self.stream_queue = asyncio.Queue()
         await self.await_queue.put(resume)
+        self.run.status = RunStatus.IN_PROGRESS
+        self.run.await_ = None
+
+    async def cancel(self) -> None:
+        self.task.cancel()
+        self.run.status = RunStatus.CANCELLING
+        self.run.await_ = None
 
     async def join(self) -> None:
         await self.await_or_terminate_event.wait()
 
-    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})
+    async def _execute(self, inputs: 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)})
 
-            await self.emit(CreatedEvent(run=self.run))
             try:
-                self.run.session_id = await self.agent.session(self.run.session_id)
-                run_logger.info("Session loaded")
+                await self.emit(CreatedEvent(run=self.run))
 
-                generator = self.agent.execute(input=input, session_id=self.run.session_id, executor=executor)
+                generator = self.agent.execute(
+                    inputs=self.history + inputs, session_id=self.run.session_id, executor=executor
+                )
                 run_logger.info("Run started")
 
                 self.run.status = RunStatus.IN_PROGRESS
@@ -87,8 +100,11 @@ class RunBundle:
                 while True:
                     next = await generator.asend(await_resume)
                     if isinstance(next, Message):
-                        self.composed_message += next
+                        self.run.outputs.append(next)
                         await self.emit(MessageEvent(message=next))
+                    elif isinstance(next, Artifact):
+                        self.run.artifacts.append(next)
+                        await self.emit(ArtifactEvent(artifact=next))
                     elif isinstance(next, Await):
                         self.run.await_ = next
                         self.run.status = RunStatus.AWAITING
@@ -103,7 +119,6 @@ class RunBundle:
                         )
                         run_logger.info("Run awaited")
                         await_resume = await self.await_()
-                        self.run.status = RunStatus.IN_PROGRESS
                         await self.emit(InProgressEvent(run=self.run))
                         run_logger.info("Run resumed")
                     else:
@@ -113,7 +128,6 @@ class RunBundle:
                         except ValidationError:
                             raise TypeError("Invalid yield")
             except StopAsyncIteration:
-                self.run.output = self.composed_message
                 self.run.status = RunStatus.COMPLETED
                 await self.emit(CompletedEvent(run=self.run))
                 run_logger.info("Run completed")
@@ -126,6 +140,7 @@ class RunBundle:
                 self.run.status = RunStatus.FAILED
                 await self.emit(FailedEvent(run=self.run))
                 run_logger.exception("Run failed")
+                raise
             finally:
                 self.await_or_terminate_event.set()
                 await self.stream_queue.put(None)