reactifact 0.15.0__tar.gz → 0.15.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.15.0
+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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.15.0"
+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.15.0 → 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.15.0"
+__version__ = "0.15.1"
 
 __all__ = [
     "Agent",

{reactifact-0.15.0 → 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.15.0 → 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.15.0 → 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.15.0 → 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.15.0 → 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
@@ -83,7 +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]] | 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`.
 
@@ -104,7 +108,8 @@ def create_chat_router(
     - `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. Without it the turn runs with `request=None`.
+      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
@@ -153,6 +158,8 @@ def create_chat_router(
     )
     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(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.15.0
+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

{reactifact-0.15.0 → 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.15.0 → reactifact-0.15.1}/tests/test_chat_web.py

@@ -197,6 +197,44 @@ def test_web_router_request_factory_forwards_per_turn_context(tmp_path):
     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] = {}
@@ -427,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."""

reactifact-0.15.1/tests/test_streaming.py

@@ -0,0 +1,156 @@
+import asyncio
+import contextlib
+
+from pydantic import BaseModel
+from reactifact import Agent, Consume, Context, Patch, Runtime
+from reactifact.streaming import EventHub, ProgressEvent
+
+
+class UserMsg(BaseModel):
+    text: str
+
+
+class Done(BaseModel):
+    text: str
+
+
+class Announcer(Agent):
+    consumes = [Consume(UserMsg)]
+
+    async def run(self, event, context):
+        context.announce("Думаю над вопросом...", kind="status", source="brain")
+        context.announce("Найдено 3 соответствия", kind="status")
+        return Patch().create(Done(text="ok"))
+
+
+class Slow(Agent):
+    consumes = [Consume(UserMsg)]
+
+    async def run(self, event, context):
+        await asyncio.sleep(30)  # stays running while the consumer goes away
+        return Patch().create(Done(text="ok"))
+
+
+class Stubborn(Agent):
+    consumes = [Consume(UserMsg)]
+
+    async def run(self, event, context):
+        try:
+            await asyncio.sleep(30)
+        except asyncio.CancelledError:
+            await asyncio.sleep(0.5)  # ignores the cancel for a bit
+        return Patch().create(Done(text="ok"))
+
+
+async def collect_events(runtime):
+    return [ev async for ev in runtime.astream()]
+
+
+def test_astream_yields_status_and_run_end():
+    ctx = Context()
+    runtime = Runtime(ctx, agents=[Announcer()])
+    ctx.create(UserMsg(text="привет"))
+
+    events = asyncio.run(collect_events(runtime))
+
+    assert events[0].kind == "run_start"
+    assert events[-1].kind == "run_end"
+    statuses = [e for e in events if e.kind == "status"]
+    assert [e.message for e in statuses] == [
+        "Думаю над вопросом...",
+        "Найдено 3 соответствия",
+    ]
+    assert statuses[0].data["source"] == "brain"
+    assert events[-1].data["runs"] >= 1
+    assert events[-1].data["outcome"] in {"completed", "budget_runs_exceeded"}
+
+
+def test_announce_is_noop_without_subscribers():
+    ctx = Context()
+    ctx.announce("никто не слушает", kind="status")  # must not raise
+    assert isinstance(ctx._hub, EventHub)
+
+
+def test_astream_leaves_no_pending_tasks_after_consuming():
+    """Regression: the runner used to leave a cancelled-but-unawaited
+    ``queue.get()``/``done.wait()`` future pending, which surfaced as
+    "Task was destroyed but it is pending!" when the event loop closed."""
+
+    async def run():
+        ctx = Context()
+        runtime = Runtime(ctx, agents=[Announcer()])
+        ctx.create(UserMsg(text="привет"))
+        async for _ in runtime.astream():
+            pass
+        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_astream_close_while_waiting_leaves_no_pending_tasks():
+    """A dropped consumer closed while the stream is awaiting
+    ``queue.get()``/``done.wait()`` must not leave those futures pending."""
+
+    async def run():
+        ctx = Context()
+        runtime = Runtime(ctx, agents=[Slow()])
+        ctx.create(UserMsg(text="привет"))
+        agen = runtime.astream()
+        assert (await agen.__anext__()).kind == "run_start"
+
+        puller = asyncio.create_task(agen.__anext__())
+        await asyncio.sleep(0)  # enter the wait: queue.get()/done.wait() created
+        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_eventhub_multiple_subscribers():
+    hub = EventHub()
+    q1 = hub.subscribe()
+    q2 = hub.subscribe()
+
+    hub.publish(ProgressEvent(kind="status", message="x"))
+    ev1 = q1.get_nowait()
+    ev2 = q2.get_nowait()
+    assert ev1.message == ev2.message == "x"
+
+    hub.unsubscribe(q1)
+    hub.unsubscribe(q2)
+    assert not hub.has_subscribers
+    hub.publish(ProgressEvent(kind="status", message="y"))
+    assert q2.empty()
+
+
+def test_eventhub_bounds_a_stuck_subscriber_by_dropping_oldest():
+    hub = EventHub(maxsize=3)
+    q = hub.subscribe()
+    for i in range(5):
+        hub.publish(ProgressEvent(kind="status", message=str(i)))
+    assert q.qsize() == 3
+    assert [q.get_nowait().message for _ in range(3)] == ["2", "3", "4"]
+
+
+def test_astream_close_is_bounded_when_runner_ignores_cancel(monkeypatch):
+    """A misbehaving agent that swallows `CancelledError` must not hang the
+    caller's disconnect path: `astream` gives up after a bounded grace."""
+    monkeypatch.setattr("reactifact.runtime._CANCEL_GRACE_SECONDS", 0.05)
+
+    async def run():
+        ctx = Context()
+        runtime = Runtime(ctx, agents=[Stubborn()])
+        ctx.create(UserMsg(text="привет"))
+        agen = runtime.astream()
+        assert (await agen.__anext__()).kind == "run_start"
+        started = asyncio.get_running_loop().time()
+        await agen.aclose()
+        return asyncio.get_running_loop().time() - started
+
+    assert asyncio.run(run()) < 0.4