graphharbor 0.13.0.post33__tar.gz → 0.13.0.post35__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphharbor
-Version: 0.13.0.post33
+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.post33
+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.post33 → 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.post33"
+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.post33",
+    "graphharbor-runtime==0.13.0.post35",
 ]
 
 [project.urls]

{graphharbor-0.13.0.post33 → 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,
@@ -271,6 +277,15 @@ def _frame(wire: dict[str, Any]) -> str:
     return f"id: {seq}\nevent: event\ndata: {data}\n\n"
 
 
+def _safe_uuid(value: Any) -> UUID | None:
+    if not value:
+        return None
+    try:
+        return UUID(str(value))
+    except (ValueError, TypeError):
+        return None
+
+
 async def protocol_event_stream(request: Request) -> JSONResponse | StreamingResponse:
     from langhost.streaming import _resumable_run_ids
 
@@ -300,67 +315,117 @@ async def protocol_event_stream(request: Request) -> JSONResponse | StreamingRes
     queue = await manager.add_thread_stream(thread_id)
     try:
         watermark, replay = await _load_protocol_events(thread_id, since)
+        if since and since < watermark:
+            await manager.remove_thread_stream(thread_id, queue)
+            return JSONResponse(
+                {"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
+        }
+        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)
+            and _is_active_protocol_event(wire)
+        ]
     except Exception:
         await manager.remove_thread_stream(thread_id, queue)
         raise
-    if since and since < watermark:
-        await manager.remove_thread_stream(thread_id, queue)
-        return JSONResponse(
-            {"code": "cursor_expired", "detail": "cursor_expired", "recovery": "thread_snapshot"},
-            status_code=410,
-        )
-    resumable = await _resumable_run_ids(
-        {UUID(wire["params"]["run_id"]) for wire in replay if wire.get("params", {}).get("run_id")}
-    )
-    replay = [
-        wire
-        for wire in replay
-        if not wire.get("params", {}).get("run_id") or UUID(wire["params"]["run_id"]) in resumable
-    ]
 
     async def stream() -> AsyncIterator[str]:
         metric_inc("graphharbor_protocol_connections_opened_total")
         if since:
             metric_inc("graphharbor_protocol_replays_total")
         seen: set[int] = set()
-        try:
+        loop = asyncio.get_running_loop()
+        last_sent_at = loop.time()
+        last_auth_at = loop.time()
+
+        async def _check_authorized() -> bool:
+            nonlocal last_auth_at
+            now_ = loop.time()
+            if now_ - last_auth_at < 10.0:
+                return True
             if await _thread(request, thread_id) is None:
+                return False
+            last_auth_at = now_
+            return True
+
+        try:
+            if not await _check_authorized():
                 return
             for wire in replay:
-                if await _thread(request, thread_id) is None:
-                    return
                 seq = wire.get("seq")
                 if isinstance(seq, int) and seq not in seen and _wire_matches(wire, body):
                     seen.add(seq)
                     metric_inc("graphharbor_protocol_events_total")
                     yield _frame(wire)
-            started = asyncio.get_running_loop().time()
-            while asyncio.get_running_loop().time() - started < timeout:
+                    last_sent_at = loop.time()
+            started = loop.time()
+            while loop.time() - started < timeout:
+                now = loop.time()
+                remaining = max(0.1, heartbeat - (now - last_sent_at))
                 try:
-                    message = await asyncio.wait_for(queue.get(), timeout=heartbeat)
+                    message = await asyncio.wait_for(queue.get(), timeout=remaining)
                 except TimeoutError:
                     if await request.is_disconnected():
                         return
-                    if await _thread(request, thread_id) is None:
+                    if not await _check_authorized():
                         return
                     yield ": heartbeat\n\n"
+                    last_sent_at = loop.time()
                     continue
-                if await _thread(request, thread_id) is None:
+                if not await _check_authorized():
                     return
                 try:
-                    wire = json.loads(message.data)
+                    payload = json.loads(message.data)
                 except (TypeError, ValueError, json.JSONDecodeError):
+                    payload = None
+                if not isinstance(payload, dict):
+                    if loop.time() - last_sent_at >= heartbeat:
+                        yield ": heartbeat\n\n"
+                        last_sent_at = loop.time()
                     continue
-                if not isinstance(wire, dict):
-                    continue
+                wire = payload
                 seq = wire.get("seq")
-                if not isinstance(seq, int) or seq <= since or seq in seen:
-                    continue
-                if not _wire_matches(wire, body):
+                if (
+                    not isinstance(seq, int)
+                    or seq <= since
+                    or seq in seen
+                    or not _wire_matches(wire, body)
+                ):
+                    if loop.time() - last_sent_at >= heartbeat:
+                        yield ": heartbeat\n\n"
+                        last_sent_at = loop.time()
                     continue
                 seen.add(seq)
                 metric_inc("graphharbor_protocol_events_total")
                 yield _frame(wire)
+                last_sent_at = loop.time()
             yield ": stream timeout\n\n"
         finally:
             metric_inc("graphharbor_protocol_connections_closed_total")
@@ -369,7 +434,11 @@ async def protocol_event_stream(request: Request) -> JSONResponse | StreamingRes
     return StreamingResponse(
         stream(),
         media_type="text/event-stream",
-        headers={"Cache-Control": "no-store", "X-Accel-Buffering": "no"},
+        headers={
+            "Cache-Control": "no-cache, no-transform",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
     )
 
 

{graphharbor-0.13.0.post33 → graphharbor-0.13.0.post35}/src/langhost/server.py

@@ -8,40 +8,29 @@ import os
 import pathlib
 import sys
 from contextlib import asynccontextmanager
-from datetime import UTC, datetime
+from datetime import datetime
 from typing import Any
 from uuid import UUID
 
 import uvicorn
 from langgraph_cli.config import validate_config_file
-from sqlalchemy import func, select
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
 from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import Request
-from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.responses import HTMLResponse, JSONResponse
 from starlette.routing import Mount, Route
 
 from langgraph_runtime_pg.auth import (
     PrincipalMiddleware,
-    in_principal_scope,
     principal_from_scope,
-    scoped_idempotency_key,
 )
 from langgraph_runtime_pg.checkpoint import get_checkpointer
-from langgraph_runtime_pg.database import connect, pool_stats
+from langgraph_runtime_pg.database import pool_stats
 from langgraph_runtime_pg.graph_registry import GraphRegistry, resolve_within_base_dir
 from langgraph_runtime_pg.metrics import prometheus_text, set_gauge
-from langgraph_runtime_pg.models import (
-    AssistantRow,
-    AssistantVersionRow,
-    RunRow,
-    ThreadRow,
-)
 from langgraph_runtime_pg.production import RuntimeReadiness, lifespan as runtime_lifespan
 from langgraph_runtime_pg.protocol import official_info_document
-from langgraph_runtime_pg.redis_stream import wake_run_queue
-from langgraph_runtime_pg.run_store import RunRepository
 from langhost.core_api import (
     assistants_count,
     assistants_create,
@@ -360,137 +349,6 @@ async def _metrics(_: Request):
     return PlainTextResponse(prometheus_text(), media_type="text/plain; version=0.0.4")
 
 
-def _no_content() -> Response:
-    return Response(status_code=204)
-
-
-async def _capability_unavailable(request: Request) -> JSONResponse:
-    capability = request.path_params.get("capability", "stream_v2")
-    return JSONResponse(
-        {
-            "detail": f"capability {capability!r} is not enabled in the foundation profile",
-            "capability": capability,
-            "status": 501,
-        },
-        status_code=501,
-    )
-
-
-def _scope_query(query: Any, model: Any, principal: Any) -> Any:
-    return query
-
-
-def _metadata_query(query: Any, model: Any, metadata: Any) -> Any:
-    if isinstance(metadata, dict) and metadata:
-        query = query.where(model.metadata_.contains(metadata))
-    return query
-
-
-def _request_limit_offset(request: Request) -> tuple[int, int]:
-    try:
-        limit = max(1, min(int(request.query_params.get("limit", "10")), 1000))
-        offset = max(0, int(request.query_params.get("offset", "0")))
-    except ValueError as exc:
-        raise ValueError("limit and offset must be integers") from exc
-    return limit, offset
-
-
-async def _assistant_search(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    payload = await request.json()
-    try:
-        limit, offset = _request_limit_offset(request)
-    except ValueError as exc:
-        return JSONResponse({"detail": str(exc)}, status_code=422)
-    query = select(AssistantRow).order_by(AssistantRow.created_at.desc())
-    query = _scope_query(query, AssistantRow, principal)
-    query = _metadata_query(query, AssistantRow, payload.get("metadata"))
-    if payload.get("graph_id"):
-        query = query.where(AssistantRow.graph_id == str(payload["graph_id"]))
-    if payload.get("name"):
-        query = query.where(AssistantRow.name.ilike(f"%{payload['name']}%"))
-    async with connect() as conn:
-        rows = (await conn.session.execute(query.limit(limit).offset(offset))).scalars().all()
-        values = [_assistant_payload(row) for row in rows]
-    if payload.get("response_format") == "object":
-        return JSONResponse({"assistants": values, "next": None})
-    return JSONResponse(values)
-
-
-async def _assistant_count(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    payload = await request.json()
-    query = select(func.count()).select_from(AssistantRow)
-    query = _scope_query(query, AssistantRow, principal)
-    query = _metadata_query(query, AssistantRow, payload.get("metadata"))
-    if payload.get("graph_id"):
-        query = query.where(AssistantRow.graph_id == str(payload["graph_id"]))
-    if payload.get("name"):
-        query = query.where(AssistantRow.name.ilike(f"%{payload['name']}%"))
-    async with connect() as conn:
-        count = int(await conn.session.scalar(query) or 0)
-    return JSONResponse(count)
-
-
-async def _assistant_update(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    try:
-        assistant_id = UUID(request.path_params["assistant_id"])
-    except ValueError:
-        return JSONResponse({"detail": "assistant not found"}, status_code=404)
-    payload = await request.json()
-    async with connect() as conn:
-        query = _scope_query(
-            select(AssistantRow).where(AssistantRow.assistant_id == assistant_id),
-            AssistantRow,
-            principal,
-        )
-        row = (await conn.session.execute(query)).scalar_one_or_none()
-        if row is None:
-            return JSONResponse({"detail": "assistant not found"}, status_code=404)
-        for field in ("graph_id", "name", "description", "config", "context"):
-            if field in payload:
-                setattr(row, field, payload[field])
-        if isinstance(payload.get("metadata"), dict):
-            row.metadata_ = {**row.metadata_, **payload["metadata"]}
-        row.version += 1
-        row.updated_at = datetime.now(UTC)
-        conn.session.add(
-            AssistantVersionRow(
-                assistant_id=row.assistant_id,
-                version=row.version,
-                graph_id=row.graph_id,
-                config=row.config,
-                context=row.context,
-                metadata_=row.metadata_,
-                name=row.name,
-                description=row.description,
-            )
-        )
-        await conn.session.flush()
-        return JSONResponse(_assistant_payload(row))
-
-
-async def _assistant_delete(request: Request) -> JSONResponse | Response:
-    principal = _principal(request)
-    try:
-        assistant_id = UUID(request.path_params["assistant_id"])
-    except ValueError:
-        return _no_content()
-    async with connect() as conn:
-        query = _scope_query(
-            select(AssistantRow).where(AssistantRow.assistant_id == assistant_id),
-            AssistantRow,
-            principal,
-        )
-        row = (await conn.session.execute(query)).scalar_one_or_none()
-        if row is None:
-            return _no_content()
-        await conn.session.delete(row)
-        await conn.session.flush()
-    return _no_content()
-
-
 async def _assistants(request: Request) -> JSONResponse:
     request._json = dict(request.query_params)
     return await assistants_search(request)
@@ -501,152 +359,6 @@ async def _threads(request: Request) -> JSONResponse:
     return await threads_search(request)
 
 
-async def _assistant_get(request: Request) -> JSONResponse:
-    try:
-        assistant_id = UUID(request.path_params["assistant_id"])
-    except ValueError:
-        return JSONResponse({"detail": "assistant not found"}, status_code=404)
-    async with connect() as conn:
-        query = select(AssistantRow).where(AssistantRow.assistant_id == assistant_id)
-        row = (await conn.session.execute(query)).scalar_one_or_none()
-        if row is None:
-            return JSONResponse({"detail": "assistant not found"}, status_code=404)
-        return JSONResponse(_assistant_payload(row))
-
-
-async def _thread_get(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    try:
-        thread_id = UUID(request.path_params["thread_id"])
-    except ValueError:
-        return JSONResponse({"detail": "thread not found"}, status_code=404)
-    async with connect() as conn:
-        row = await conn.session.get(ThreadRow, thread_id)
-        if row is None or not in_principal_scope(row, principal):
-            return JSONResponse({"detail": "thread not found"}, status_code=404)
-        return JSONResponse(_thread_payload(row))
-
-
-async def _resolve_assistant(
-    session: Any, assistant_value: str, principal: Any
-) -> AssistantRow | None:
-    try:
-        assistant_id = UUID(assistant_value)
-        query = select(AssistantRow).where(AssistantRow.assistant_id == assistant_id)
-    except ValueError:
-        query = select(AssistantRow).where(AssistantRow.graph_id == assistant_value)
-    return (await session.execute(query.limit(1))).scalar_one_or_none()
-
-
-async def _run_create(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    payload = await request.json()
-    assistant_value = str(payload.get("assistant_id", ""))
-    thread_value = request.path_params.get("thread_id")
-    if not assistant_value:
-        return JSONResponse({"detail": "assistant_id is required"}, status_code=422)
-    async with connect() as conn:
-        assistant = await _resolve_assistant(conn.session, assistant_value, principal)
-        if assistant is None:
-            return JSONResponse({"detail": "assistant not found"}, status_code=404)
-        thread = None
-        thread_id = UUID(str(thread_value)) if thread_value else None
-        if thread_id is not None:
-            thread = await conn.session.get(ThreadRow, thread_id)
-            if thread is None or not in_principal_scope(thread, principal):
-                return JSONResponse({"detail": "thread not found"}, status_code=404)
-        raw_idempotency_key = request.headers.get("idempotency-key") or payload.get(
-            "idempotency_key"
-        )
-        idempotency_key = scoped_idempotency_key(principal, raw_idempotency_key)
-        run = await RunRepository().create(
-            conn.session,
-            assistant_id=assistant.assistant_id,
-            thread_id=thread_id,
-            kwargs=payload,
-            metadata=payload.get("metadata") or {},
-            idempotency_key=idempotency_key,
-        )
-        await conn.session.refresh(run)
-        conn.schedule_after_commit(wake_run_queue)
-        return JSONResponse(_run_payload(run), status_code=201)
-
-
-async def _run_get(request: Request) -> JSONResponse:
-    principal = _principal(request)
-    run_id = UUID(request.path_params["run_id"])
-    thread_id = UUID(request.path_params["thread_id"])
-    async with connect() as conn:
-        run = await conn.session.get(RunRow, run_id)
-        if run is None or run.thread_id != thread_id or not in_principal_scope(run, principal):
-            return JSONResponse({"detail": "run not found"}, status_code=404)
-        return JSONResponse(_run_payload(run))
-
-
-async def _run_list(request: Request) -> JSONResponse:
-    thread_id = UUID(request.path_params["thread_id"])
-    async with connect() as conn:
-        query = (
-            select(RunRow).where(RunRow.thread_id == thread_id).order_by(RunRow.created_at.desc())
-        )
-        rows = (await conn.session.execute(query)).scalars().all()
-        return JSONResponse([_run_payload(row) for row in rows])
-
-
-async def _run_cancel(request: Request) -> JSONResponse:
-    return await runs_cancel(request)
-
-
-def _assistant_payload(row: AssistantRow) -> dict[str, Any]:
-    return _plain(
-        {
-            "assistant_id": row.assistant_id,
-            "graph_id": row.graph_id,
-            "name": row.name,
-            "description": row.description,
-            "config": row.config,
-            "context": row.context,
-            "metadata": row.metadata_,
-            "version": row.version,
-            "created_at": row.created_at,
-            "updated_at": row.updated_at,
-        }
-    )
-
-
-def _thread_payload(row: ThreadRow) -> dict[str, Any]:
-    return _plain(
-        {
-            "thread_id": row.thread_id,
-            "status": row.status,
-            "metadata": row.metadata_,
-            "config": row.config,
-            "values": row.values_,
-            "interrupts": row.interrupts,
-            "error": row.error,
-            "created_at": row.created_at,
-            "updated_at": row.updated_at,
-            "state_updated_at": row.state_updated_at,
-        }
-    )
-
-
-def _run_payload(row: RunRow) -> dict[str, Any]:
-    return _plain(
-        {
-            "run_id": row.run_id,
-            "thread_id": row.thread_id,
-            "assistant_id": row.assistant_id,
-            "status": row.status,
-            "metadata": row.metadata_,
-            "kwargs": row.kwargs,
-            "multitask_strategy": row.multitask_strategy,
-            "created_at": row.created_at,
-            "updated_at": row.updated_at,
-        }
-    )
-
-
 def create_app(
     config: dict[str, Any] | Any,
     *,

{graphharbor-0.13.0.post33 → graphharbor-0.13.0.post35}/src/langhost/store_api.py

@@ -31,13 +31,13 @@ def _namespace_error(namespace: Sequence[str]) -> Response | None:
     return None
 
 
-def _namespace(request: Request, value: Any) -> tuple[str, ...] | None:
+def _namespace(value: Any, request: Request | None = None) -> tuple[str, ...] | None:
     if not isinstance(value, list) or not all(isinstance(label, str) for label in value):
         return None
     return tuple(value)
 
 
-def _public_namespace(request: Request, value: Sequence[str]) -> list[str]:
+def _public_namespace(value: Sequence[str], request: Request | None = None) -> list[str]:
     return list(value)
 
 
@@ -61,7 +61,7 @@ async def _authorize_store(request: Request, action: str, value: dict[str, Any])
 
 def _item(request: Request, value: Any) -> dict[str, Any]:
     data = value.dict()
-    data["namespace"] = _public_namespace(request, data["namespace"])
+    data["namespace"] = _public_namespace(data["namespace"])
     return data
 
 
@@ -77,10 +77,10 @@ async def store_put(request: Request) -> Response:
     payload = await _body(request)
     if payload is None or "key" not in payload or "value" not in payload:
         return JSONResponse({"detail": "namespace, key and value are required"}, status_code=422)
-    namespace = _namespace(request, payload.get("namespace"))
+    namespace = _namespace(payload.get("namespace"))
     if namespace is None:
         return JSONResponse({"detail": "namespace must be an array of strings"}, status_code=422)
-    if error := _namespace_error(namespace[-len(payload["namespace"]) :]):
+    if error := _namespace_error(namespace):
         return error
     if not isinstance(payload["key"], str) or not isinstance(payload["value"], dict):
         return JSONResponse(
@@ -110,8 +110,11 @@ async def store_put(request: Request) -> Response:
 
 
 async def store_get(request: Request) -> JSONResponse | Response:
-    labels = request.query_params.get("namespace", "").split(".")
-    namespace = _namespace(request, labels)
+    raw_namespace = request.query_params.get("namespace")
+    if not raw_namespace:
+        return JSONResponse({"detail": "namespace is required"}, status_code=422)
+    labels = raw_namespace.split(".")
+    namespace = _namespace(labels)
     if namespace is None:
         return JSONResponse({"detail": "namespace must be an array of strings"}, status_code=422)
     if error := _namespace_error(labels):
@@ -133,10 +136,10 @@ async def store_delete(request: Request) -> JSONResponse | Response:
     payload = await _body(request)
     if payload is None or "key" not in payload:
         return JSONResponse({"detail": "namespace and key are required"}, status_code=422)
-    namespace = _namespace(request, payload.get("namespace"))
+    namespace = _namespace(payload.get("namespace"))
     if namespace is None:
         return JSONResponse({"detail": "namespace must be an array of strings"}, status_code=422)
-    if error := _namespace_error(namespace[-len(payload["namespace"]) :]):
+    if error := _namespace_error(namespace):
         return error
     if not isinstance(payload["key"], str):
         return JSONResponse({"detail": "key must be a string"}, status_code=422)
@@ -150,7 +153,7 @@ async def store_search(request: Request) -> JSONResponse | Response:
     if payload is None:
         return JSONResponse({"detail": "request body must be an object"}, status_code=422)
     labels = payload.get("namespace_prefix")
-    namespace = _namespace(request, labels)
+    namespace = _namespace(labels)
     if namespace is None:
         return JSONResponse(
             {"detail": "namespace_prefix must be an array of strings"}, status_code=422
@@ -222,7 +225,7 @@ async def store_list_namespaces(request: Request) -> JSONResponse | Response:
         limit=authorized.get("limit", 100),
         offset=authorized.get("offset", 0),
     )
-    return JSONResponse({"namespaces": [_public_namespace(request, item) for item in namespaces]})
+    return JSONResponse({"namespaces": [_public_namespace(item) for item in namespaces]})
 
 
 __all__ = ["store_delete", "store_get", "store_list_namespaces", "store_put", "store_search"]

{graphharbor-0.13.0.post33 → graphharbor-0.13.0.post35}/src/langhost/streaming.py

@@ -158,7 +158,9 @@ async def _resumable_run_ids(run_ids: set[UUID]) -> set[UUID]:
         )
 
 
-async def _thread_frame(row: RuntimeEventRow, modes: set[str]) -> tuple[str, Any, str] | None:
+async def _thread_frame(
+    row: RuntimeEventRow, modes: set[str], *, attempts: dict[UUID, int] | None = None
+) -> tuple[str, Any, str] | None:
     event = row.payload
     name = str(event.get("event") or event.get("method") or "custom")
     if name == "lifecycle":
@@ -168,10 +170,13 @@ async def _thread_frame(row: RuntimeEventRow, modes: set[str]) -> tuple[str, Any
                 return None
             attempt = 1
             if row.run_id is not None:
-                async with connect() as conn:
-                    run = await conn.session.get(RunRow, row.run_id)
-                if run is not None:
-                    attempt = max(run.retry_count, 1)
+                if attempts is not None and row.run_id in attempts:
+                    attempt = attempts[row.run_id]
+                else:
+                    async with connect() as conn:
+                        run = await conn.session.get(RunRow, row.run_id)
+                    if run is not None:
+                        attempt = max(run.retry_count, 1)
             return "metadata", {"run_id": str(row.run_id), "attempt": attempt}, f"{row.sequence}-0"
         if status in _TERMINAL:
             if "lifecycle" not in modes and "run_modes" not in modes:
@@ -221,12 +226,26 @@ async def thread_stream(request: Request) -> JSONResponse | StreamingResponse:
     async def body() -> AsyncIterator[str]:
         nonlocal cursor_value
         queue = await manager.add_thread_stream(thread_id)
+        loop = asyncio.get_running_loop()
+        last_sent_at = loop.time()
+        last_auth_at = loop.time()
+
+        async def _check_authorized() -> bool:
+            nonlocal last_auth_at
+            now_ = loop.time()
+            if now_ - last_auth_at < 10.0:
+                return True
+            if (await _get_thread(request))[0] is None:
+                return False
+            last_auth_at = now_
+            return True
+
         try:
             if cursor_value < 0:
                 cursor_value = await _thread_event_sequence(thread_id)
             initial_replay = True
             while True:
-                if (await _get_thread(request))[0] is None:
+                if not await _check_authorized():
                     return
                 watermark, rows = await _thread_events(thread_id, cursor_value)
                 if (
@@ -240,23 +259,50 @@ async def thread_stream(request: Request) -> JSONResponse | StreamingResponse:
                     if initial_replay
                     else set()
                 )
+                running_run_ids = {
+                    row.run_id
+                    for row in rows
+                    if row.run_id is not None
+                    and (row.payload.get("event") or row.payload.get("method")) == "lifecycle"
+                    and row.payload.get("status") == RunStatus.RUNNING.value
+                }
+                attempts: dict[UUID, int] = {}
+                if running_run_ids:
+                    async with connect() as conn:
+                        run_rows = (
+                            await conn.session.scalars(
+                                select(RunRow).where(RunRow.run_id.in_(running_run_ids))
+                            )
+                        ).all()
+                        attempts = {r.run_id: max(r.retry_count, 1) for r in run_rows}
+                emitted = False
                 for row in rows:
-                    if (await _get_thread(request))[0] is None:
-                        return
                     cursor_value = row.sequence
                     if initial_replay and row.run_id is not None and row.run_id not in resumable:
                         continue
-                    frame = await _thread_frame(row, modes)
+                    frame = await _thread_frame(row, modes, attempts=attempts)
                     if frame is not None:
                         name, data, event_id = frame
                         yield _sse(name, data, event_id=event_id, event_id_last=True)
+                        last_sent_at = loop.time()
+                        emitted = True
                 initial_replay = False
+
+                if not emitted and (loop.time() - last_sent_at >= heartbeat):
+                    yield ": heartbeat\n\n"
+                    last_sent_at = loop.time()
+
+                now = loop.time()
+                remaining = max(0.1, heartbeat - (now - last_sent_at))
                 try:
-                    await asyncio.wait_for(queue.get(), timeout=heartbeat)
+                    await asyncio.wait_for(queue.get(), timeout=remaining)
                 except TimeoutError:
                     if await request.is_disconnected():
                         return
+                    if not await _check_authorized():
+                        return
                     yield ": heartbeat\n\n"
+                    last_sent_at = loop.time()
         finally:
             await manager.remove_thread_stream(thread_id, queue)
 
@@ -264,7 +310,7 @@ async def thread_stream(request: Request) -> JSONResponse | StreamingResponse:
         body(),
         media_type="text/event-stream",
         headers={
-            "Cache-Control": "no-store",
+            "Cache-Control": "no-cache, no-transform",
             "Connection": "keep-alive",
             "X-Accel-Buffering": "no",
         },
@@ -458,39 +504,63 @@ async def _run_sse(
                 metric_inc("graphharbor_sse_events_total", labels={"version": version})
                 yield _sse(name, data, event_id=sequence if resumable else None)
 
-            for envelope in replay:
+            loop = asyncio.get_running_loop()
+            last_sent_at = loop.time()
+            last_auth_at = loop.time()
+
+            async def _check_authorized() -> bool:
+                nonlocal last_auth_at
+                now_ = loop.time()
+                if now_ - last_auth_at < 10.0:
+                    return True
                 if await _run_snapshot(request, run_id) is None:
-                    return
+                    return False
+                last_auth_at = now_
+                return True
+
+            for envelope in replay:
                 async for frame in emit_envelope(envelope):
                     yield frame
+                    last_sent_at = loop.time()
             snapshot = await _run_snapshot(request, run_id)
             if snapshot is None or snapshot.status in _TERMINAL:
                 return
 
-            started = asyncio.get_running_loop().time()
-            while asyncio.get_running_loop().time() - started < timeout:
+            started = loop.time()
+            while loop.time() - started < timeout:
+                now = loop.time()
+                remaining = max(0.1, heartbeat - (now - last_sent_at))
                 try:
-                    message = await asyncio.wait_for(queue.get(), timeout=heartbeat)
+                    message = await asyncio.wait_for(queue.get(), timeout=remaining)
                 except TimeoutError:
-                    snapshot = await _run_snapshot(request, run_id)
-                    if snapshot is None:
+                    if not await _check_authorized():
                         return
                     yield ": heartbeat\n\n"
-                    if snapshot.status in _TERMINAL:
+                    last_sent_at = loop.time()
+                    snapshot = await _run_snapshot(request, run_id)
+                    if snapshot is not None and snapshot.status in _TERMINAL:
                         for envelope in await _load_events(run_id, after=max(seen or {cursor})):
-                            if await _run_snapshot(request, run_id) is None:
-                                return
                             async for frame in emit_envelope(envelope):
                                 yield frame
+                                last_sent_at = loop.time()
                         return
                     continue
                 live_envelope = _message_envelope(message)
                 if live_envelope is None:
+                    if loop.time() - last_sent_at >= heartbeat:
+                        yield ": heartbeat\n\n"
+                        last_sent_at = loop.time()
                     continue
-                if await _run_snapshot(request, run_id) is None:
+                if not await _check_authorized():
                     return
+                emitted = False
                 async for frame in emit_envelope(live_envelope):
                     yield frame
+                    last_sent_at = loop.time()
+                    emitted = True
+                if not emitted and (loop.time() - last_sent_at >= heartbeat):
+                    yield ": heartbeat\n\n"
+                    last_sent_at = loop.time()
                 event = live_envelope.get("event")
                 if isinstance(event, dict) and event.get("event") == "lifecycle":
                     status = str(event.get("status", ""))
@@ -502,7 +572,7 @@ async def _run_sse(
             await manager.remove_queue(run_id, thread_id, queue)
 
     headers = {
-        "Cache-Control": "no-cache",
+        "Cache-Control": "no-cache, no-transform",
         "Connection": "keep-alive",
         "X-Accel-Buffering": "no",
     }

{graphharbor-0.13.0.post33 → graphharbor-0.13.0.post35}/tests/test_application_authorization.py

@@ -582,3 +582,35 @@ def test_filters_compile_as_bound_json_before_pagination():
     assert "jsonb_typeof" in sql and "@>" in sql and "::JSONB" in sql
     assert "alice" not in sql
     assert sql.index("WHERE") < sql.index("LIMIT")
+
+
+@pytest.mark.asyncio
+async def test_synchronous_auth_handler_is_supported():
+    auth = Auth()
+    auth._handlers[("threads", "read")] = [lambda ctx, value: {"owner": ctx.user.identity}]
+
+    user = {"identity": "alice", "permissions": []}
+    result = await authorize(auth, user, "threads", "read", {"thread_id": "test"})
+    assert result == {"owner": "alice"}
+
+
+@pytest.mark.asyncio
+async def test_store_get_requires_namespace():
+    import json
+
+    from starlette.requests import Request
+
+    from langhost.store_api import store_get
+
+    scope = {
+        "type": "http",
+        "method": "GET",
+        "path": "/store/items",
+        "query_string": b"key=test",
+        "headers": [],
+    }
+    request = Request(scope)
+    res = await store_get(request)
+    assert res.status_code == 422
+    assert json.loads(res.body.decode()) == {"detail": "namespace is required"}
+

graphharbor-0.13.0.post35/tests/test_stream_heartbeat_resilience.py

@@ -0,0 +1,344 @@
+"""Tests for deterministic stream heartbeats and resilience under filtered traffic."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+from uuid import UUID, uuid4
+
+import pytest
+from starlette.requests import Request
+from starlette.responses import StreamingResponse
+
+from langgraph_runtime_pg.models import ThreadRow
+from langgraph_runtime_pg.protocol import protocol_event
+from langgraph_runtime_pg.redis_stream import Message
+from langhost.protocol_api import protocol_event_stream
+from langhost.streaming import thread_stream
+
+
+class InMemoryStreamManager:
+    def __init__(self) -> None:
+        self.queues: dict[UUID, list[asyncio.Queue]] = {}
+        self.removed_count = 0
+
+    async def add_thread_stream(self, thread_id: UUID) -> asyncio.Queue:
+        q: asyncio.Queue = asyncio.Queue()
+        self.queues.setdefault(thread_id, []).append(q)
+        return q
+
+    async def remove_thread_stream(self, thread_id: UUID, queue: asyncio.Queue) -> None:
+        if thread_id in self.queues:
+            self.queues[thread_id] = [q for q in self.queues[thread_id] if q is not queue]
+            self.removed_count += 1
+
+    async def publish_thread_event(self, thread_id: UUID, message: Message) -> None:
+        for q in self.queues.get(thread_id, []):
+            await q.put(message)
+
+
+def _make_scope_and_receive(
+    method: str,
+    path: str,
+    path_params: dict[str, str],
+    body_dict: dict | None = None,
+    headers: dict[str, str] | None = None,
+) -> tuple[dict, callable]:
+    raw_headers = []
+    if headers:
+        for k, v in headers.items():
+            raw_headers.append((k.lower().encode("latin1"), v.encode("latin1")))
+    scope = {
+        "type": "http",
+        "method": method,
+        "path": path,
+        "headers": raw_headers,
+        "path_params": path_params,
+        "query_string": b"",
+    }
+    body_bytes = json.dumps(body_dict).encode("utf-8") if body_dict is not None else b""
+
+    async def receive():
+        return {"type": "http.request", "body": body_bytes, "more_body": False}
+
+    return scope, receive
+
+
+@pytest.mark.asyncio
+async def test_protocol_event_stream_heartbeat_under_filtered_traffic(monkeypatch):
+    """Ensure protocol stream emits heartbeats even when inundated with filtered events."""
+    monkeypatch.setenv("GRAPHHARBOR_PROTOCOL_HEARTBEAT_SECONDS", "0.15")
+    monkeypatch.setenv("GRAPHHARBOR_PROTOCOL_TIMEOUT_SECONDS", "2.0")
+
+    thread_id = uuid4()
+    mock_thread = ThreadRow(
+        thread_id=thread_id,
+        status="idle",
+        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.protocol_api._load_protocol_events",
+        lambda *a, **k: asyncio.sleep(0, result=(0, [])),
+    )
+
+    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)
+
+    async def pump_filtered_events():
+        for seq in range(1, 20):
+            await asyncio.sleep(0.03)
+            wire = protocol_event(
+                event_id=f"evt-{seq}",
+                sequence=seq,
+                run_id=str(uuid4()),
+                thread_id=str(thread_id),
+                event={"event": "filtered_internal", "data": "ignore_me"},
+            )
+            wire["method"] = "debug:internal"
+            await manager.publish_thread_event(
+                thread_id,
+                Message(
+                    topic=b"thread",
+                    id=f"{seq}-0".encode("ascii"),
+                    data=json.dumps(wire).encode("utf-8"),
+                ),
+            )
+
+    pump_task = asyncio.create_task(pump_filtered_events())
+    heartbeats_received = 0
+    try:
+        async for chunk in res.body_iterator:
+            if chunk.startswith(": heartbeat"):
+                heartbeats_received += 1
+                if heartbeats_received >= 2:
+                    break
+    finally:
+        pump_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await pump_task
+        await res.body_iterator.aclose()
+
+    assert heartbeats_received >= 2, f"Expected >= 2 heartbeats, got {heartbeats_received}"
+    assert manager.removed_count >= 1, "Queue must be cleaned up in finally block"
+
+
+@pytest.mark.asyncio
+async def test_thread_stream_heartbeat_under_empty_queue(monkeypatch):
+    """Ensure thread_stream emits heartbeat when idle."""
+    monkeypatch.setenv("GRAPHHARBOR_THREAD_STREAM_HEARTBEAT_SECONDS", "0.15")
+
+    thread_id = uuid4()
+    mock_thread = ThreadRow(
+        thread_id=thread_id,
+        status="idle",
+        metadata_={},
+        config={},
+        values_={},
+        interrupts={},
+        error=None,
+    )
+
+    manager = InMemoryStreamManager()
+
+    monkeypatch.setattr("langhost.streaming.get_stream_manager", lambda: manager)
+    monkeypatch.setattr(
+        "langhost.core_api._get_thread",
+        lambda *a, **k: asyncio.sleep(0, result=(mock_thread, None, thread_id)),
+    )
+    monkeypatch.setattr(
+        "langhost.streaming._thread_event_sequence",
+        lambda *a, **k: asyncio.sleep(0, result=0),
+    )
+    monkeypatch.setattr(
+        "langhost.streaming._thread_events",
+        lambda *a, **k: asyncio.sleep(0, result=(0, [])),
+    )
+
+    scope, receive = _make_scope_and_receive(
+        "GET",
+        f"/threads/{thread_id}/stream",
+        {"thread_id": str(thread_id)},
+    )
+    req = Request(scope, receive)
+    res = await thread_stream(req)
+    assert isinstance(res, StreamingResponse)
+
+    heartbeats_received = 0
+    try:
+        async for chunk in res.body_iterator:
+            if chunk.startswith(": heartbeat"):
+                heartbeats_received += 1
+                if heartbeats_received >= 2:
+                    break
+    finally:
+        await res.body_iterator.aclose()
+
+    assert heartbeats_received >= 2
+    assert manager.removed_count >= 1
+
+
+@pytest.mark.asyncio
+async def test_stream_response_headers_compliance(monkeypatch):
+    """Verify that SSE stream endpoints provide standardized headers."""
+    thread_id = uuid4()
+    mock_thread = ThreadRow(
+        thread_id=thread_id,
+        status="idle",
+        metadata_={},
+        config={},
+        values_={},
+        interrupts={},
+        error=None,
+    )
+
+    manager = InMemoryStreamManager()
+    monkeypatch.setattr("langhost.protocol_api.get_stream_manager", lambda: manager)
+    monkeypatch.setattr("langhost.streaming.get_stream_manager", lambda: manager)
+    monkeypatch.setattr(
+        "langhost.protocol_api._thread",
+        lambda *a, **k: asyncio.sleep(0, result=mock_thread),
+    )
+    monkeypatch.setattr(
+        "langhost.protocol_api._load_protocol_events",
+        lambda *a, **k: asyncio.sleep(0, result=(0, [])),
+    )
+    monkeypatch.setattr(
+        "langhost.core_api._get_thread",
+        lambda *a, **k: asyncio.sleep(0, result=(mock_thread, None, thread_id)),
+    )
+    monkeypatch.setattr(
+        "langhost.streaming._thread_event_sequence",
+        lambda *a, **k: asyncio.sleep(0, result=0),
+    )
+    monkeypatch.setattr(
+        "langhost.streaming._thread_events",
+        lambda *a, **k: asyncio.sleep(0, result=(0, [])),
+    )
+
+    # 1. Test protocol stream
+    scope, receive = _make_scope_and_receive(
+        "POST",
+        f"/threads/{thread_id}/stream/events",
+        {"thread_id": str(thread_id)},
+        body_dict={"channels": ["input"], "since": 0},
+    )
+    res_proto = await protocol_event_stream(Request(scope, receive))
+    assert res_proto.status_code == 200
+    assert res_proto.headers["connection"] == "keep-alive"
+    assert "no-cache" in res_proto.headers["cache-control"]
+    assert res_proto.headers["x-accel-buffering"] == "no"
+    await res_proto.body_iterator.aclose()
+
+    # 2. Test thread stream
+    scope_t, receive_t = _make_scope_and_receive(
+        "GET",
+        f"/threads/{thread_id}/stream",
+        {"thread_id": str(thread_id)},
+    )
+    res_thread = await thread_stream(Request(scope_t, receive_t))
+    assert res_thread.status_code == 200
+    assert res_thread.headers["connection"] == "keep-alive"
+    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!"
+