graphharbor 0.13.0.post35__tar.gz → 0.13.0.post37__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphharbor
-Version: 0.13.0.post35
+Version: 0.13.0.post37
 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.post37
 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.post37}/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.post37"
 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.post37",
 ]
 
 [project.urls]

{graphharbor-0.13.0.post35 → graphharbor-0.13.0.post37}/src/langhost/core_api.py

@@ -858,10 +858,16 @@ async def threads_delete(request: Request) -> JSONResponse | Response:
     return _no_content()
 
 
-def _checkpoint_config(thread_id: UUID, checkpoint_id: str | None = None) -> dict[str, Any]:
+def _checkpoint_config(
+    thread_id: UUID,
+    checkpoint_id: str | None = None,
+    checkpoint_ns: str | None = None,
+) -> dict[str, Any]:
     configurable: dict[str, Any] = {"thread_id": str(thread_id)}
     if checkpoint_id:
         configurable["checkpoint_id"] = checkpoint_id
+    if checkpoint_ns is not None:
+        configurable["checkpoint_ns"] = checkpoint_ns
     return {"configurable": configurable}
 
 
@@ -936,57 +942,73 @@ async def threads_state(request: Request) -> JSONResponse:
     if row is None or thread_id is None:
         return _error("thread not found", 404)
     checkpoint_id = request.path_params.get("checkpoint_id")
-    if not checkpoint_id and request.method == "POST":
+    checkpoint_ns = request.query_params.get("checkpoint_ns")
+    if request.method == "POST":
         try:
             body = await request.json()
             if isinstance(body, dict):
                 cp_data = body.get("checkpoint")
                 if isinstance(cp_data, dict):
-                    checkpoint_id = cp_data.get("checkpoint_id")
-                elif isinstance(cp_data, str):
+                    if not checkpoint_id:
+                        checkpoint_id = cp_data.get("checkpoint_id")
+                    if not checkpoint_ns:
+                        checkpoint_ns = cp_data.get("checkpoint_ns")
+                elif isinstance(cp_data, str) and not checkpoint_id:
                     checkpoint_id = cp_data
                 if not checkpoint_id:
                     checkpoint_id = body.get("checkpoint_id")
+                if not checkpoint_ns:
+                    checkpoint_ns = body.get("checkpoint_ns")
         except Exception:
             pass
 
+    is_subgraph = bool(checkpoint_ns)
+    config = cast(
+        RunnableConfig,
+        _checkpoint_config(thread_id, checkpoint_id=checkpoint_id, checkpoint_ns=checkpoint_ns),
+    )
     registry = getattr(request.app.state, "graph_registry", None)
     graph_id = row.graph_id or row.metadata_.get("graph_id")
-    if registry is not None and graph_id and str(graph_id) in registry.ids():
-        config = cast(RunnableConfig, _checkpoint_config(thread_id, checkpoint_id))
+    # Subgraphs invoked dynamically within tools do not exist in the root graph's
+    # static topology; querying the compiled graph would raise SubgraphNotFound.
+    # Route subgraphs directly to the persistent checkpointer.
+    if not is_subgraph and registry is not None and graph_id and str(graph_id) in registry.ids():
         try:
             async with registry.open(str(graph_id), config) as graph:
                 return JSONResponse(_state_from_snapshot(await graph.aget_state(config)))
         except Exception as exc:
             return _error(f"checkpoint read failed: {exc}", 503)
     try:
-        item = await get_checkpointer().aget_tuple(
-            cast(RunnableConfig, _checkpoint_config(thread_id, checkpoint_id))
-        )
+        item = await get_checkpointer().aget_tuple(config)
     except Exception as exc:
         return _error(f"checkpoint read failed: {exc}", 503)
     if item is None:
         return JSONResponse(
             _plain(
                 {
-                    "values": row.values_ or {},
+                    "values": {} if is_subgraph else (row.values_ or {}),
                     "next": [],
-                    "checkpoint": _checkpoint_key(_checkpoint_config(thread_id, checkpoint_id)),
+                    "checkpoint": _checkpoint_key(config),
                     "metadata": {},
                     "created_at": None,
                     "parent_checkpoint": None,
                     "tasks": [],
-                    "interrupts": _stored_interrupts(row),
+                    "interrupts": [] if is_subgraph else _stored_interrupts(row),
                 }
             )
         )
     state = _state_from_tuple(item)
-    if not state.get("interrupts"):
+    if not is_subgraph and not state.get("interrupts"):
         state["interrupts"] = _stored_interrupts(row)
     # Some LangChain/Deep Agents checkpoints keep only scheduler bookkeeping in
     # channel_values while the durable thread row has the final projected state.
     # Expose that state instead of returning the misleading bare __pregel_tasks.
-    if checkpoint_id is None and not _has_projected_values(state.get("values")) and row.values_:
+    if (
+        not is_subgraph
+        and checkpoint_id is None
+        and not _has_projected_values(state.get("values"))
+        and row.values_
+    ):
         state["values"] = _plain(row.values_)
     return JSONResponse(state)
 
@@ -1002,7 +1024,18 @@ async def threads_history(request: Request) -> JSONResponse:
         limit, _ = _pagination(request, payload)
     except ValueError as exc:
         return _error(str(exc))
-    config = cast(RunnableConfig, _checkpoint_config(thread_id))
+
+    checkpoint_ns: str | None = None
+    if request.method == "POST":
+        cp_data = payload.get("checkpoint")
+        if isinstance(cp_data, dict):
+            checkpoint_ns = cp_data.get("checkpoint_ns")
+        if not checkpoint_ns:
+            checkpoint_ns = payload.get("checkpoint_ns")
+    if not checkpoint_ns:
+        checkpoint_ns = request.query_params.get("checkpoint_ns")
+
+    config = cast(RunnableConfig, _checkpoint_config(thread_id, checkpoint_ns=checkpoint_ns))
     before = (
         payload.get("before") if request.method == "POST" else request.query_params.get("before")
     )
@@ -1011,12 +1044,16 @@ async def threads_history(request: Request) -> JSONResponse:
             before = json.loads(before)
         except (TypeError, json.JSONDecodeError):
             return _error("before must be a JSON object")
-    if isinstance(before, dict):
+    if isinstance(before, str):
+        before = {"configurable": {"checkpoint_id": before}}
+    elif isinstance(before, dict):
         before = {"configurable": before}
     before_config = cast(RunnableConfig | None, before)
+
+    is_subgraph = bool(checkpoint_ns)
     registry = getattr(request.app.state, "graph_registry", None)
     graph_id = row.graph_id or row.metadata_.get("graph_id")
-    if registry is not None and graph_id and str(graph_id) in registry.ids():
+    if not is_subgraph and registry is not None and graph_id and str(graph_id) in registry.ids():
         try:
             async with registry.open(str(graph_id), config) as graph:
                 return JSONResponse(

{graphharbor-0.13.0.post35 → graphharbor-0.13.0.post37}/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.post37}/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
+
+

graphharbor-0.13.0.post37/tests/test_subagent_history.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import json
+from contextlib import asynccontextmanager
+from types import SimpleNamespace
+from typing import Annotated, TypedDict
+from uuid import uuid4
+
+import pytest
+from langgraph.channels import DeltaChannel
+from langgraph.checkpoint.base import empty_checkpoint
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.graph import END, START, StateGraph
+from starlette.requests import Request
+
+from langhost import core_api
+
+
+class RootState(TypedDict):
+    messages: Annotated[
+        list[str],
+        DeltaChannel(lambda state, writes: state + [item for batch in writes for item in batch]),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_subagent_namespace_state_and_history(monkeypatch):
+    tid = uuid4()
+    root_config = {"configurable": {"thread_id": str(tid), "checkpoint_ns": ""}}
+    subagent_ns = "tools:call_subagent_abc123"
+
+    saver = InMemorySaver()
+
+    # 1. 模拟根图执行，保存在根命名空间
+    root_graph = (
+        StateGraph(RootState)
+        .add_node("agent", lambda state: {"messages": ["call task tool"]})
+        .add_edge(START, "agent")
+        .add_edge("agent", END)
+        .compile(checkpointer=saver)
+    )
+    await root_graph.ainvoke({"messages": ["user prompt"]}, root_config)
+
+    # 2. 模拟 Subagent 在独立命名空间下的执行历史（写入多个 step checkpoint）
+    # Step 1: Subagent 接收指令并发出 read_file 工具调用
+    cp_id_1 = "00000000-0000-0000-0000-000000000001"
+    config_step1 = {
+        "configurable": {
+            "thread_id": str(tid),
+            "checkpoint_ns": subagent_ns,
+            "checkpoint_id": cp_id_1,
+        }
+    }
+    cp1 = empty_checkpoint()
+    cp1["id"] = cp_id_1
+    cp1["channel_values"] = {
+        "messages": [
+            {"role": "human", "content": "investigate code"},
+            {"role": "ai", "tool_calls": [{"name": "read_file", "args": {"path": "main.py"}}]},
+        ]
+    }
+    cp1["channel_versions"] = {"messages": 1}
+    await saver.aput(config_step1, cp1, {"step": 1}, {"messages": 1})
+
+    # Step 2: Subagent 获得 read_file 返回并给出最终结论
+    cp_id_2 = "00000000-0000-0000-0000-000000000002"
+    config_step2 = {
+        "configurable": {
+            "thread_id": str(tid),
+            "checkpoint_ns": subagent_ns,
+            "checkpoint_id": cp_id_2,
+        }
+    }
+    cp2 = empty_checkpoint()
+    cp2["id"] = cp_id_2
+    cp2["channel_values"] = {
+        "messages": [
+            {"role": "human", "content": "investigate code"},
+            {"role": "ai", "tool_calls": [{"name": "read_file", "args": {"path": "main.py"}}]},
+            {"role": "tool", "name": "read_file", "content": "def main(): pass"},
+            {"role": "ai", "content": "investigation finished"},
+        ]
+    }
+    cp2["channel_versions"] = {"messages": 2}
+    await saver.aput(config_step2, cp2, {"step": 2}, {"messages": 2})
+
+    # 3. 准备 mock 的 graph_registry 与 get_checkpointer
+    @asynccontextmanager
+    async def opened(graph_id, run_config):
+        # 静态注册中只有 root_graph，子图在 registry 中并不存在
+        assert graph_id == "root_agent"
+        yield root_graph
+
+    async def get_thread(request):
+        return (
+            SimpleNamespace(
+                graph_id="root_agent",
+                metadata_={},
+                values_={"messages": ["root cached messages"]},
+                interrupts={},
+            ),
+            None,
+            tid,
+        )
+
+    monkeypatch.setattr(core_api, "_get_thread", get_thread)
+    monkeypatch.setattr(core_api, "get_checkpointer", lambda: saver)
+
+    app = SimpleNamespace(
+        state=SimpleNamespace(
+            graph_registry=SimpleNamespace(open=opened, ids=lambda: ("root_agent",))
+        )
+    )
+
+    # 4. 场景 1：根图默认查询（回归测试）
+    req_root = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "app": app,
+            "path_params": {},
+            "query_string": b"",
+        }
+    )
+    root_state = json.loads((await core_api.threads_state(req_root)).body)
+    assert root_state["checkpoint"]["checkpoint_ns"] == ""
+    assert root_state["values"]["messages"] == ["user prompt", "call task tool"]
+
+    # 5. 场景 2：通过 POST /state/checkpoint 指定子图 checkpoint_ns 查询最新状态
+    req_sub_post = Request(
+        {
+            "type": "http",
+            "method": "POST",
+            "app": app,
+            "path_params": {},
+            "query_string": b"",
+        }
+    )
+    req_sub_post._json = {"checkpoint": {"checkpoint_ns": subagent_ns}}
+    sub_state_post = json.loads((await core_api.threads_state(req_sub_post)).body)
+    assert sub_state_post["checkpoint"]["checkpoint_ns"] == subagent_ns
+    assert sub_state_post["checkpoint"]["checkpoint_id"] == cp_id_2
+    assert len(sub_state_post["values"]["messages"]) == 4
+    assert sub_state_post["values"]["messages"][1]["tool_calls"][0]["name"] == "read_file"
+    assert sub_state_post["values"]["messages"][3]["content"] == "investigation finished"
+
+    # 6. 场景 3：通过 GET /state?checkpoint_ns=... 查询最新状态
+    req_sub_get = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "app": app,
+            "path_params": {},
+            "query_string": f"checkpoint_ns={subagent_ns}".encode(),
+        }
+    )
+    sub_state_get = json.loads((await core_api.threads_state(req_sub_get)).body)
+    assert sub_state_get["checkpoint"]["checkpoint_ns"] == subagent_ns
+    assert sub_state_get["values"] == sub_state_post["values"]
+
+    # 7. 场景 4：指定特定 checkpoint_id 获取子图历史某一步状态
+    req_sub_step1 = Request(
+        {
+            "type": "http",
+            "method": "POST",
+            "app": app,
+            "path_params": {},
+            "query_string": b"",
+        }
+    )
+    req_sub_step1._json = {
+        "checkpoint": {
+            "checkpoint_ns": subagent_ns,
+            "checkpoint_id": cp_id_1,
+        }
+    }
+    sub_step1_state = json.loads((await core_api.threads_state(req_sub_step1)).body)
+    assert sub_step1_state["checkpoint"]["checkpoint_id"] == cp_id_1
+    assert len(sub_step1_state["values"]["messages"]) == 2
+
+    # 8. 场景 5：通过 POST /history 指定子图 checkpoint_ns 查询历史列表
+    req_hist_post = Request(
+        {
+            "type": "http",
+            "method": "POST",
+            "app": app,
+            "path_params": {},
+            "query_string": b"",
+        }
+    )
+    req_hist_post._json = {"checkpoint": {"checkpoint_ns": subagent_ns}, "limit": 10}
+    sub_hist = json.loads((await core_api.threads_history(req_hist_post)).body)
+    assert len(sub_hist) == 2
+    # 历史列表按倒序排列（最新在前）
+    assert sub_hist[0]["checkpoint"]["checkpoint_id"] == cp_id_2
+    assert sub_hist[1]["checkpoint"]["checkpoint_id"] == cp_id_1
+    for item in sub_hist:
+        assert item["checkpoint"]["checkpoint_ns"] == subagent_ns
+
+    # 9. 场景 6：查询不存在的子图命名空间，返回空 values，不被根图数据污染
+    req_nonexistent = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "app": app,
+            "path_params": {},
+            "query_string": b"checkpoint_ns=tools:nonexistent_call",
+        }
+    )
+    nonexistent_state = json.loads((await core_api.threads_state(req_nonexistent)).body)
+    assert nonexistent_state["checkpoint"]["checkpoint_ns"] == "tools:nonexistent_call"
+    assert nonexistent_state["values"] == {}
+    assert nonexistent_state["interrupts"] == []