opencode-a2a 0.4.1__tar.gz → 0.5.0__tar.gz

{opencode_a2a-0.4.1/src/opencode_a2a.egg-info → opencode_a2a-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-a2a
-Version: 0.4.1
+Version: 0.5.0
 Summary: OpenCode A2A runtime
 Author: liujuanjuan1984@Intelligent-Internet
 License-Expression: Apache-2.0
@@ -20,10 +20,12 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: a2a-sdk==0.3.25
+Requires-Dist: aiosqlite<1.0,>=0.20
 Requires-Dist: fastapi<1.0,>=0.110
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: pydantic<3.0,>=2.6
 Requires-Dist: pydantic-settings<3.0,>=2.2
+Requires-Dist: sqlalchemy<3.0,>=2.0
 Requires-Dist: sse-starlette<4.0,>=2.1
 Requires-Dist: uvicorn<1.0,>=0.29
 Provides-Extra: dev

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/docs/guide.md

@@ -55,10 +55,10 @@ Key variables to understand protocol behavior:
   also logged with preview truncation controlled by `A2A_LOG_BODY_LIMIT`.
 - `A2A_MAX_REQUEST_BODY_BYTES`: runtime request-body limit. Oversized requests
   return HTTP `413`.
-- `A2A_SESSION_CACHE_TTL_SECONDS` / `A2A_SESSION_CACHE_MAXSIZE`: session cache
-  behavior for `(identity, contextId) -> session_id`.
+- `A2A_PENDING_SESSION_CLAIM_TTL_SECONDS`: lease duration for pending preferred
+  session claims before they expire and stop blocking other identities.
 - `A2A_INTERRUPT_REQUEST_TTL_SECONDS`: active retention window for the
-  in-memory interrupt request binding cache used by `a2a.interrupt.*`
+  interrupt request binding registry used by `a2a.interrupt.*`
   callback methods. Default: `10800` seconds (`180` minutes).
 - `A2A_INTERRUPT_REQUEST_TOMBSTONE_TTL_SECONDS`: retention window for expired
   interrupt tombstones after active TTL has elapsed. During this window,
@@ -76,6 +76,12 @@ Key variables to understand protocol behavior:
 - `A2A_CLIENT_BEARER_TOKEN`: optional bearer token attached to outbound peer
   calls made by the embedded A2A client and `a2a_call` tool path.
 - `A2A_CLIENT_SUPPORTED_TRANSPORTS`: ordered outbound transport preference list.
+- `A2A_TASK_STORE_BACKEND`: runtime state backend. Supported values: `database`,
+  `memory`. Default: `database`.
+- `A2A_TASK_STORE_DATABASE_URL`: database URL used by the default durable
+  backend. Default: `sqlite+aiosqlite:///./opencode-a2a.db`.
+- `A2A_TASK_STORE_TABLE_NAME` / `A2A_TASK_STORE_CREATE_TABLE`: database task
+  store table name and whether to auto-create database tables on startup.
 - Runtime authentication is bearer-token only via `A2A_BEARER_TOKEN`.
 - The same outbound client flags are also honored by the server-side embedded
   A2A client used for peer calls and `a2a_call` tool execution:
@@ -157,6 +163,30 @@ OPENCODE_WORKSPACE_ROOT=/abs/path/to/workspace \
 opencode-a2a
 ```
 
+By default, the service uses a SQLite-backed durable state store:
+
+```bash
+OPENCODE_BASE_URL=http://127.0.0.1:4096 \
+A2A_BEARER_TOKEN=dev-token \
+A2A_TASK_STORE_DATABASE_URL=sqlite+aiosqlite:///./opencode-a2a.db \
+opencode-a2a
+```
+
+With the default `database` backend, the service persists:
+
+- task records
+- session binding / ownership state
+- interrupt request bindings and tombstones
+
+In-flight asyncio locks, outbound A2A client caches, and stream-local
+aggregation buffers remain process-local runtime state.
+
+To opt into an ephemeral development profile, set:
+
+```bash
+A2A_TASK_STORE_BACKEND=memory
+```
+
 ## Troubleshooting Provider Auth State
 
 If one deployment works while another fails against the same upstream provider,
@@ -825,8 +855,8 @@ Notes:
 
 - `request_id` must be a live interrupt request observed from stream metadata
   (`metadata.shared.interrupt.request_id`).
-- The server keeps an in-memory interrupt binding cache; callbacks with unknown
-  or expired `request_id` are rejected.
+- The server keeps an interrupt binding registry; callbacks with unknown or
+  expired `request_id` are rejected.
 - The cache retention windows are controlled by
   `A2A_INTERRUPT_REQUEST_TTL_SECONDS` (default: `10800` seconds / `180`
   minutes) and `A2A_INTERRUPT_REQUEST_TOMBSTONE_TTL_SECONDS` (default: `600`

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/pyproject.toml

@@ -25,10 +25,12 @@ classifiers = [
 ]
 dependencies = [
     "a2a-sdk==0.3.25",
+    "aiosqlite>=0.20,<1.0",
     "fastapi>=0.110,<1.0",
     "httpx>=0.27,<1.0",
     "pydantic>=2.6,<3.0",
     "pydantic-settings>=2.2,<3.0",
+    "sqlalchemy>=2.0,<3.0",
     "sse-starlette>=2.1,<4.0",
     "uvicorn>=0.29,<1.0",
 ]

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/config.py

@@ -35,6 +35,7 @@ WriteAccessScope = Literal[
     "custom",
 ]
 OutsideWorkspaceAccess = Literal["unknown", "allowed", "disallowed", "custom"]
+TaskStoreBackend = Literal["memory", "database"]
 
 
 def _parse_declared_list(value: Any) -> tuple[str, ...]:
@@ -132,9 +133,11 @@ class Settings(BaseSettings):
     a2a_port: int = Field(default=8000, alias="A2A_PORT")
     a2a_bearer_token: str = Field(..., min_length=1, alias="A2A_BEARER_TOKEN")
 
-    # Session cache settings
-    a2a_session_cache_ttl_seconds: int = Field(default=3600, alias="A2A_SESSION_CACHE_TTL_SECONDS")
-    a2a_session_cache_maxsize: int = Field(default=10_000, alias="A2A_SESSION_CACHE_MAXSIZE")
+    a2a_pending_session_claim_ttl_seconds: float = Field(
+        default=30.0,
+        gt=0.0,
+        alias="A2A_PENDING_SESSION_CLAIM_TTL_SECONDS",
+    )
     a2a_interrupt_request_ttl_seconds: float = Field(
         default=10_800.0,
         ge=0.0,
@@ -176,7 +179,30 @@ class Settings(BaseSettings):
         alias="A2A_CLIENT_SUPPORTED_TRANSPORTS",
     )
 
+    # Task store settings
+    a2a_task_store_backend: TaskStoreBackend = Field(
+        default="database",
+        alias="A2A_TASK_STORE_BACKEND",
+    )
+    a2a_task_store_database_url: str | None = Field(
+        default="sqlite+aiosqlite:///./opencode-a2a.db",
+        alias="A2A_TASK_STORE_DATABASE_URL",
+    )
+    a2a_task_store_table_name: str = Field(
+        default="tasks",
+        min_length=1,
+        alias="A2A_TASK_STORE_TABLE_NAME",
+    )
+    a2a_task_store_create_table: bool = Field(
+        default=True,
+        alias="A2A_TASK_STORE_CREATE_TABLE",
+    )
+
     @model_validator(mode="after")
     def _validate_sandbox_policy(self) -> Settings:
         SandboxPolicy.from_settings(self).validate_configuration()
+        if self.a2a_task_store_backend == "database" and not self.a2a_task_store_database_url:
+            raise ValueError(
+                "A2A_TASK_STORE_DATABASE_URL is required when A2A_TASK_STORE_BACKEND=database"
+            )
         return self

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/contracts/extensions.py

@@ -450,8 +450,9 @@ def build_session_binding_extension_params(
                 "message to that upstream session."
             ),
             (
-                "Otherwise, the server will create a new upstream session and cache "
-                "the (identity, contextId)->session_id mapping in memory with TTL."
+                "Otherwise, the server will create a new upstream session and retain "
+                "the (identity, contextId)->session_id mapping according to the "
+                "configured task/state store backend and TTL policy."
             ),
         ],
     }

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/execution/executor.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from ..server.application import A2AClientManager
+    from ..server.state_store import SessionStateRepository
 
 import httpx
 from a2a.server.agent_execution import AgentExecutor, RequestContext
@@ -72,7 +73,7 @@ from .stream_state import (
     _TTLCache,
 )
 from .tool_error_mapping import build_tool_error, map_a2a_tool_exception
-from .upstream_errors import (
+from .upstream_error_translator import (
     _await_stream_terminal_signal,
     _extract_upstream_error_detail,
     _format_inband_upstream_error,
@@ -530,7 +531,9 @@ class OpencodeAgentExecutor(AgentExecutor):
         cancel_abort_timeout_seconds: float = 2.0,
         session_cache_ttl_seconds: int = 3600,
         session_cache_maxsize: int = 10_000,
+        pending_session_claim_ttl_seconds: float = 30.0,
         a2a_client_manager: A2AClientManager | None = None,
+        session_state_repository: SessionStateRepository | None = None,
     ) -> None:
         self._client = client
         self._streaming_enabled = streaming_enabled
@@ -544,6 +547,8 @@ class OpencodeAgentExecutor(AgentExecutor):
             client=client,
             session_cache_ttl_seconds=session_cache_ttl_seconds,
             session_cache_maxsize=session_cache_maxsize,
+            pending_session_claim_ttl_seconds=pending_session_claim_ttl_seconds,
+            state_repository=session_state_repository,
         )
         self._stream_runtime = StreamRuntime(
             client=client,

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/execution/session_manager.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 
-from .stream_state import _TTLCache
+from ..server.state_store import MemorySessionStateRepository, SessionStateRepository
 
 
 class SessionManager:
@@ -12,18 +12,15 @@ class SessionManager:
         client,
         session_cache_ttl_seconds: int = 3600,
         session_cache_maxsize: int = 10_000,
+        pending_session_claim_ttl_seconds: float = 30.0,
+        state_repository: SessionStateRepository | None = None,
     ) -> None:
         self._client = client
-        self._sessions = _TTLCache(
+        self._state_repository = state_repository or MemorySessionStateRepository(
             ttl_seconds=session_cache_ttl_seconds,
             maxsize=session_cache_maxsize,
+            pending_claim_ttl_seconds=pending_session_claim_ttl_seconds,
         )
-        self._session_owners = _TTLCache(
-            ttl_seconds=session_cache_ttl_seconds,
-            maxsize=session_cache_maxsize,
-            refresh_on_get=True,
-        )
-        self._pending_session_claims: dict[str, str] = {}
         self._lock = asyncio.Lock()
         self._inflight_session_creates: dict[tuple[str, str], asyncio.Task[str]] = {}
         self._session_locks: dict[str, asyncio.Lock] = {}
@@ -43,13 +40,21 @@ class SessionManager:
                 session_id=preferred_session_id,
             )
             if not pending_claim:
-                self._sessions.set((identity, context_id), preferred_session_id)
+                async with self._lock:
+                    await self._state_repository.set_session(
+                        identity=identity,
+                        context_id=context_id,
+                        session_id=preferred_session_id,
+                    )
             return preferred_session_id, pending_claim
 
         task: asyncio.Task[str] | None = None
         cache_key = (identity, context_id)
         async with self._lock:
-            existing = self._sessions.get(cache_key)
+            existing = await self._state_repository.get_session(
+                identity=cache_key[0],
+                context_id=cache_key[1],
+            )
             if existing:
                 return existing, False
             task = self._inflight_session_creates.get(cache_key)
@@ -68,14 +73,18 @@ class SessionManager:
             raise
 
         async with self._lock:
-            owner = self._session_owners.get(session_id)
+            owner = await self._state_repository.get_owner(session_id=session_id)
             if owner and owner != identity:
                 if self._inflight_session_creates.get(cache_key) is task:
                     self._inflight_session_creates.pop(cache_key, None)
                 raise PermissionError(f"Session {session_id} is not owned by you")
-            self._sessions.set(cache_key, session_id)
+            await self._state_repository.set_session(
+                identity=cache_key[0],
+                context_id=cache_key[1],
+                session_id=session_id,
+            )
             if not owner:
-                self._session_owners.set(session_id, identity)
+                await self._state_repository.set_owner(session_id=session_id, identity=identity)
             if self._inflight_session_creates.get(cache_key) is task:
                 self._inflight_session_creates.pop(cache_key, None)
         return session_id, False
@@ -89,37 +98,45 @@ class SessionManager:
     ) -> None:
         await self.finalize_session_claim(identity=identity, session_id=session_id)
         async with self._lock:
-            self._sessions.set((identity, context_id), session_id)
+            await self._state_repository.set_session(
+                identity=identity,
+                context_id=context_id,
+                session_id=session_id,
+            )
 
     async def claim_preferred_session(self, *, identity: str, session_id: str) -> bool:
         async with self._lock:
-            owner = self._session_owners.get(session_id)
-            pending_owner = self._pending_session_claims.get(session_id)
+            owner = await self._state_repository.get_owner(session_id=session_id)
+            pending_owner = await self._state_repository.get_pending_claim(session_id=session_id)
             if owner and owner != identity:
                 raise PermissionError(f"Session {session_id} is not owned by you")
             if pending_owner and pending_owner != identity:
                 raise PermissionError(f"Session {session_id} is not owned by you")
             if owner == identity:
                 return False
-            self._pending_session_claims[session_id] = identity
+            await self._state_repository.set_pending_claim(session_id=session_id, identity=identity)
             return True
 
     async def finalize_session_claim(self, *, identity: str, session_id: str) -> None:
         async with self._lock:
-            owner = self._session_owners.get(session_id)
-            pending_owner = self._pending_session_claims.get(session_id)
+            owner = await self._state_repository.get_owner(session_id=session_id)
+            pending_owner = await self._state_repository.get_pending_claim(session_id=session_id)
             if owner and owner != identity:
                 raise PermissionError(f"Session {session_id} is not owned by you")
             if pending_owner and pending_owner != identity:
                 raise PermissionError(f"Session {session_id} is not owned by you")
-            self._session_owners.set(session_id, identity)
-            if self._pending_session_claims.get(session_id) == identity:
-                self._pending_session_claims.pop(session_id, None)
+            await self._state_repository.set_owner(session_id=session_id, identity=identity)
+            await self._state_repository.clear_pending_claim(
+                session_id=session_id,
+                identity=identity,
+            )
 
     async def release_preferred_session_claim(self, *, identity: str, session_id: str) -> None:
         async with self._lock:
-            if self._pending_session_claims.get(session_id) == identity:
-                self._pending_session_claims.pop(session_id, None)
+            await self._state_repository.clear_pending_claim(
+                session_id=session_id,
+                identity=identity,
+            )
 
     async def get_session_lock(self, session_id: str) -> asyncio.Lock:
         async with self._lock:
@@ -136,5 +153,5 @@ class SessionManager:
         context_id: str,
     ) -> asyncio.Task[str] | None:
         async with self._lock:
-            self._sessions.pop((identity, context_id))
+            await self._state_repository.pop_session(identity=identity, context_id=context_id)
             return self._inflight_session_creates.pop((identity, context_id), None)

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/execution/stream_events.py

@@ -8,7 +8,7 @@ from typing import Any
 from a2a.types import TaskState
 
 from .stream_state import BlockType
-from .upstream_errors import (
+from .upstream_error_translator import (
     _format_inband_upstream_error,
     _format_stream_terminal_error,
     _StreamTerminalSignal,

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/execution/stream_runtime.py

@@ -45,7 +45,7 @@ from .stream_state import (
     _StreamOutputState,
     _StreamPartState,
 )
-from .upstream_errors import _StreamTerminalSignal
+from .upstream_error_translator import _StreamTerminalSignal
 
 logger = logging.getLogger("opencode_a2a.execution.executor")
 
@@ -429,7 +429,7 @@ class StreamRuntime:
                                         None,
                                     )
                                     if callable(remember_request):
-                                        remember_request(
+                                        await remember_request(
                                             request_id=request_id,
                                             session_id=session_id,
                                             interrupt_type=asked["interrupt_type"],
@@ -456,7 +456,7 @@ class StreamRuntime:
                                     None,
                                 )
                                 if callable(discard_request):
-                                    discard_request(resolved_request_id)
+                                    await discard_request(resolved_request_id)
                                 if cleared_pending:
                                     await _emit_interrupt_status(
                                         state=TaskState.working,

opencode_a2a-0.4.1/src/opencode_a2a/execution/upstream_errors.py → opencode_a2a-0.5.0/src/opencode_a2a/execution/upstream_error_translator.py

@@ -7,13 +7,13 @@ from dataclasses import dataclass
 import httpx
 from a2a.types import TaskState
 
-from ..error_taxonomy import (
+from ..opencode_upstream_client import UpstreamContractError
+from ..upstream_taxonomy import (
     extract_upstream_error_detail as _extract_upstream_error_detail,
 )
-from ..error_taxonomy import (
+from ..upstream_taxonomy import (
     resolve_upstream_http_error_profile as _resolve_upstream_error_profile,
 )
-from ..opencode_upstream_client import UpstreamContractError
 
 
 @dataclass(frozen=True)

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/jsonrpc/application.py

@@ -22,7 +22,7 @@ from ..contracts.extensions import (
     SESSION_QUERY_ERROR_BUSINESS_CODES,
 )
 from ..opencode_upstream_client import OpencodeUpstreamClient, UpstreamContractError
-from .error_mapping import (
+from .error_responses import (
     interrupt_not_found_error,
     invalid_params_error,
     method_not_supported_error,
@@ -776,7 +776,7 @@ class OpencodeSessionQueryJSONRPCApplication(A2AFastAPIApplication):
         )
         resolve_request = getattr(self._upstream_client, "resolve_interrupt_request", None)
         if callable(resolve_request):
-            status, binding = resolve_request(request_id)
+            status, binding = await resolve_request(request_id)
             if status != "active" or binding is None:
                 return self._generate_error_response(
                     base_request.id,
@@ -818,7 +818,7 @@ class OpencodeSessionQueryJSONRPCApplication(A2AFastAPIApplication):
         else:
             resolve_session = getattr(self._upstream_client, "resolve_interrupt_session", None)
             if callable(resolve_session):
-                if not resolve_session(request_id):
+                if not await resolve_session(request_id):
                     return self._generate_error_response(
                         base_request.id,
                         interrupt_not_found_error(
@@ -869,7 +869,7 @@ class OpencodeSessionQueryJSONRPCApplication(A2AFastAPIApplication):
                 await self._upstream_client.question_reject(request_id, directory=directory)
             discard_request = getattr(self._upstream_client, "discard_interrupt_request", None)
             if callable(discard_request):
-                discard_request(request_id)
+                await discard_request(request_id)
         except ValueError as exc:
             return self._generate_error_response(
                 base_request.id,
@@ -880,7 +880,7 @@ class OpencodeSessionQueryJSONRPCApplication(A2AFastAPIApplication):
             if upstream_status == 404:
                 discard_request = getattr(self._upstream_client, "discard_interrupt_request", None)
                 if callable(discard_request):
-                    discard_request(request_id)
+                    await discard_request(request_id)
                 return self._generate_error_response(
                     base_request.id,
                     interrupt_not_found_error(

{opencode_a2a-0.4.1 → opencode_a2a-0.5.0}/src/opencode_a2a/opencode_upstream_client.py

@@ -12,6 +12,8 @@ import httpx
 
 from .config import Settings
 from .parts.text import extract_text_from_parts
+from .runtime_state import InterruptRequestBinding
+from .server.state_store import InterruptRequestRepository, MemoryInterruptRequestRepository
 
 _UNSET = object()
 logger = logging.getLogger(__name__)
@@ -29,25 +31,13 @@ class OpencodeMessage:
     raw: dict[str, Any]
 
 
-@dataclass(frozen=True)
-class InterruptRequestBinding:
-    request_id: str
-    session_id: str
-    interrupt_type: str
-    identity: str | None
-    task_id: str | None
-    context_id: str | None
-    expires_at: float
-
-
-@dataclass(frozen=True)
-class InterruptRequestTombstone:
-    request_id: str
-    expires_at: float
-
-
 class OpencodeUpstreamClient:
-    def __init__(self, settings: Settings) -> None:
+    def __init__(
+        self,
+        settings: Settings,
+        *,
+        interrupt_request_repository: InterruptRequestRepository | None = None,
+    ) -> None:
         self._settings = settings
         self._base_url = settings.opencode_base_url.rstrip("/")
         self._directory = settings.opencode_workspace_root
@@ -61,10 +51,20 @@ class OpencodeUpstreamClient:
             settings.a2a_interrupt_request_tombstone_ttl_seconds
         )
         self._interrupt_request_clock = time.monotonic
-        self._interrupt_requests: dict[str, InterruptRequestBinding] = {}
-        self._interrupt_request_tombstones: dict[str, InterruptRequestTombstone] = {}
+        self._interrupt_request_repository = (
+            interrupt_request_repository
+            or MemoryInterruptRequestRepository(
+                request_ttl_seconds=self._interrupt_request_ttl_seconds,
+                tombstone_ttl_seconds=self._interrupt_request_tombstone_ttl_seconds,
+                clock=self._interrupt_request_clock,
+            )
+        )
         self._client = self._build_http_client(self._base_url)
 
+    def _sync_interrupt_clock(self) -> None:
+        if isinstance(self._interrupt_request_repository, MemoryInterruptRequestRepository):
+            self._interrupt_request_repository._clock = self._interrupt_request_clock
+
     def _build_http_client(self, base_url: str) -> httpx.AsyncClient:
         return httpx.AsyncClient(
             base_url=base_url,
@@ -157,36 +157,7 @@ class OpencodeUpstreamClient:
         )
         return self._require_boolean_response(endpoint=endpoint, payload=data)
 
-    def _prune_interrupt_requests(self, *, now: float) -> None:
-        expired = [
-            request_id
-            for request_id, binding in self._interrupt_requests.items()
-            if binding.expires_at <= now
-        ]
-        for request_id in expired:
-            self._interrupt_requests.pop(request_id, None)
-            self._remember_interrupt_request_tombstone(request_id, now=now)
-
-    def _prune_interrupt_request_tombstones(self, *, now: float) -> None:
-        expired = [
-            request_id
-            for request_id, tombstone in self._interrupt_request_tombstones.items()
-            if tombstone.expires_at <= now
-        ]
-        for request_id in expired:
-            self._interrupt_request_tombstones.pop(request_id, None)
-
-    def _remember_interrupt_request_tombstone(self, request_id: str, *, now: float) -> None:
-        ttl = self._interrupt_request_tombstone_ttl_seconds
-        if ttl <= 0:
-            self._interrupt_request_tombstones.pop(request_id, None)
-            return
-        self._interrupt_request_tombstones[request_id] = InterruptRequestTombstone(
-            request_id=request_id,
-            expires_at=now + ttl,
-        )
-
-    def remember_interrupt_request(
+    async def remember_interrupt_request(
         self,
         *,
         request_id: str,
@@ -202,12 +173,8 @@ class OpencodeUpstreamClient:
         kind = interrupt_type.strip()
         if not request or not session or kind not in {"permission", "question"}:
             return
-        now = self._interrupt_request_clock()
-        self._prune_interrupt_requests(now=now)
-        self._prune_interrupt_request_tombstones(now=now)
-        ttl = self._interrupt_request_ttl_seconds if ttl_seconds is None else ttl_seconds
-        expires_at = now + max(0.0, float(ttl))
-        self._interrupt_requests[request] = InterruptRequestBinding(
+        self._sync_interrupt_clock()
+        await self._interrupt_request_repository.remember(
             request_id=request,
             session_id=session,
             interrupt_type=kind,
@@ -216,44 +183,30 @@ class OpencodeUpstreamClient:
             context_id=(
                 context_id.strip() if isinstance(context_id, str) and context_id.strip() else None
             ),
-            expires_at=expires_at,
+            ttl_seconds=ttl_seconds,
         )
-        self._interrupt_request_tombstones.pop(request, None)
 
-    def resolve_interrupt_request(
+    async def resolve_interrupt_request(
         self,
         request_id: str,
     ) -> tuple[str, InterruptRequestBinding | None]:
         request = request_id.strip()
         if not request:
             return "missing", None
-        now = self._interrupt_request_clock()
-        self._prune_interrupt_request_tombstones(now=now)
-        binding = self._interrupt_requests.get(request)
-        if binding is None:
-            if request in self._interrupt_request_tombstones:
-                return "expired", None
-            return "missing", None
-        if binding.expires_at <= now:
-            self._interrupt_requests.pop(request, None)
-            self._prune_interrupt_requests(now=now)
-            self._remember_interrupt_request_tombstone(request, now=now)
-            return "expired", None
-        self._prune_interrupt_requests(now=now)
-        return "active", binding
-
-    def resolve_interrupt_session(self, request_id: str) -> str | None:
-        status, binding = self.resolve_interrupt_request(request_id)
+        self._sync_interrupt_clock()
+        return await self._interrupt_request_repository.resolve(request_id=request)
+
+    async def resolve_interrupt_session(self, request_id: str) -> str | None:
+        status, binding = await self.resolve_interrupt_request(request_id)
         if status != "active" or binding is None:
             return None
         return binding.session_id
 
-    def discard_interrupt_request(self, request_id: str) -> None:
+    async def discard_interrupt_request(self, request_id: str) -> None:
         request = request_id.strip()
         if not request:
             return
-        self._interrupt_requests.pop(request, None)
-        self._interrupt_request_tombstones.pop(request, None)
+        await self._interrupt_request_repository.discard(request_id=request)
 
     @property
     def stream_timeout(self) -> float | None:

opencode_a2a-0.5.0/src/opencode_a2a/runtime_state.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class InterruptRequestBinding:
+    request_id: str
+    session_id: str
+    interrupt_type: str
+    identity: str | None
+    task_id: str | None
+    context_id: str | None
+    expires_at: float
+
+
+@dataclass(frozen=True)
+class InterruptRequestTombstone:
+    request_id: str
+    expires_at: float