graphharbor 0.13.0.post35__tar.gz → 0.13.0.post36__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphharbor
-Version: 0.13.0.post35
+Version: 0.13.0.post36
 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.post35
+Requires-Dist: graphharbor-runtime==0.13.0.post36
 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.post35 → graphharbor-0.13.0.post36}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "graphharbor"
 # Lockstep with graphharbor-runtime; independent of langgraph-api releases.
-version = "0.13.0.post35"
+version = "0.13.0.post36"
 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.post35",
+    "graphharbor-runtime==0.13.0.post36",
 ]
 
 [project.urls]

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

@@ -264,10 +264,15 @@ async def _load_protocol_events(thread_id: UUID, since: int) -> tuple[int, list[
 
 
 def _wire_matches(wire: dict[str, Any], body: dict[str, Any]) -> bool:
-    method = str(wire.get("method", ""))
-    params = wire.get("params") or {}
+    if not isinstance(wire, dict):
+        return False
+    method = str(wire.get("method") or "")
+    params = wire.get("params")
+    params_dict = params if isinstance(params, dict) else {}
+    ns = params_dict.get("namespace")
+    ns_list = list(ns) if isinstance(ns, (list, tuple)) else []
     return _channel_matches(method, body.get("channels")) and _namespace_matches(
-        list(params.get("namespace") or []), body.get("namespaces"), body.get("depth")
+        ns_list, body.get("namespaces"), body.get("depth")
     )
 
 
@@ -321,36 +326,54 @@ async def protocol_event_stream(request: Request) -> JSONResponse | StreamingRes
                 {"code": "cursor_expired", "detail": "cursor_expired", "recovery": "thread_snapshot"},
                 status_code=410,
             )
-        parsed_run_ids = {
-            uid
-            for wire in replay
-            if (uid := _safe_uuid(wire.get("params", {}).get("run_id"))) is not None
-        }
+        parsed_run_ids: set[UUID] = set()
+        for wire in replay:
+            if isinstance(wire, dict):
+                params = wire.get("params")
+                if isinstance(params, dict):
+                    uid = _safe_uuid(params.get("run_id"))
+                    if uid is not None:
+                        parsed_run_ids.add(uid)
         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 {}
+        def _is_active_protocol_event(w: Any) -> bool:
+            if not isinstance(w, dict):
+                return True
+            method = str(w.get("method") or "")
+            params = w.get("params")
+            params_dict = params if isinstance(params, dict) else {}
+            data = params_dict.get("data")
+            data_dict = data if isinstance(data, dict) else {}
+            data_event = str(data_dict.get("event") or "")
+
             is_input_req = (
                 method == "input.requested"
-                or (method == "input" and data.get("event") == "requested")
-                or data.get("event") == "input.requested"
+                or (method == "input" and data_event == "requested")
+                or data_event == "input.requested"
             )
             if is_input_req:
-                iid = str(data.get("interrupt_id") or params.get("interrupt_id") or "")
+                iid = str(data_dict.get("interrupt_id") or params_dict.get("interrupt_id") or "")
                 if iid and iid not in active_interrupt_ids:
                     return False
             return True
 
+        def _is_resumable(wire: Any) -> bool:
+            if not isinstance(wire, dict):
+                return True
+            params = wire.get("params")
+            if isinstance(params, dict):
+                uid = _safe_uuid(params.get("run_id"))
+                if uid is not None and uid not in resumable:
+                    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)
-            and _is_active_protocol_event(wire)
+            if _is_resumable(wire) and _is_active_protocol_event(wire)
         ]
     except Exception:
         await manager.remove_thread_stream(thread_id, queue)

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

@@ -342,3 +342,95 @@ async def test_zombie_interrupt_replay_filtered(monkeypatch):
     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!"
 
+
+@pytest.mark.asyncio
+async def test_protocol_stream_replay_with_non_dict_data_payloads(monkeypatch):
+    """Ensure protocol stream replay handles events where data is a list, string, or params is malformed."""
+    thread_id = uuid4()
+    run_id = uuid4()
+
+    mock_thread = ThreadRow(
+        thread_id=thread_id,
+        status="busy",
+        metadata_={},
+        config={},
+        values_={},
+        interrupts={},
+        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 rids: asyncio.sleep(0, result=rids),
+    )
+
+    # Various weird payloads that occur in real production (list data, none params, string data)
+    wire_list_data = {
+        "type": "event",
+        "event_id": "evt-list",
+        "seq": 1,
+        "method": "messages",
+        "params": {
+            "run_id": str(run_id),
+            "thread_id": str(thread_id),
+            "namespace": [],
+            "data": [{"delta": {"type": "block-delta", "text": "hello"}}],
+        },
+    }
+    wire_string_data = {
+        "type": "event",
+        "event_id": "evt-str",
+        "seq": 2,
+        "method": "custom",
+        "params": {
+            "run_id": str(run_id),
+            "thread_id": str(thread_id),
+            "namespace": [],
+            "data": "plain string",
+        },
+    }
+    wire_none_params = {
+        "type": "event",
+        "event_id": "evt-none-params",
+        "seq": 3,
+        "method": "custom",
+        "params": None,
+    }
+
+    monkeypatch.setattr(
+        "langhost.protocol_api._load_protocol_events",
+        lambda *a, **k: asyncio.sleep(
+            0, result=(0, [wire_list_data, wire_string_data, wire_none_params])
+        ),
+    )
+
+    scope, receive = _make_scope_and_receive(
+        "POST",
+        f"/threads/{thread_id}/stream/events",
+        {"thread_id": str(thread_id)},
+        body_dict={"channels": ["messages", "custom"], "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)
+            if len(frames) >= 2:
+                break
+    finally:
+        await res.body_iterator.aclose()
+
+    all_output = "".join(frames)
+    assert "evt-list" in all_output
+    assert "evt-str" in all_output
+
+