reactifact 0.11.0__tar.gz → 0.11.2__tar.gz

{reactifact-0.11.0/reactifact.egg-info → reactifact-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.11.0
+Version: 0.11.2
 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.11.0 → reactifact-0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.11.0"
+version = "0.11.2"
 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.11.0 → reactifact-0.11.2}/reactifact/__init__.py

@@ -49,7 +49,7 @@ from .session import Session, SessionStore
 from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 
-__version__ = "0.11.0"
+__version__ = "0.11.2"
 
 __all__ = [
     "Agent",

{reactifact-0.11.0 → reactifact-0.11.2}/reactifact/checkpoints.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import copy
 import json
 import sqlite3
@@ -301,6 +302,12 @@ class PostgreSQLKVBackend(KVBackend):
     enough for session-checkpoint traffic (small, infrequent writes); reach for
     `psycopg_pool.AsyncConnectionPool` yourself if you need many concurrent
     writers sharing one DSN.
+
+    The connection **self-heals**: a query cancelled mid-flight (a client that
+    drops a streaming turn) or any protocol error leaves the shared libpq
+    connection busy/aborted, and a single poisoned connection would otherwise
+    fail every later session read/write. Each statement reconnects and retries
+    once, so one bad query cannot wedge the whole store.
     """
 
     def __init__(self, dsn: str):
@@ -324,42 +331,64 @@ class PostgreSQLKVBackend(KVBackend):
             self._conn = conn
         return conn
 
-    async def set(self, key: str, data: dict[str, Any]) -> None:
+    async def _reset(self) -> None:
+        """Drops the cached connection so the next statement reconnects.
+
+        Called after any error: a connection that raised is never trusted again
+        (it may be mid-command or in an aborted transaction).
+        """
+        conn, self._conn = self._conn, None
+        if conn is not None and not conn.closed:
+            with contextlib.suppress(Exception):
+                await conn.close()
+
+    async def _run(
+        self,
+        sql: str,
+        params: tuple[Any, ...] = (),
+        *,
+        fetch: str | None = None,
+    ) -> Any:
+        """Runs one statement under the lock, reconnecting once on failure.
+
+        All `kv_entries` statements are idempotent (upsert/delete/select), so a
+        retry after a dropped connection is safe.
+        """
         async with self._lock:
-            conn = await self._connection()
-            async with conn.cursor() as cur:
-                await cur.execute(
-                    "INSERT INTO kv_entries (key, data) VALUES (%s, %s) "
-                    "ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data",
-                    (key, json.dumps(data)),
-                )
-            await conn.commit()
+            for attempt in (0, 1):
+                try:
+                    conn = await self._connection()
+                    async with conn.cursor() as cur:
+                        await cur.execute(sql, params)
+                        result = await getattr(cur, fetch)() if fetch else None
+                    await conn.commit()
+                    return result
+                except self._psycopg.Error:
+                    await self._reset()
+                    if attempt:
+                        raise
+        raise AssertionError("unreachable")  # pragma: no cover
+
+    async def set(self, key: str, data: dict[str, Any]) -> None:
+        await self._run(
+            "INSERT INTO kv_entries (key, data) VALUES (%s, %s) "
+            "ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data",
+            (key, json.dumps(data)),
+        )
 
     async def get(self, key: str) -> dict[str, Any] | None:
-        async with self._lock:
-            conn = await self._connection()
-            async with conn.cursor() as cur:
-                await cur.execute("SELECT data FROM kv_entries WHERE key = %s", (key,))
-                row = await cur.fetchone()
+        row = await self._run(
+            "SELECT data FROM kv_entries WHERE key = %s", (key,), fetch="fetchone"
+        )
         return cast(dict[str, Any], json.loads(row[0])) if row is not None else None
 
     async def delete(self, key: str) -> None:
-        async with self._lock:
-            conn = await self._connection()
-            async with conn.cursor() as cur:
-                await cur.execute("DELETE FROM kv_entries WHERE key = %s", (key,))
-            await conn.commit()
+        await self._run("DELETE FROM kv_entries WHERE key = %s", (key,))
 
     async def keys(self) -> list[str]:
-        async with self._lock:
-            conn = await self._connection()
-            async with conn.cursor() as cur:
-                await cur.execute("SELECT key FROM kv_entries")
-                rows = await cur.fetchall()
+        rows = await self._run("SELECT key FROM kv_entries", fetch="fetchall")
         return [cast(str, r[0]) for r in rows]
 
     async def aclose(self) -> None:
         async with self._lock:
-            if self._conn is not None and not self._conn.closed:
-                await self._conn.close()
-            self._conn = None
+            await self._reset()

{reactifact-0.11.0 → reactifact-0.11.2}/reactifact/tracing/web.py

@@ -141,7 +141,11 @@ def create_trace_router(
             offset=offset,
         )
 
-    @router.get("/api/traces/export")
+    # ``response_model=None`` is required: the module uses ``from __future__
+    # import annotations`` and imports fastapi lazily here, so the ``->
+    # JSONResponse`` return annotation stays an unresolvable forward ref and
+    # FastAPI would fail to build ``/openapi.json``.
+    @router.get("/api/traces/export", response_model=None)
     async def export_traces(
         session_id: str | None = Query(default=None),
         outcome: str | None = Query(default=None),

{reactifact-0.11.0 → reactifact-0.11.2/reactifact.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.11.0
+Version: 0.11.2
 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.11.0 → reactifact-0.11.2}/tests/test_checkpoint.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import os
 import tempfile
 
@@ -109,6 +110,48 @@ async def _test_postgres_kv_roundtrip(dsn: str) -> None:
         await backend.aclose()
 
 
+def test_postgres_kv_self_heals_after_a_cancelled_query():
+    """A poisoned shared connection must not wedge the store.
+
+    A query cancelled mid-flight (a client that drops a streaming turn) leaves
+    libpq busy/aborted; before the fix every later session read/write failed
+    forever with ``InFailedSqlTransaction`` / "another command is already in
+    progress". The backend must reconnect and retry instead.
+    """
+    dsn = os.environ.get("TEST_PG_DSN")
+    if not dsn:
+        pytest.skip("TEST_PG_DSN not set — skipping Postgres KV integration")
+    import psycopg  # noqa: F401  (ensure the extra is installed)
+
+    asyncio.run(_test_postgres_kv_self_heal(dsn))
+
+
+async def _test_postgres_kv_self_heal(dsn: str) -> None:
+    from reactifact.checkpoints import PostgreSQLKVBackend
+
+    backend = PostgreSQLKVBackend(dsn)
+    try:
+        await backend.set("heal", {"v": 1})
+        conn = await backend._connection()
+
+        async def slow() -> None:
+            async with conn.cursor() as cur:
+                await cur.execute("SELECT pg_sleep(10)")
+
+        task = asyncio.create_task(slow())
+        await asyncio.sleep(0.3)
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+
+        assert await backend.get("heal") == {"v": 1}
+        assert backend._conn is not conn  # reconnected, not the poisoned one
+        await backend.delete("heal")
+        assert await backend.get("heal") is None
+    finally:
+        await backend.aclose()
+
+
 def test_require_extra_readable_error():
     """Missing extra dependency → a hint, not a bare ModuleNotFoundError."""
     from unittest import mock

{reactifact-0.11.0 → reactifact-0.11.2}/tests/test_tracing.py

@@ -576,6 +576,23 @@ def test_trace_router_open_without_auth(tmp_path):
     assert client.get("/api/traces").status_code == 200
 
 
+def test_trace_router_openapi_schema_builds(tmp_path):
+    from fastapi import FastAPI
+    from fastapi.testclient import TestClient
+    from reactifact.tracing.web import create_trace_router
+
+    store = TraceStore(str(tmp_path / "schema.db"))
+    app = FastAPI()
+    app.include_router(create_trace_router(store))
+    client = TestClient(app)
+
+    # regression: the ``-> JSONResponse`` export handler used to make schema
+    # generation raise on an unresolvable forward ref (no module-level import)
+    spec = client.get("/openapi.json")
+    assert spec.status_code == 200
+    assert "/api/traces/export" in spec.json()["paths"]
+
+
 def test_trace_run_page_embeds_mermaid_diagram(tmp_path):
     from fastapi import FastAPI
     from fastapi.testclient import TestClient