graphharbor 0.13.0.post34__tar.gz → 0.13.0.post35__tar.gz

{graphharbor-0.13.0.post34 → graphharbor-0.13.0.post35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphharbor
-Version: 0.13.0.post34
+Version: 0.13.0.post35
 Summary: GraphHarbor CLI for a self-hosted LangGraph Agent Server on PostgreSQL and Redis
 Project-URL: Homepage, https://github.com/ljxpython/graphharbor
 Project-URL: Repository, https://github.com/ljxpython/graphharbor
@@ -26,7 +26,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.7
-Requires-Dist: graphharbor-runtime==0.13.0.post34
+Requires-Dist: graphharbor-runtime==0.13.0.post35
 Requires-Dist: langgraph-cli<0.5,>=0.4.0
 Requires-Dist: mcp<2,>=1.23
 Requires-Dist: pyfiglet>=1.0.0

{graphharbor-0.13.0.post34 → graphharbor-0.13.0.post35}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "graphharbor"
 # Lockstep with graphharbor-runtime; independent of langgraph-api releases.
-version = "0.13.0.post34"
+version = "0.13.0.post35"
 description = "GraphHarbor CLI for a self-hosted LangGraph Agent Server on PostgreSQL and Redis"
 readme = "README.md"
 license = "MIT"
@@ -50,7 +50,7 @@ dependencies = [
     "mcp>=1.23,<2",
     "uvicorn[standard]>=0.51.0",
     # Exact same version as graphharbor-runtime (lockstep releases).
-    "graphharbor-runtime==0.13.0.post34",
+    "graphharbor-runtime==0.13.0.post35",
 ]
 
 [project.urls]

{graphharbor-0.13.0.post34 → graphharbor-0.13.0.post35}/src/langhost/protocol_api.py

@@ -189,6 +189,12 @@ async def protocol_commands(request: Request) -> JSONResponse:
                     key: value for key, value in persisted.interrupts.items() if key != interrupt_id
                 }
                 persisted.status = "busy"
+            old_run = await conn.session.get(RunRow, latest.run_id)
+            if old_run is not None:
+                old_kwargs = dict(old_run.kwargs or {})
+                if old_kwargs.get("stream_resumable") is True:
+                    old_kwargs["stream_resumable"] = False
+                    old_run.kwargs = old_kwargs
         return JSONResponse(
             {
                 "id": command_id,
@@ -321,10 +327,30 @@ async def protocol_event_stream(request: Request) -> JSONResponse | StreamingRes
             if (uid := _safe_uuid(wire.get("params", {}).get("run_id"))) is not None
         }
         resumable = await _resumable_run_ids(parsed_run_ids)
+        active_interrupt_ids = (
+            set(thread.interrupts.keys()) if isinstance(thread.interrupts, dict) else set()
+        )
+
+        def _is_active_protocol_event(w: dict[str, Any]) -> bool:
+            method = w.get("method")
+            params = w.get("params") or {}
+            data = params.get("data") or {}
+            is_input_req = (
+                method == "input.requested"
+                or (method == "input" and data.get("event") == "requested")
+                or data.get("event") == "input.requested"
+            )
+            if is_input_req:
+                iid = str(data.get("interrupt_id") or params.get("interrupt_id") or "")
+                if iid and iid not in active_interrupt_ids:
+                    return False
+            return True
+
         replay = [
             wire
             for wire in replay
-            if (uid := _safe_uuid(wire.get("params", {}).get("run_id"))) is None or uid in resumable
+            if ((uid := _safe_uuid(wire.get("params", {}).get("run_id"))) is None or uid in resumable)
+            and _is_active_protocol_event(wire)
         ]
     except Exception:
         await manager.remove_thread_stream(thread_id, queue)

{graphharbor-0.13.0.post34 → graphharbor-0.13.0.post35}/tests/test_stream_heartbeat_resilience.py

@@ -261,3 +261,84 @@ async def test_stream_response_headers_compliance(monkeypatch):
     assert "no-cache" in res_thread.headers["cache-control"]
     assert res_thread.headers["x-accel-buffering"] == "no"
     await res_thread.body_iterator.aclose()
+
+
+@pytest.mark.asyncio
+async def test_zombie_interrupt_replay_filtered(monkeypatch):
+    """Ensure resolved/historical input.requested events are filtered from replay."""
+    thread_id = uuid4()
+    run_id = uuid4()
+
+    # Active interrupts on thread only contains 'int-active'
+    mock_thread = ThreadRow(
+        thread_id=thread_id,
+        status="interrupted",
+        metadata_={},
+        config={},
+        values_={},
+        interrupts={"int-active": {"id": "int-active", "value": "Approve step 2"}},
+        error=None,
+    )
+
+    manager = InMemoryStreamManager()
+    monkeypatch.setattr("langhost.protocol_api.get_stream_manager", lambda: manager)
+    monkeypatch.setattr(
+        "langhost.protocol_api._thread",
+        lambda *a, **k: asyncio.sleep(0, result=mock_thread),
+    )
+    monkeypatch.setattr(
+        "langhost.streaming._resumable_run_ids",
+        lambda run_ids: asyncio.sleep(0, result=set(run_ids)),
+    )
+
+    # 2 historical events: seq 1 is zombie (int-old), seq 2 is active (int-active)
+    wire_old = protocol_event(
+        event_id="evt-1",
+        sequence=1,
+        run_id=str(run_id),
+        thread_id=str(thread_id),
+        event={
+            "event": "input.requested",
+            "data": {"interrupt_id": "int-old", "value": "Old resolved request"},
+        },
+    )
+    wire_active = protocol_event(
+        event_id="evt-2",
+        sequence=2,
+        run_id=str(run_id),
+        thread_id=str(thread_id),
+        event={
+            "event": "input.requested",
+            "data": {"interrupt_id": "int-active", "value": "Active request"},
+        },
+    )
+
+    monkeypatch.setattr(
+        "langhost.protocol_api._load_protocol_events",
+        lambda *a, **k: asyncio.sleep(0, result=(0, [wire_old, wire_active])),
+    )
+
+    scope, receive = _make_scope_and_receive(
+        "POST",
+        f"/threads/{thread_id}/stream/events",
+        {"thread_id": str(thread_id)},
+        body_dict={"channels": ["input"], "since": 0},
+    )
+    req = Request(scope, receive)
+    res = await protocol_event_stream(req)
+    assert isinstance(res, StreamingResponse)
+
+    frames: list[str] = []
+    try:
+        async for chunk in res.body_iterator:
+            frames.append(chunk)
+            # Replay emits immediately, break after replay
+            if "int-active" in chunk or len(frames) >= 2:
+                break
+    finally:
+        await res.body_iterator.aclose()
+
+    all_output = "".join(frames)
+    assert "int-old" not in all_output, "Zombie interrupt 'int-old' must NOT be replayed to client!"
+    assert "int-active" in all_output, "Active interrupt 'int-active' must be replayed to client!"
+