reactifact 0.14.2__tar.gz → 0.15.1__tar.gz

{reactifact-0.14.2/reactifact.egg-info → reactifact-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.14.2
+Version: 0.15.1
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact
@@ -55,7 +55,7 @@ Dynamic: license-file
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://github.com/bzdvdn/reactifact)
 [![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
+[![Ask DeepWiki](docs/img/deepwiki.svg)](https://deepwiki.com/bzdvdn/reactifact)
 [![Docs](https://img.shields.io/badge/docs-bzdvdn.github.io%2Freactifact-blue)](https://bzdvdn.github.io/reactifact/)
 
 > **Is:** a Python library (3 core deps) · single-process · typed, versioned artifacts with provenance · deterministic replay · runs offline, no API key

{reactifact-0.14.2 → reactifact-0.15.1}/README.md

@@ -9,7 +9,7 @@
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://github.com/bzdvdn/reactifact)
 [![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
+[![Ask DeepWiki](docs/img/deepwiki.svg)](https://deepwiki.com/bzdvdn/reactifact)
 [![Docs](https://img.shields.io/badge/docs-bzdvdn.github.io%2Freactifact-blue)](https://bzdvdn.github.io/reactifact/)
 
 > **Is:** a Python library (3 core deps) · single-process · typed, versioned artifacts with provenance · deterministic replay · runs offline, no API key

{reactifact-0.14.2 → reactifact-0.15.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.14.2"
+version = "0.15.1"
 description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
 readme = "README.md"
 requires-python = ">=3.11"

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/__init__.py

@@ -51,7 +51,7 @@ from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 from .types import register as register_type
 
-__version__ = "0.14.2"
+__version__ = "0.15.1"
 
 __all__ = [
     "Agent",

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/a2a/server.py

@@ -25,6 +25,8 @@ tasks persists the `Context` with a `Session` itself.
 """
 
 import asyncio
+import contextlib
+from collections import OrderedDict
 from collections.abc import AsyncIterator, Callable, Sequence
 from dataclasses import dataclass, field
 from typing import Any
@@ -59,6 +61,10 @@ CreateMessage = Callable[[Context, str], str]
 Reply = Callable[[Context, str], str]
 ContextFactory = Callable[[], Context]
 
+#: In-process task store bound. A long-lived A2A server must not grow `_tasks`
+#: without limit; the oldest completed task is evicted first (see `_evict`).
+_MAX_TASKS = 512
+
 
 def default_create_message(context: Context, text: str) -> str:
     """Default input hook: seed a `UserMessage` artifact (apps override this)."""
@@ -106,10 +112,11 @@ class _A2AServer:
         self._reply = reply
         self._budget = budget
         self._max_iterations = max_iterations
-        self._tasks: dict[str, _TaskRecord] = {}
+        self._tasks: OrderedDict[str, _TaskRecord] = OrderedDict()
 
     def _record_for(self, message: Message) -> _TaskRecord:
         if message.taskId and message.taskId in self._tasks:
+            self._tasks.move_to_end(message.taskId)
             return self._tasks[message.taskId]
         record = _TaskRecord(
             id=message.taskId or uuid4().hex,
@@ -117,8 +124,20 @@ class _A2AServer:
             context=self._context_factory(),
         )
         self._tasks[record.id] = record
+        self._evict()
         return record
 
+    def _evict(self) -> None:
+        """Keep `_tasks` bounded: drop the oldest terminal task first."""
+        if len(self._tasks) <= _MAX_TASKS:
+            return
+        for task_id, record in list(self._tasks.items()):
+            if record.state in TERMINAL_STATES:
+                del self._tasks[task_id]
+                break
+        else:
+            self._tasks.popitem(last=False)
+
     async def _execute(
         self,
         record: _TaskRecord,
@@ -185,14 +204,23 @@ class _A2AServer:
         run = asyncio.create_task(
             self._execute(record, params.message.text, on_event=queue.put_nowait)
         )
-        while not run.done() or not queue.empty():
-            try:
-                event = await asyncio.wait_for(queue.get(), timeout=0.05)
-            except TimeoutError:
-                continue
-            yield _sse(request_id, _status_update(record, "working", event.message))
-        await run
-        yield _sse(request_id, self.task(record))
+        try:
+            while not run.done() or not queue.empty():
+                try:
+                    event = await asyncio.wait_for(queue.get(), timeout=0.05)
+                except TimeoutError:
+                    continue
+                yield _sse(request_id, _status_update(record, "working", event.message))
+            await run
+            yield _sse(request_id, self.task(record))
+        finally:
+            # A dropped SSE client closes this generator mid-run: cancel and
+            # await the run, or it keeps executing (tokens!) and is destroyed
+            # pending ("Task was destroyed but it is pending!").
+            if not run.done():
+                run.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await run
 
     def get(self, task_id: str) -> Task | None:
         record = self._tasks.get(task_id)

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/chat.py

@@ -26,7 +26,7 @@ from collections.abc import (
     Mapping,
     Sequence,
 )
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -414,9 +414,16 @@ class ChatAssistant:
                         self._session_locks.pop(session_id, None)
 
     async def _open(self, session_id: str) -> Session:
-        return await self.store.open(
-            session_id, resources=_resolve_with_session(self._resources, session_id)
-        )
+        resources = _resolve_with_session(self._resources, session_id)
+        try:
+            return await self.store.open(session_id, resources=resources)
+        except Exception:
+            # A callable `resources=` built a fresh per-turn instance; if the
+            # store fails to open the session nothing else will close it.
+            if callable(self._resources):
+                with suppress(Exception):
+                    await resources.aclose()
+            raise
 
     def _memory_agents(self) -> list[Agent]:
         """The bounded-memory agent implied by `memory=`, or none."""
@@ -497,6 +504,7 @@ class ChatAssistant:
         design (see the module docstring).
         """
         async with self._locked_session(session_id):
+            session: Session | None = None
             try:
                 session = await self._open(session_id)
                 runtime = self._build_runtime(session)
@@ -504,6 +512,12 @@ class ChatAssistant:
                 logger.exception(
                     "chat.ChatAssistant: failed to open session %r", session_id
                 )
+                # If the session did open but building the runtime failed, its
+                # per-turn resources still need closing (a callable `resources=`
+                # is never referenced again).
+                if session is not None and callable(self._resources):
+                    with suppress(Exception):
+                        await session.context.resources.aclose()
                 yield ChatEvent(
                     kind="message",
                     session_id=session_id,

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/runtime.py

@@ -59,6 +59,11 @@ class RunInfo:
 _ACTIVE_RUNS: dict[str, RunInfo] = {}
 _RUN_TASKS: dict[str, "asyncio.Task[Any]"] = {}
 
+#: How long `astream` waits for a cancelled runner to unwind before giving up
+#: (a well-behaved turn stops immediately; this only guards a misbehaving agent
+#: that swallows `CancelledError`).
+_CANCEL_GRACE_SECONDS = 5.0
+
 
 def active_runs() -> list[RunInfo]:
     """Snapshots of the turns currently executing in this process.
@@ -1031,13 +1036,22 @@ class Runtime:
                     break
                 get_event = asyncio.ensure_future(queue.get())
                 wait_done = asyncio.ensure_future(done.wait())
-                finished, _ = await asyncio.wait(
-                    {get_event, wait_done}, return_when=asyncio.FIRST_COMPLETED
-                )
-                if get_event in finished:
-                    yield get_event.result()
-                else:
-                    get_event.cancel()
+                try:
+                    finished, _ = await asyncio.wait(
+                        {get_event, wait_done}, return_when=asyncio.FIRST_COMPLETED
+                    )
+                    if get_event in finished:
+                        yield get_event.result()
+                finally:
+                    # Always cancel *and await* the losing future. A task that is
+                    # cancelled but never awaited stays pending until the loop
+                    # closes, producing "Task was destroyed but it is pending!"
+                    # (`Queue.get`/`Event.wait`) on every early generator close
+                    # (e.g. a dropped SSE client).
+                    for fut in (get_event, wait_done):
+                        if not fut.done():
+                            fut.cancel()
+                    await asyncio.gather(get_event, wait_done, return_exceptions=True)
             # Re-raise any agent/runtime exception instead of silently dropping it:
             # an error inside a run must reach the caller, not hide in the task.
             await task
@@ -1053,6 +1067,15 @@ class Runtime:
             )
         finally:
             task.cancel()
+            # Settle the runner too, so an early generator close (client
+            # disconnect) does not leave the run task pending at loop shutdown.
+            # Bounded: an agent that swallows `CancelledError` must never hang
+            # the caller's disconnect/shutdown path.
+            with contextlib.suppress(Exception):
+                await asyncio.wait_for(
+                    asyncio.gather(task, return_exceptions=True),
+                    timeout=_CANCEL_GRACE_SECONDS,
+                )
             self.context.unsubscribe(queue)
 
     def _apply_patch(self, patch: Patch, commit: Commit) -> list[Write]:

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/streaming.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from typing import Any
@@ -30,6 +31,11 @@ class ProgressEvent:
 
 QueueEvent = asyncio.Queue[ProgressEvent]
 
+#: Per-subscriber queue bound. Status events are best-effort UI hints: a
+#: subscriber that never drains must not grow the queue without bound, so the
+#: oldest event is dropped when this is reached.
+_DEFAULT_SUBSCRIBER_QUEUE_SIZE = 1024
+
 
 class EventHub:
     """Broadcaster of agent status events into a single- or multi-stream.
@@ -38,15 +44,16 @@ class EventHub:
     runs pay nothing for announce.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, maxsize: int = _DEFAULT_SUBSCRIBER_QUEUE_SIZE) -> None:
         self._subscribers: set[QueueEvent] = set()
+        self._maxsize = maxsize
 
     @property
     def has_subscribers(self) -> bool:
         return bool(self._subscribers)
 
     def subscribe(self) -> QueueEvent:
-        queue: QueueEvent = asyncio.Queue()
+        queue: QueueEvent = asyncio.Queue(maxsize=self._maxsize)
         self._subscribers.add(queue)
         return queue
 
@@ -55,4 +62,8 @@ class EventHub:
 
     def publish(self, event: ProgressEvent) -> None:
         for queue in self._subscribers:
+            if queue.full():
+                # Drop the oldest status hint rather than block or grow forever.
+                with contextlib.suppress(asyncio.QueueEmpty):
+                    queue.get_nowait()
             queue.put_nowait(event)

{reactifact-0.14.2 → reactifact-0.15.1}/reactifact/web.py

@@ -31,8 +31,9 @@ fastapi installed, and only `create_chat_router` requires the `web` extra —
 
 from __future__ import annotations
 
+import inspect
 import json
-from collections.abc import AsyncIterator, Callable, Mapping, Sequence
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
@@ -41,7 +42,7 @@ from ._extras import require_extra
 from .chat import ChatAssistant, ChatEvent, ChatEventKind
 
 if TYPE_CHECKING:
-    from fastapi import APIRouter
+    from fastapi import APIRouter, Request
     from fastapi.responses import JSONResponse, StreamingResponse
 
 
@@ -83,6 +84,10 @@ def create_chat_router(
     forward_kinds: Sequence[str] | None = None,
     payload_shaper: Callable[[ChatEvent], Mapping[str, Any]] | None = None,
     done_event: str | None = None,
+    request_factory: Callable[
+        [Request], Mapping[str, Any] | Awaitable[Mapping[str, Any]]
+    ]
+    | None = None,
 ) -> APIRouter:
     """Builds the chat router on top of a `ChatAssistant`.
 
@@ -100,6 +105,11 @@ def create_chat_router(
     - `payload_shaper(event) -> mapping` — reshape a frame's payload.
     - `done_event` — emit one extra terminal frame (e.g. `"done"`) when the
       stream ends.
+    - `request_factory(request) -> mapping` — build the per-turn `request=`
+      mapping (the same one `ChatAssistant.stream` takes) from the incoming
+      FastAPI `Request`, e.g. the authenticated user for ACL/identity-aware
+      runs. May be sync or async (an awaitable result is awaited). Without it
+      the turn runs with `request=None`.
 
     Defaults reproduce the canonical contract exactly, so existing clients are
     unaffected. The event schema (`ChatEvent`) and the effective names are
@@ -108,9 +118,15 @@ def create_chat_router(
     # Readable error when the `web` extra is missing — then a regular
     # (mypy-visible) import for the real types.
     require_extra("web.create_chat_router", "fastapi", "web")
-    from fastapi import APIRouter
+    from fastapi import APIRouter, Request
     from fastapi.responses import JSONResponse, StreamingResponse
 
+    # `Request` is only referenced from the endpoint's *string* annotation
+    # (`from __future__ import annotations`); FastAPI resolves those against
+    # the module globals, and fastapi may be absent at import time — so publish
+    # it lazily here, right before the endpoint that uses it is defined.
+    globals().setdefault("Request", Request)
+
     names: dict[str, str] = {k: v for k, v in DEFAULT_EVENT_NAMES.items()}
     names.update(event_names or {})
     forward = set(forward_kinds) if forward_kinds is not None else None
@@ -140,9 +156,15 @@ def create_chat_router(
             }
         },
     )
-    async def chat_stream(req: ChatMessage) -> StreamingResponse:
+    async def chat_stream(req: ChatMessage, request: Request) -> StreamingResponse:
+        turn_request = request_factory(request) if request_factory else None
+        if inspect.isawaitable(turn_request):
+            turn_request = await turn_request
+
         async def stream() -> AsyncIterator[str]:
-            async for event in assistant.stream(req.message, req.session_id):
+            async for event in assistant.stream(
+                req.message, req.session_id, request=turn_request
+            ):
                 if forward is not None and event.kind not in forward:
                     continue
                 yield sse(names.get(event.kind, event.kind), dict(shaper(event)))

{reactifact-0.14.2 → reactifact-0.15.1/reactifact.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.14.2
+Version: 0.15.1
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact
@@ -55,7 +55,7 @@ Dynamic: license-file
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://github.com/bzdvdn/reactifact)
 [![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
+[![Ask DeepWiki](docs/img/deepwiki.svg)](https://deepwiki.com/bzdvdn/reactifact)
 [![Docs](https://img.shields.io/badge/docs-bzdvdn.github.io%2Freactifact-blue)](https://bzdvdn.github.io/reactifact/)
 
 > **Is:** a Python library (3 core deps) · single-process · typed, versioned artifacts with provenance · deterministic replay · runs offline, no API key

{reactifact-0.14.2 → reactifact-0.15.1}/tests/test_a2a.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 
 import httpx
 import pytest
@@ -48,6 +49,14 @@ class Echo(Produce[Answer]):
         call.effects.create(Answer(text=call.trigger.data.text.upper()))
 
 
+class Slow(Produce[Answer]):
+    artifact_type = Answer
+
+    async def produce(self, call):
+        await asyncio.sleep(30)
+        call.effects.create(Answer(text="slow"))
+
+
 class AskOrAnswer(Produce[Answer]):
     """First a PendingQuestion (input-required), then an Answer once resumed."""
 
@@ -154,6 +163,63 @@ def test_unknown_method_errors():
     assert body["error"]["code"] == -32601
 
 
+def test_server_task_store_is_bounded():
+    """A long-lived server must not grow its in-process task store without
+    bound: the oldest records are evicted once the cap is reached."""
+    from reactifact.a2a.server import (
+        _MAX_TASKS,
+        _A2AServer,
+        default_create_message,
+        default_reply,
+    )
+
+    server = _A2AServer(
+        [_echo_agent()],
+        context_factory=Context,
+        create_message=default_create_message,
+        reply=default_reply,
+        budget=None,
+        max_iterations=100,
+    )
+    for _ in range(_MAX_TASKS + 20):
+        server._record_for(Message.user("hi"))
+    assert len(server._tasks) <= _MAX_TASKS
+
+
+def test_server_stream_cancels_run_when_the_client_disconnects():
+    """A dropped SSE client must cancel the in-flight run — otherwise it keeps
+    executing and is destroyed pending at loop shutdown ("Task was destroyed
+    but it is pending!")."""
+    from reactifact.a2a.models import MessageSendParams
+    from reactifact.a2a.server import _A2AServer, default_create_message, default_reply
+
+    slow = create_agent("slow", consumes=[Consume(UserMessage)], produces=[Slow()])
+    server = _A2AServer(
+        [slow],
+        context_factory=Context,
+        create_message=default_create_message,
+        reply=default_reply,
+        budget=None,
+        max_iterations=100,
+    )
+    params = MessageSendParams(message=Message.user("hi"))
+
+    async def run():
+        agen = server.stream("1", params)
+        assert (await agen.__anext__()).startswith("data:")  # the working frame
+        puller = asyncio.create_task(agen.__anext__())
+        await asyncio.sleep(0)  # enter the wait: the run task is in flight
+        puller.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await puller
+        await agen.aclose()
+        for _ in range(10):
+            await asyncio.sleep(0)
+        return [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+
+    assert asyncio.run(run()) == []
+
+
 def test_hitl_input_required_then_resume():
     agent = create_agent(
         "asker",

{reactifact-0.14.2 → reactifact-0.15.1}/tests/test_chat_web.py

@@ -157,6 +157,116 @@ def test_web_router_openapi_publishes_event_schema(tmp_path):
     assert "content" in responses["200"]["description"]
 
 
+def test_web_router_request_factory_forwards_per_turn_context(tmp_path):
+    """`request_factory` maps the FastAPI `Request` into the turn's `request=`."""
+    seen: dict[str, object] = {}
+
+    async def capture(call):
+        seen["user"] = call.request.get("user")
+        call.effects.create(A(text="answer"))
+        return None
+
+    prod = produce(A)(capture)
+    agent = create_agent("cap", consumes=[Consume(Q)], produces=[prod])
+    store = SessionStore(FileKVBackend(os.path.join(tmp_path, "sess")))
+    assistant = ChatAssistant(
+        store=store,
+        agents=[agent],
+        user_message=Q,
+        reply=lambda ctx, msg_id: {"reply": "ok", "waiting": False},
+        max_concurrency=1,
+    )
+
+    app = FastAPI()
+    app.include_router(
+        create_chat_router(
+            assistant,
+            request_factory=lambda request: {"user": request.headers.get("x-user", "")},
+        )
+    )
+    client = TestClient(app)
+
+    with client.stream(
+        "POST",
+        "/api/chat/stream",
+        json={"message": "hi", "session_id": "s1"},
+        headers={"X-User": "alice"},
+    ) as response:
+        "".join(response.iter_text())
+
+    assert seen["user"] == "alice"
+
+
+def test_web_router_async_request_factory_is_awaited(tmp_path):
+    """An async `request_factory` must be awaited, not passed as a coroutine."""
+    seen: dict[str, object] = {}
+
+    async def capture(call):
+        seen["user"] = call.request.get("user")
+        call.effects.create(A(text="answer"))
+        return None
+
+    prod = produce(A)(capture)
+    agent = create_agent("cap", consumes=[Consume(Q)], produces=[prod])
+    store = SessionStore(FileKVBackend(os.path.join(tmp_path, "sess")))
+    assistant = ChatAssistant(
+        store=store,
+        agents=[agent],
+        user_message=Q,
+        reply=lambda ctx, msg_id: {"reply": "ok", "waiting": False},
+        max_concurrency=1,
+    )
+
+    async def request_factory(request):
+        return {"user": request.headers.get("x-user", "")}
+
+    app = FastAPI()
+    app.include_router(create_chat_router(assistant, request_factory=request_factory))
+    client = TestClient(app)
+
+    with client.stream(
+        "POST",
+        "/api/chat/stream",
+        json={"message": "hi", "session_id": "s1"},
+        headers={"X-User": "bob"},
+    ) as response:
+        "".join(response.iter_text())
+
+    assert seen["user"] == "bob"
+
+
+def test_web_router_without_request_factory_has_no_request(tmp_path):
+    """Default stays `request=None`: no behavior change for existing callers."""
+    seen: dict[str, object] = {}
+
+    async def capture(call):
+        seen["request"] = dict(call.request)
+        call.effects.create(A(text="answer"))
+        return None
+
+    prod = produce(A)(capture)
+    agent = create_agent("cap", consumes=[Consume(Q)], produces=[prod])
+    store = SessionStore(FileKVBackend(os.path.join(tmp_path, "sess")))
+    assistant = ChatAssistant(
+        store=store,
+        agents=[agent],
+        user_message=Q,
+        reply=lambda ctx, msg_id: {"reply": "ok", "waiting": False},
+        max_concurrency=1,
+    )
+
+    app = FastAPI()
+    app.include_router(create_chat_router(assistant))
+    client = TestClient(app)
+
+    with client.stream(
+        "POST", "/api/chat/stream", json={"message": "hi", "session_id": "s1"}
+    ) as response:
+        "".join(response.iter_text())
+
+    assert seen["request"] == {}
+
+
 def test_disconnect_cancels_the_running_turn(tmp_path):
     """A dropped SSE client must cancel in-flight work, not leave it burning.
 
@@ -355,6 +465,42 @@ def test_callable_resources_closed_after_each_turn(tmp_path):
     assert all(llm.closed for llm in built)
 
 
+def test_callable_resources_closed_when_session_open_fails(tmp_path):
+    """A failing session open must not leak the freshly-built per-turn
+    ``resources=`` instance — ``_open`` closes it before re-raising."""
+    from reactifact import RuntimeResources
+
+    built: list[_SpyLLM] = []
+
+    def fresh_resources():
+        llm = _SpyLLM()
+        built.append(llm)
+        return RuntimeResources(llm=llm)
+
+    class BoomStore:
+        def open(self, session_id, resources=None):
+            raise RuntimeError("backend down")
+
+        def delete_session(self, session_id):
+            pass
+
+    assistant = ChatAssistant(
+        store=BoomStore(),
+        agents=[ANSWER_AGENT],
+        user_message=Q,
+        reply=lambda ctx, mid: {"reply": "never", "waiting": False},
+        resources=fresh_resources,
+        max_concurrency=1,
+        fallback_reply="degraded",
+    )
+
+    events = _drain(assistant.stream("hi", session_id="s6"))
+
+    assert events[-1].payload["reply"] == "degraded"
+    assert len(built) == 1
+    assert built[0].closed is True
+
+
 def test_shared_resources_instance_not_closed(tmp_path):
     """A plain (non-callable) resources= instance must survive the turn —
     it's shared across future turns/sessions, not closed automatically."""