acp-sdk 0.1.0rc7__py3-none-any.whl → 0.1.0rc8__py3-none-any.whl

acp_sdk/__init__.py

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

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/models/models.py

@@ -91,13 +91,18 @@ class AwaitResume(BaseModel):
     pass
 
 
+class Artifact(BaseModel):
+    pass
+
+
 class Run(BaseModel):
     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/models/schemas.py

@@ -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
 
 

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/server/app.py

@@ -1,4 +1,3 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
@@ -25,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
@@ -38,6 +37,7 @@ 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
 
 
@@ -51,7 +51,7 @@ def create_app(*agents: Agent) -> FastAPI:
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
         nonlocal executor
-        with ThreadPoolExecutor(max_workers=5) as exec:
+        with ThreadPoolExecutor() as exec:
             executor = exec
             yield
 
@@ -61,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)
@@ -96,17 +97,20 @@ 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)}
 
@@ -140,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(
@@ -164,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
+        await bundle.cancel()
         return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(bundle.run))
 
     return app

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"):
+    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)

acp_sdk/server/server.py

@@ -7,7 +7,7 @@ from typing import Any, Callable
 import uvicorn
 import uvicorn.config
 
-from acp_sdk.models import Message
+from acp_sdk.models import Message, Metadata
 from acp_sdk.server.agent import Agent
 from acp_sdk.server.app import create_app
 from acp_sdk.server.context import Context
@@ -21,7 +21,13 @@ class Server:
         self._agents: list[Agent] = []
         self._server: uvicorn.Server | None = None
 
-    def agent(self, name: str | None = None, description: str | None = None) -> Callable:
+    def agent(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        *,
+        metadata: Metadata | None = None,
+    ) -> Callable:
         """Decorator to register an agent."""
 
         def decorator(fn: Callable) -> Callable:
@@ -49,6 +55,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     async def run(self, input: Message, context: Context) -> AsyncGenerator[RunYield, RunYieldResume]:
                         try:
                             gen: AsyncGenerator[RunYield, RunYieldResume] = (
@@ -72,6 +82,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     async def run(self, input: Message, context: Context) -> Coroutine[RunYield]:
                         return await (fn(input, context) if has_context_param else fn(input))
 
@@ -87,6 +101,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     def run(self, input: Message, context: Context) -> Generator[RunYield, RunYieldResume]:
                         yield from (fn(input, context) if has_context_param else fn(input))
 
@@ -102,6 +120,10 @@ class Server:
                     def description(self) -> str:
                         return description or fn.__doc__ or ""
 
+                    @property
+                    def metadata(self) -> Metadata:
+                        return metadata or Metadata()
+
                     def run(self, input: Message, context: Context) -> RunYield:
                         return fn(input, context) if has_context_param else fn(input)
 

acp_sdk/server/session.py

@@ -0,0 +1,21 @@
+import uuid
+from collections.abc import Iterator
+
+from acp_sdk.models import Message, SessionId
+from acp_sdk.models.models import RunStatus
+from acp_sdk.server.bundle import RunBundle
+
+
+class Session:
+    def __init__(self) -> None:
+        self.id: SessionId = uuid.uuid4()
+        self.bundles: list[RunBundle] = []
+
+    def append(self, bundle: RunBundle) -> None:
+        self.bundles.append(bundle)
+
+    def history(self) -> Iterator[Message]:
+        for bundle in self.bundles:
+            if bundle.run.status == RunStatus.COMPLETED:
+                yield from bundle.inputs
+                yield from bundle.run.outputs

acp_sdk/server/telemetry.py

@@ -1,5 +1,4 @@
 import logging
-from importlib.metadata import version
 
 from opentelemetry import metrics, trace
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
@@ -18,6 +17,8 @@ from opentelemetry.sdk.resources import (
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
+from acp_sdk.version import __version__
+
 root_logger = logging.getLogger()
 
 
@@ -28,7 +29,7 @@ def configure_telemetry() -> None:
         attributes={
             SERVICE_NAME: "acp-server",
             SERVICE_NAMESPACE: "acp",
-            SERVICE_VERSION: version("acp-sdk"),
+            SERVICE_VERSION: __version__,
         }
     )
 
@@ -50,3 +51,7 @@ def configure_telemetry() -> None:
     processor = BatchLogRecordProcessor(OTLPLogExporter())
     logger_provider.add_log_record_processor(processor)
     root_logger.addHandler(LoggingHandler(logger_provider=logger_provider))
+
+
+def get_tracer() -> trace.Tracer:
+    return trace.get_tracer("acp-sdk", __version__)

acp_sdk/version.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("acp-sdk")

{acp_sdk-0.1.0rc7.dist-info → acp_sdk-0.1.0rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.1.0rc7
+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)
 ```
 
@@ -59,13 +59,13 @@ The `server` submodule exposes [fastapi] application factory that makes it easy
 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.run()

acp_sdk-0.1.0rc8.dist-info/RECORD

@@ -0,0 +1,24 @@
+acp_sdk/__init__.py,sha256=tXdAUM9zcmdSKCAkVrOCrGcXcuVS-yuvQUoQwTe9pek,98
+acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acp_sdk/version.py,sha256=Niy83rgvigB4hL_rR-O4ySvI7dj6xnqkyOe_JTymi9s,73
+acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
+acp_sdk/client/client.py,sha256=phsFdVMdVmTcfmzUQUgqzzvq4zNvmEUgW2eL9cFJY2g,6140
+acp_sdk/models/__init__.py,sha256=numSDBDT1QHx7n_Y3Deb5VOvKWcUBxbOEaMwQBSRHxc,151
+acp_sdk/models/errors.py,sha256=rEyaMVvQuBi7fwWe_d0PGGySYsD3FZTluQ-SkC0yhAs,444
+acp_sdk/models/models.py,sha256=LrOZIWwn_6SenSwzz2JeK7Q555vzqjBKFElCifxQgnk,4107
+acp_sdk/models/schemas.py,sha256=LNs3oN1pQ4GD0ceV3-k6X6R39eu33nsAfnW6uEgOP0c,735
+acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
+acp_sdk/server/agent.py,sha256=wMwyB3Ouz361DX-RDPFD61nymoUOTvBIJt3_JU9KmOw,3297
+acp_sdk/server/app.py,sha256=Ys5EN4MzmrwrpBGvycEP5dKEIYkDZmeBMMV1Aq58AU0,5897
+acp_sdk/server/bundle.py,sha256=VUOqzBhwsADkoyPWqXSZ2KG59S3q4LMDfpFVAssnGSM,5386
+acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
+acp_sdk/server/errors.py,sha256=fWlgVsQ5hs_AXwzc-wvy6QgoDWEMRUBlSrfJfhHHMyE,2085
+acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
+acp_sdk/server/server.py,sha256=6iCJZrMfIDtqEmxqFREpPbyAiuxVxbQD73QHiFJ6KpA,9307
+acp_sdk/server/session.py,sha256=0cDr924HC5x2bBNbK9NSKVHAt5A_mi5dK8P4jP_ugq0,629
+acp_sdk/server/telemetry.py,sha256=WIEHK8syOTG9SyWi3Y-cos7CsCF5-IHGiyL9bCaUN0E,1921
+acp_sdk/server/types.py,sha256=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
+acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
+acp_sdk-0.1.0rc8.dist-info/METADATA,sha256=hrIiPuTocgUWerNeGvolLPMY1DgqFqpTshMswZr7sQw,2041
+acp_sdk-0.1.0rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.1.0rc8.dist-info/RECORD,,

acp_sdk-0.1.0rc7.dist-info/RECORD

@@ -1,22 +0,0 @@
-acp_sdk/__init__.py,sha256=XlcAbmvJfvJK5tmOFdxXP19aDwxxdG_jygsTCvXtjTk,43
-acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
-acp_sdk/client/client.py,sha256=W6iXxH65UUODnvt3tnvgdqT_pP1meZUF2HwJpWCM0BM,5029
-acp_sdk/models/__init__.py,sha256=numSDBDT1QHx7n_Y3Deb5VOvKWcUBxbOEaMwQBSRHxc,151
-acp_sdk/models/errors.py,sha256=rEyaMVvQuBi7fwWe_d0PGGySYsD3FZTluQ-SkC0yhAs,444
-acp_sdk/models/models.py,sha256=JhjI_M9GO-1lMrpZJo0IChDVrzUfnDyH5R5hFcqkXEE,3936
-acp_sdk/models/schemas.py,sha256=TM_0aRsBj_9G__zzWPYDx4wAXsGs2RUH57IOTi4--Ek,728
-acp_sdk/server/__init__.py,sha256=CowMcwN_WSsnO_-ZoqWQKtNVfa21MW3X3trZ9haJjaA,329
-acp_sdk/server/agent.py,sha256=SZfJK634d4s8fRh0u1Tc56l58XCRHAh3hq5Hcabh6tI,3442
-acp_sdk/server/app.py,sha256=rf8I2qcaaXoM-36Za8vs3Re7gygcTSMs4MXbMUBJENU,5803
-acp_sdk/server/bundle.py,sha256=LZzinifpbKxEBivoxOSdxUmzEcu3XNAkCiIJc2Ivveg,4987
-acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
-acp_sdk/server/errors.py,sha256=fWlgVsQ5hs_AXwzc-wvy6QgoDWEMRUBlSrfJfhHHMyE,2085
-acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
-acp_sdk/server/server.py,sha256=B1XGptw2kTgaB52klI4aNqDAlmyT2rNpMtKDSCxyVc4,8665
-acp_sdk/server/telemetry.py,sha256=EwmtUrWMYid7XHiX76V1J6CigJPa2NrzEPOX0fBoY3o,1838
-acp_sdk/server/types.py,sha256=2yJPkfUzjVIhHmc0SegGTMqDROe2uFgycb-7CATvYVw,161
-acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
-acp_sdk-0.1.0rc7.dist-info/METADATA,sha256=IoDvdN2USySSWbm7I05iIuuRz-7vCzaBtsnilmgW5IQ,2033
-acp_sdk-0.1.0rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.1.0rc7.dist-info/RECORD,,