flowjet 2.1.7__tar.gz → 2.1.8__tar.gz

{flowjet-2.1.7 → flowjet-2.1.8}/CHANGELOG.md

@@ -10,6 +10,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.8] — 2026-10-26
+
+### Fixed
+
+- **PostgreSQL checkpointer is now wired for the server surface.**
+  `Checkpointers.open()` (the `/v1/responses` + ACP server path) used to warn
+  “Checkpointer backend 'postgresql' is not wired for the flowjet server surface
+  yet” and yield `None`, so thread state never survived a turn — a deployment
+  whose `persistence.default_backend` is `postgresql` silently ran every turn as
+  a fresh conversation. It now builds an `AsyncPostgresSaver` on nano's shared
+  checkpoints pool (`resolve_checkpointer()` → `(None, pool)`), opens the pool,
+  and runs `setup()` once per process under nano's advisory lock
+  (`SharedCheckpointerPool.setup_checkpointer`), so concurrent workers cannot
+  race LangGraph's DDL. The shared pool is deliberately **not** closed on exit
+  (it is process-wide). Failure still degrades to “no persistence” with a
+  warning instead of failing startup; unknown backends keep the old behavior.
+
 ## [2.1.7] — 2026-10-25
 
 ### Added

{flowjet-2.1.7 → flowjet-2.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.1.7
+Version: 2.1.8
 Summary: FlowJet — a fast, open agent runtime for CLI and HTTP, powered by Soothe
 Project-URL: Homepage, https://github.com/caesar0301/flowjet
 Project-URL: Repository, https://github.com/caesar0301/flowjet

{flowjet-2.1.7 → flowjet-2.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.1.7"
+version = "2.1.8"
 description = "FlowJet — a fast, open agent runtime for CLI and HTTP, powered by Soothe"
 readme = "README.md"
 license = { text = "MIT" }

{flowjet-2.1.7 → flowjet-2.1.8}/src/flowjet/core/agent/workspace.py

@@ -90,20 +90,43 @@ class Checkpointers:
 
         Server-surface counterpart of :meth:`open_sqlite`: honors
         ``agent.protocols.durability.checkpointer`` (which inherits
-        ``persistence.default_backend``), so a deployment that asks for sqlite
-        gets thread state that survives across turns, pool workers and
-        restarts. ``postgresql`` is not wired for the server surface yet — it
-        warns and yields ``None`` (no persistence) rather than failing
-        startup.
+        ``persistence.default_backend``), so a deployment that asks for
+        ``sqlite`` **or** ``postgresql`` gets thread state that survives across
+        turns, pool workers and restarts.
+
+        The PostgreSQL branch builds an ``AsyncPostgresSaver`` on nano's shared
+        checkpoints pool so every worker and every restart sees the same
+        threads — that is what makes ``conversation_key`` continuity (and
+        recovery from an executor restart) work on this surface. Setup runs
+        once per process under nano's advisory lock, so parallel workers cannot
+        race LangGraph's DDL. Failure is degraded, not fatal: a warning is
+        logged and ``None`` is yielded.
         """
         try:
             backend = str(config.resolve_checkpointer_backend()).strip().lower()
         except Exception:  # noqa: BLE001 - unknown config shape → sqlite default
             backend = "sqlite"
+
+        if backend == "postgresql":
+            try:
+                saver = await _connect_postgres(config)
+            except Exception:  # noqa: BLE001 - persistence is degraded, not fatal
+                logger.warning(
+                    "PostgreSQL checkpointer unavailable; thread state will not "
+                    "persist across turns",
+                    exc_info=True,
+                )
+                yield None
+                return
+            # The pool is a process-wide singleton shared by every worker:
+            # closing it here would break the next turn.
+            yield saver
+            return
+
         if backend != "sqlite":
             logger.warning(
                 "Checkpointer backend %r is not wired for the flowjet server "
-                "surface yet; thread state will not persist across turns",
+                "surface; thread state will not persist across turns",
                 backend,
             )
             yield None
@@ -123,6 +146,47 @@ class Checkpointers:
             await saver.conn.close()
 
 
+async def _connect_postgres(config: Any) -> Any:
+    """Open an ``AsyncPostgresSaver`` on nano's shared checkpoints pool.
+
+    ``resolve_checkpointer`` returns ``(None, pool)`` for PostgreSQL: the
+    saver is built from that pool (not from a DSN), and the pool must be
+    opened explicitly before use.
+    """
+    from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
+    from soothe_nano.utils.serde import create_soothe_serde
+
+    result = resolve_checkpointer(config)
+    pool = result[1] if isinstance(result, tuple) else None
+    if pool is None:
+        raise RuntimeError("PostgreSQL checkpointer pool unresolved")
+
+    await pool.open()
+    saver = AsyncPostgresSaver(pool, serde=create_soothe_serde())
+    await _setup_postgres(pool, saver)
+    logger.debug("PostgreSQL checkpointer ready (shared pool)")
+    return saver
+
+
+async def _setup_postgres(pool: Any, saver: Any) -> None:
+    """Run ``saver.setup()`` once per process under nano's advisory lock.
+
+    Parallel `setup()` calls race LangGraph's DDL (``UniqueViolation`` on
+    checkpoint types), so nano's helper serializes them — and it is a no-op
+    after the first success in this process.
+    """
+    try:
+        from soothe_nano.persistence.shared_checkpointer_pool import (
+            SharedCheckpointerPool,
+        )
+
+        await SharedCheckpointerPool.setup_checkpointer(pool, saver.setup)
+        return
+    except (ImportError, AttributeError):  # pragma: no cover - older nano
+        # nano without the helper (or without the method): plain setup().
+        await saver.setup()
+
+
 def _sqlite_db_path(result: Any) -> str | None:
     """Extract the sqlite db path from a ``resolve_checkpointer`` result."""
     if isinstance(result, tuple):