acp-sdk 0.9.1__tar.gz → 0.10.0__tar.gz

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/PKG-INFO

@@ -1,27 +1,29 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.9.1
+Version: 0.10.0
 Summary: Agent Communication Protocol SDK
 Author: IBM Corp.
 Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>
 License-Expression: Apache-2.0
 Requires-Python: <4.0,>=3.11
-Requires-Dist: cachetools>=5.5.2
-Requires-Dist: fastapi[standard]>=0.115.8
-Requires-Dist: httpx-sse>=0.4.0
-Requires-Dist: httpx>=0.26.0
-Requires-Dist: janus>=2.0.0
-Requires-Dist: opentelemetry-api>=1.31.1
-Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31.1
+Requires-Dist: cachetools>=5.5
+Requires-Dist: fastapi[standard]>=0.115
+Requires-Dist: httpx-sse>=0.4
+Requires-Dist: httpx>=0.26
+Requires-Dist: janus>=2.0
+Requires-Dist: opentelemetry-api>=1.31
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.31
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.52b1
 Requires-Dist: opentelemetry-instrumentation-httpx>=0.52b1
-Requires-Dist: opentelemetry-sdk>=1.31.1
-Requires-Dist: pydantic>=2.0.0
+Requires-Dist: opentelemetry-sdk>=1.31
+Requires-Dist: psycopg[binary]>=3.2
+Requires-Dist: pydantic>=2.0
+Requires-Dist: redis>=6.1
 Description-Content-Type: text/markdown
 
 # Agent Communication Protocol SDK for Python
 
-Agent Communication Protocol SDK for Python provides allows developers to serve and consume agents over the Agent Communication Protocol.
+Agent Communication Protocol SDK for Python helps developers to serve and consume agents over the Agent Communication Protocol.
 
 ## Prerequisites
 

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/README.md

@@ -1,6 +1,6 @@
 # Agent Communication Protocol SDK for Python
 
-Agent Communication Protocol SDK for Python provides allows developers to serve and consume agents over the Agent Communication Protocol.
+Agent Communication Protocol SDK for Python helps developers to serve and consume agents over the Agent Communication Protocol.
 
 ## Prerequisites
 

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acp-sdk"
-version = "0.9.1"
+version = "0.10.0"
 description = "Agent Communication Protocol SDK"
 license = "Apache-2.0"
 readme = "README.md"
@@ -8,17 +8,19 @@ authors = [{ name = "IBM Corp." }]
 maintainers = [{ name = "Tomas Pilar", email = "thomas7pilar@gmail.com" }]
 requires-python = ">=3.11, <4.0"
 dependencies = [
-    "opentelemetry-api>=1.31.1",
-    "pydantic>=2.0.0",
-    "httpx>=0.26.0",
-    "httpx-sse>=0.4.0",
+    "opentelemetry-api>=1.31",
+    "pydantic>=2.0",
+    "httpx>=0.26",
+    "httpx-sse>=0.4",
     "opentelemetry-instrumentation-httpx>=0.52b1",
-    "fastapi[standard]>=0.115.8",
-    "opentelemetry-exporter-otlp-proto-http>=1.31.1",
+    "fastapi[standard]>=0.115",
+    "opentelemetry-exporter-otlp-proto-http>=1.31",
     "opentelemetry-instrumentation-fastapi>=0.52b1",
-    "opentelemetry-sdk>=1.31.1",
-    "janus>=2.0.0",
-    "cachetools>=5.5.2",
+    "opentelemetry-sdk>=1.31",
+    "janus>=2.0",
+    "cachetools>=5.5",
+    "redis>=6.1",
+    "psycopg[binary]>=3.2",
 ]
 
 [build-system]
@@ -26,4 +28,8 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
-dev = ["pytest-httpx>=0.35.0"]
+dev = [
+    "pytest-httpx>=0.35.0",
+    "pytest-postgresql>=7.0.2",
+    "pytest-redis>=3.1.3",
+]

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/pytest.ini

@@ -2,4 +2,5 @@
 testpaths = tests/e2e
 python_files = test_*.py
 python_functions = test_*
-addopts = -v --strict-markers
+addopts = -v --strict-markers
+redis_datadir = /tmp

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/src/acp_sdk/server/app.py

@@ -1,13 +1,14 @@
+import asyncio
 from collections.abc import AsyncGenerator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
-from datetime import datetime, timedelta
+from datetime import timedelta
 from enum import Enum
 
-from cachetools import TTLCache
 from fastapi import Depends, FastAPI, HTTPException, status
 from fastapi.applications import AppType, Lifespan
 from fastapi.encoders import jsonable_encoder
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
 
 from acp_sdk.models import (
@@ -27,12 +28,11 @@ from acp_sdk.models import (
     RunReadResponse,
     RunResumeRequest,
     RunResumeResponse,
-    SessionId,
 )
 from acp_sdk.models.errors import ACPError
+from acp_sdk.models.models import AwaitResume, RunStatus
 from acp_sdk.models.schemas import PingResponse
 from acp_sdk.server.agent import Agent
-from acp_sdk.server.bundle import RunBundle
 from acp_sdk.server.errors import (
     RequestValidationError,
     StarletteHTTPException,
@@ -41,8 +41,10 @@ from acp_sdk.server.errors import (
     http_exception_handler,
     validation_exception_handler,
 )
+from acp_sdk.server.executor import CancelData, Executor, RunData
 from acp_sdk.server.session import Session
-from acp_sdk.server.utils import stream_sse
+from acp_sdk.server.store import MemoryStore, Store
+from acp_sdk.server.utils import stream_sse, wait_util_stop
 
 
 class Headers(str, Enum):
@@ -51,8 +53,7 @@ class Headers(str, Enum):
 
 def create_app(
     *agents: Agent,
-    run_limit: int = 1000,
-    run_ttl: timedelta = timedelta(hours=1),
+    store: Store | None = None,
     lifespan: Lifespan[AppType] | None = None,
     dependencies: list[Depends] | None = None,
 ) -> FastAPI:
@@ -74,20 +75,37 @@ def create_app(
         dependencies=dependencies,
     )
 
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["https://agentcommunicationprotocol.dev"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+        allow_credentials=True,
+    )
+
     agents: dict[AgentName, Agent] = {agent.name: agent for agent in agents}
-    runs: TTLCache[RunId, RunBundle] = TTLCache(maxsize=run_limit, ttl=run_ttl, timer=datetime.now)
-    sessions: TTLCache[SessionId, Session] = TTLCache(maxsize=run_limit, ttl=run_ttl, timer=datetime.now)
+
+    store = store or MemoryStore(limit=1000, ttl=timedelta(hours=1))
+    run_store = store.as_store(model=RunData, prefix="run_")
+    run_cancel_store = store.as_store(model=CancelData, prefix="run_cancel_")
+    run_resume_store = store.as_store(model=AwaitResume, prefix="run_resume_")
+    session_store = store.as_store(model=Session, prefix="session_")
 
     app.exception_handler(ACPError)(acp_error_handler)
     app.exception_handler(StarletteHTTPException)(http_exception_handler)
     app.exception_handler(RequestValidationError)(validation_exception_handler)
     app.exception_handler(Exception)(catch_all_exception_handler)
 
-    def find_run_bundle(run_id: RunId) -> RunBundle:
-        bundle = runs.get(run_id)
-        if not bundle:
+    async def find_run_data(run_id: RunId) -> RunData:
+        run_data = await run_store.get(run_id)
+        if not run_data:
             raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-        return bundle
+        if run_data.run.status.is_terminal:
+            return run_data
+        cancel_data = await run_cancel_store.get(run_data.key)
+        if cancel_data is not None:
+            run_data.run.status = RunStatus.CANCELLING
+        return run_data
 
     def find_agent(agent_name: AgentName) -> Agent:
         agent = agents.get(agent_name, None)
@@ -117,94 +135,111 @@ def create_app(
     async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
 
-        session = sessions.get(request.session_id, Session(id=request.session_id)) if request.session_id else Session()
+        session = (
+            (await session_store.get(request.session_id)) or Session(id=request.session_id)
+            if request.session_id
+            else Session()
+        )
         nonlocal executor
-        bundle = RunBundle(
-            agent=agent,
+        run_data = RunData(
             run=Run(agent_name=agent.name, session_id=session.id),
             input=request.input,
-            history=list(session.history()),
-            executor=executor,
         )
-        session.append(bundle)
+        await run_store.set(run_data.key, run_data)
 
-        runs[bundle.run.run_id] = bundle
-        sessions[session.id] = session
+        session.append(run_data.run.run_id)
+        await session_store.set(session.id, session)
 
-        headers = {Headers.RUN_ID: str(bundle.run.run_id)}
+        headers = {Headers.RUN_ID: str(run_data.run.run_id)}
+        ready = asyncio.Event()
+
+        Executor(
+            agent=agent,
+            run_data=run_data,
+            history=await session.history(run_store),
+            run_store=run_store,
+            cancel_store=run_cancel_store,
+            resume_store=run_resume_store,
+            executor=executor,
+        ).execute(wait=ready)
 
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
-                    stream_sse(bundle),
+                    stream_sse(run_data, run_store, 0, ready=ready),
                     headers=headers,
                     media_type="text/event-stream",
                 )
             case RunMode.SYNC:
-                await bundle.join()
+                await wait_util_stop(run_data, run_store, ready=ready)
                 return JSONResponse(
                     headers=headers,
-                    content=jsonable_encoder(bundle.run),
+                    content=jsonable_encoder(run_data.run),
                 )
             case RunMode.ASYNC:
+                ready.set()
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
                     headers=headers,
-                    content=jsonable_encoder(bundle.run),
+                    content=jsonable_encoder(run_data.run),
                 )
             case _:
                 raise NotImplementedError()
 
     @app.get("/runs/{run_id}")
     async def read_run(run_id: RunId) -> RunReadResponse:
-        bundle = find_run_bundle(run_id)
+        bundle = await find_run_data(run_id)
         return bundle.run
 
     @app.get("/runs/{run_id}/events")
     async def list_run_events(run_id: RunId) -> RunEventsListResponse:
-        bundle = find_run_bundle(run_id)
+        bundle = await find_run_data(run_id)
         return RunEventsListResponse(events=bundle.events)
 
     @app.post("/runs/{run_id}")
     async def resume_run(run_id: RunId, request: RunResumeRequest) -> RunResumeResponse:
-        bundle = find_run_bundle(run_id)
+        run_data = await find_run_data(run_id)
 
-        if bundle.run.await_request is None:
+        if run_data.run.await_request is None:
             raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"Run {run_id} has no await request")
 
-        if bundle.run.await_request.type != request.await_resume.type:
+        if run_data.run.await_request.type != request.await_resume.type:
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"Run {run_id} is expecting resume of type {bundle.run.await_request.type}",
+                detail=f"Run {run_id} is expecting resume of type {run_data.run.await_request.type}",
             )
 
-        await bundle.resume(request.await_resume)
+        run_data.run.status = RunStatus.IN_PROGRESS
+        await run_store.set(run_data.key, run_data)
+        await run_resume_store.set(run_data.key, request.await_resume)
+
         match request.mode:
             case RunMode.STREAM:
                 return StreamingResponse(
-                    stream_sse(bundle),
+                    stream_sse(run_data, run_store, len(run_data.events)),
                     media_type="text/event-stream",
                 )
             case RunMode.SYNC:
-                await bundle.join()
-                return bundle.run
+                run_data = await wait_util_stop(run_data, run_store)
+                return run_data.run
             case RunMode.ASYNC:
                 return JSONResponse(
                     status_code=status.HTTP_202_ACCEPTED,
-                    content=jsonable_encoder(bundle.run),
+                    content=jsonable_encoder(run_data.run),
                 )
             case _:
                 raise NotImplementedError()
 
     @app.post("/runs/{run_id}/cancel")
     async def cancel_run(run_id: RunId) -> RunCancelResponse:
-        bundle = find_run_bundle(run_id)
-        if bundle.run.status.is_terminal:
+        run_data = await find_run_data(run_id)
+        if run_data.run.status.is_terminal:
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"Run in terminal status {bundle.run.status} can't be cancelled",
+                detail=f"Run in terminal status {run_data.run.status} can't be cancelled",
             )
-        await bundle.cancel()
-        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(bundle.run))
+        await run_cancel_store.set(run_data.key, CancelData())
+        run_data.run.status = RunStatus.CANCELLING
+        return JSONResponse(status_code=status.HTTP_202_ACCEPTED, content=jsonable_encoder(run_data.run))
 
     return app

acp_sdk-0.10.0/src/acp_sdk/server/executor.py

@@ -0,0 +1,198 @@
+import asyncio
+import logging
+from collections.abc import AsyncIterator
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from typing import Self
+
+from pydantic import BaseModel, ValidationError
+
+from acp_sdk.instrumentation import get_tracer
+from acp_sdk.models import (
+    ACPError,
+    AnyModel,
+    AwaitRequest,
+    AwaitResume,
+    Error,
+    ErrorCode,
+    Event,
+    GenericEvent,
+    Message,
+    MessageCompletedEvent,
+    MessageCreatedEvent,
+    MessagePart,
+    MessagePartEvent,
+    Run,
+    RunAwaitingEvent,
+    RunCancelledEvent,
+    RunCompletedEvent,
+    RunCreatedEvent,
+    RunFailedEvent,
+    RunInProgressEvent,
+    RunStatus,
+)
+from acp_sdk.server.agent import Agent
+from acp_sdk.server.logging import logger
+from acp_sdk.server.store import Store
+
+
+class RunData(BaseModel):
+    run: Run
+    input: list[Message]
+    events: list[Event] = []
+
+    @property
+    def key(self) -> str:
+        return str(self.run.run_id)
+
+    async def watch(self, store: Store[Self], *, ready: asyncio.Event | None = None) -> AsyncIterator[Self]:
+        async for data in store.watch(self.key, ready=ready):
+            if data is None:
+                raise RuntimeError("Missing data")
+            yield data
+            if data.run.status.is_terminal:
+                break
+
+
+class CancelData(BaseModel):
+    pass
+
+
+class Executor:
+    def __init__(
+        self,
+        *,
+        agent: Agent,
+        run_data: RunData,
+        history: list[Message],
+        executor: ThreadPoolExecutor,
+        run_store: Store[RunData],
+        cancel_store: Store[CancelData],
+        resume_store: Store[AwaitResume],
+    ) -> None:
+        self.agent = agent
+        self.history = history
+        self.run_data = run_data
+        self.executor = executor
+
+        self.run_store = run_store
+        self.cancel_store = cancel_store
+        self.resume_store = resume_store
+
+        self.logger = logging.LoggerAdapter(logger, {"run_id": str(run_data.run.run_id)})
+
+    def execute(self, *, wait: asyncio.Event) -> None:
+        self.task = asyncio.create_task(self._execute(self.run_data, executor=self.executor, wait=wait))
+        self.watcher = asyncio.create_task(self._watch_for_cancellation())
+
+    async def _push(self) -> None:
+        await self.run_store.set(self.run_data.run.run_id, self.run_data)
+
+    async def _emit(self, event: Event) -> None:
+        freeze = event.model_copy(deep=True)
+        self.run_data.events.append(freeze)
+        await self._push()
+
+    async def _await(self) -> AwaitResume:
+        async for resume in self.resume_store.watch(self.run_data.key):
+            if resume is not None:
+                await self.resume_store.set(self.run_data.key, None)
+                return resume
+
+    async def _watch_for_cancellation(self) -> None:
+        while not self.task.done():
+            try:
+                async for data in self.cancel_store.watch(self.run_data.key):
+                    if data is not None:
+                        self.task.cancel()
+            except Exception:
+                logger.warning("Cancellation watcher failed, restarting")
+
+    async def _execute(self, run_data: RunData, *, executor: ThreadPoolExecutor, wait: asyncio.Event) -> None:
+        with get_tracer().start_as_current_span("run"):
+            in_message = False
+
+            async def flush_message() -> None:
+                nonlocal in_message
+                if in_message:
+                    message = run_data.run.output[-1]
+                    message.completed_at = datetime.now(timezone.utc)
+                    await self._emit(MessageCompletedEvent(message=message))
+                    in_message = False
+
+            try:
+                await wait.wait()
+
+                await self._emit(RunCreatedEvent(run=run_data.run))
+
+                generator = self.agent.execute(
+                    input=self.history + run_data.input, session_id=run_data.run.session_id, executor=executor
+                )
+                self.logger.info("Run started")
+
+                run_data.run.status = RunStatus.IN_PROGRESS
+                await self._emit(RunInProgressEvent(run=run_data.run))
+
+                await_resume = None
+                while True:
+                    next = await generator.asend(await_resume)
+
+                    if isinstance(next, (MessagePart, str)):
+                        if isinstance(next, str):
+                            next = MessagePart(content=next)
+                        if not in_message:
+                            run_data.run.output.append(Message(parts=[], completed_at=None))
+                            in_message = True
+                            await self._emit(MessageCreatedEvent(message=run_data.run.output[-1]))
+                        run_data.run.output[-1].parts.append(next)
+                        await self._emit(MessagePartEvent(part=next))
+                    elif isinstance(next, Message):
+                        await flush_message()
+                        run_data.run.output.append(next)
+                        await self._emit(MessageCreatedEvent(message=next))
+                        for part in next.parts:
+                            await self._emit(MessagePartEvent(part=part))
+                        await self._emit(MessageCompletedEvent(message=next))
+                    elif isinstance(next, AwaitRequest):
+                        run_data.run.await_request = next
+                        run_data.run.status = RunStatus.AWAITING
+                        await self._emit(RunAwaitingEvent(run=run_data.run))
+                        self.logger.info("Run awaited")
+                        await_resume = await self._await()
+                        run_data.run.status = RunStatus.IN_PROGRESS
+                        await self._emit(RunInProgressEvent(run=run_data.run))
+                        self.logger.info("Run resumed")
+                    elif isinstance(next, Error):
+                        raise ACPError(error=next)
+                    elif isinstance(next, BaseException):
+                        raise next
+                    elif next is None:
+                        await flush_message()
+                    elif isinstance(next, BaseModel):
+                        await self._emit(GenericEvent(generic=AnyModel(**next.model_dump())))
+                    else:
+                        try:
+                            generic = AnyModel.model_validate(next)
+                            await self._emit(GenericEvent(generic=generic))
+                        except ValidationError:
+                            raise TypeError("Invalid yield")
+            except StopAsyncIteration:
+                await flush_message()
+                run_data.run.status = RunStatus.COMPLETED
+                run_data.run.finished_at = datetime.now(timezone.utc)
+                await self._emit(RunCompletedEvent(run=run_data.run))
+                self.logger.info("Run completed")
+            except asyncio.CancelledError:
+                run_data.run.status = RunStatus.CANCELLED
+                run_data.run.finished_at = datetime.now(timezone.utc)
+                await self._emit(RunCancelledEvent(run=run_data.run))
+                self.logger.info("Run cancelled")
+            except Exception as e:
+                if isinstance(e, ACPError):
+                    run_data.run.error = e.error
+                else:
+                    run_data.run.error = Error(code=ErrorCode.SERVER_ERROR, message=str(e))
+                run_data.run.status = RunStatus.FAILED
+                run_data.run.finished_at = datetime.now(timezone.utc)
+                await self._emit(RunFailedEvent(run=run_data.run))
+                self.logger.exception("Run failed")

{acp_sdk-0.9.1 → acp_sdk-0.10.0}/src/acp_sdk/server/server.py

@@ -2,7 +2,6 @@ import asyncio
 import os
 from collections.abc import AsyncGenerator, Awaitable
 from contextlib import asynccontextmanager
-from datetime import timedelta
 from typing import Any, Callable
 
 import requests
@@ -16,6 +15,7 @@ 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.store import Store
 from acp_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
 from acp_sdk.server.utils import async_request_with_retry
 
@@ -54,8 +54,7 @@ class Server:
         configure_logger: bool = True,
         configure_telemetry: bool = False,
         self_registration: bool = True,
-        run_limit: int = 1000,
-        run_ttl: timedelta = timedelta(hours=1),
+        store: Store | None = None,
         host: str = "127.0.0.1",
         port: int = 8000,
         uds: str | None = None,
@@ -118,7 +117,7 @@ class Server:
 
         import uvicorn
 
-        app = create_app(*self.agents, lifespan=self.lifespan, run_limit=run_limit, run_ttl=run_ttl)
+        app = create_app(*self.agents, lifespan=self.lifespan, store=store)
 
         if configure_logger:
             configure_logger_func()
@@ -184,8 +183,7 @@ class Server:
         configure_logger: bool = True,
         configure_telemetry: bool = False,
         self_registration: bool = True,
-        run_limit: int = 1000,
-        run_ttl: timedelta = timedelta(hours=1),
+        store: Store | None = None,
         host: str = "127.0.0.1",
         port: int = 8000,
         uds: str | None = None,
@@ -243,8 +241,7 @@ class Server:
                 configure_logger=configure_logger,
                 configure_telemetry=configure_telemetry,
                 self_registration=self_registration,
-                run_limit=run_limit,
-                run_ttl=run_ttl,
+                store=store,
                 host=host,
                 port=port,
                 uds=uds,
@@ -311,7 +308,7 @@ class Server:
 
     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):
+        if os.getenv("PRODUCTION_MODE", "").lower() in ["true", "1"]:
             logger.debug("Agent is not automatically registered in the production mode.")
             return
 

acp_sdk-0.10.0/src/acp_sdk/server/session.py

@@ -0,0 +1,24 @@
+import uuid
+
+from pydantic import BaseModel, Field
+
+from acp_sdk.models import Message, RunId, RunStatus, SessionId
+from acp_sdk.server.executor import RunData
+from acp_sdk.server.store import Store
+
+
+class Session(BaseModel):
+    id: SessionId = Field(default_factory=uuid.uuid4)
+    runs: list[RunId] = []
+
+    def append(self, run_id: RunId) -> None:
+        self.runs.append(run_id)
+
+    async def history(self, store: Store[RunData]) -> list[Message]:
+        history = []
+        for run_id in self.runs:
+            run_data = await store.get(run_id)
+            if run_data is not None and run_data.run.status == RunStatus.COMPLETED:
+                history.extend(run_data.input)
+                history.extend(run_data.run.output)
+        return history

acp_sdk-0.10.0/src/acp_sdk/server/store/__init__.py

@@ -0,0 +1,4 @@
+from acp_sdk.server.store.memory_store import MemoryStore as MemoryStore
+from acp_sdk.server.store.postgresql_store import PostgreSQLStore as PostgreSQLStore
+from acp_sdk.server.store.redis_store import RedisStore as RedisStore
+from acp_sdk.server.store.store import Store as Store

acp_sdk-0.10.0/src/acp_sdk/server/store/memory_store.py

@@ -0,0 +1,35 @@
+import asyncio
+from collections.abc import AsyncIterator
+from datetime import datetime
+from typing import Generic
+
+from cachetools import TTLCache
+
+from acp_sdk.server.store.store import Store, T
+from acp_sdk.server.store.utils import Stringable
+
+
+class MemoryStore(Store[T], Generic[T]):
+    def __init__(self, *, limit: int, ttl: int | None = None) -> None:
+        super().__init__()
+        self._cache: TTLCache[str, T] = TTLCache(maxsize=limit, ttl=ttl, timer=datetime.now)
+        self._event = asyncio.Event()
+
+    async def get(self, key: Stringable) -> T | None:
+        value = self._cache.get(str(key))
+        return value.model_copy(deep=True) if value else value
+
+    async def set(self, key: Stringable, value: T | None) -> None:
+        if value is None:
+            del self._cache[str(key)]
+        else:
+            self._cache[str(key)] = value.model_copy(deep=True)
+        self._event.set()
+
+    async def watch(self, key: Stringable, *, ready: asyncio.Event | None = None) -> AsyncIterator[T | None]:
+        if ready:
+            ready.set()
+        while True:
+            await self._event.wait()
+            self._event.clear()
+            yield await self.get(key)