langgraph-api 0.4.20__py3-none-any.whl → 0.4.21__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.20"
+__version__ = "0.4.21"

langgraph_api/api/a2a.py

@@ -7,7 +7,7 @@ A2A Protocol specification:
 https://a2a-protocol.org/dev/specification/
 
 The implementation currently supports JSON-RPC 2.0 transport only.
-Streaming (SSE) and push notifications are not implemented.
+Push notifications are not implemented.
 """
 
 import functools
@@ -16,18 +16,19 @@ from datetime import UTC, datetime
 from typing import Any, Literal, NotRequired, cast
 
 import orjson
+import structlog
 from langgraph_sdk.client import LangGraphClient, get_client
 from starlette.datastructures import Headers
 from starlette.responses import JSONResponse, Response
-from structlog import getLogger
 from typing_extensions import TypedDict
 
 from langgraph_api import __version__
 from langgraph_api.metadata import USER_API_URL
 from langgraph_api.route import ApiRequest, ApiRoute
+from langgraph_api.sse import EventSourceResponse
 from langgraph_api.utils.cache import LRUCache
 
-logger = getLogger(__name__)
+logger = structlog.stdlib.get_logger(__name__)
 
 # Cache for assistant schemas (assistant_id -> schemas dict)
 _assistant_schemas_cache = LRUCache[dict[str, Any]](max_size=1000, ttl=60)
@@ -286,6 +287,101 @@ def _extract_a2a_response(result: dict[str, Any]) -> str:
     return str(last_message)
 
 
+def _lc_stream_items_to_a2a_message(
+    items: list[dict[str, Any]],
+    *,
+    task_id: str,
+    context_id: str,
+    role: Literal["agent", "user"] = "agent",
+) -> dict[str, Any]:
+    """Convert LangChain stream "messages/*" items into a valid A2A Message.
+
+    This takes the list found in a messages/* StreamPart's data field and
+    constructs a single A2A Message object, concatenating textual content and
+    preserving select structured metadata into a DataPart.
+
+    Args:
+        items: List of LangChain message dicts from stream (e.g., with keys like
+            "content", "type", "response_metadata", "tool_calls", etc.)
+        task_id: The A2A task ID this message belongs to
+        context_id: The A2A context ID (thread) for grouping
+        role: A2A role; defaults to "agent" for streamed assistant output
+
+    Returns:
+        A2A Message dict with required fields and minimally valid parts.
+    """
+    # Aggregate any text content across items
+    text_parts: list[str] = []
+    # Collect a small amount of structured data for debugging/traceability
+    extra_data: dict[str, Any] = {}
+
+    def _sse_safe_text(s: str) -> str:
+        return s.replace("\u2028", "\\u2028").replace("\u2029", "\\u2029")
+
+    for it in items:
+        if not isinstance(it, dict):
+            continue
+        content = it.get("content")
+        if isinstance(content, str) and content:
+            text_parts.append(_sse_safe_text(content))
+
+        # Preserve a couple of useful fields if present
+        # Keep this small to avoid bloating the message payload
+        rm = it.get("response_metadata")
+        if isinstance(rm, dict) and rm:
+            extra_data.setdefault("response_metadata", rm)
+        tc = it.get("tool_calls")
+        if isinstance(tc, list) and tc:
+            extra_data.setdefault("tool_calls", tc)
+
+    parts: list[dict[str, Any]] = []
+    if text_parts:
+        parts.append({"kind": "text", "text": "".join(text_parts)})
+    if extra_data:
+        parts.append({"kind": "data", "data": extra_data})
+
+    # Ensure we always produce a minimally valid A2A Message
+    if not parts:
+        parts = [{"kind": "text", "text": ""}]
+
+    return {
+        "role": role,
+        "parts": parts,
+        "messageId": str(uuid.uuid4()),
+        "taskId": task_id,
+        "contextId": context_id,
+        "kind": "message",
+    }
+
+
+def _lc_items_to_status_update_event(
+    items: list[dict[str, Any]],
+    *,
+    task_id: str,
+    context_id: str,
+    state: str = "working",
+) -> dict[str, Any]:
+    """Build a TaskStatusUpdateEvent embedding a converted A2A Message.
+
+    This avoids emitting standalone Message results (which some clients reject)
+    and keeps message content within the status update per spec.
+    """
+    message = _lc_stream_items_to_a2a_message(
+        items, task_id=task_id, context_id=context_id, role="agent"
+    )
+    return {
+        "taskId": task_id,
+        "contextId": context_id,
+        "kind": "status-update",
+        "status": {
+            "state": state,
+            "message": message,
+            "timestamp": datetime.now(UTC).isoformat(),
+        },
+        "final": False,
+    }
+
+
 def _map_runs_create_error_to_rpc(
     exception: Exception, assistant_id: str, thread_id: str | None = None
 ) -> dict[str, Any]:
@@ -519,9 +615,6 @@ async def handle_post_request(request: ApiRequest, assistant_id: str) -> Respons
     except orjson.JSONDecodeError:
         return create_error_response("Invalid JSON payload", 400)
 
-    if not is_valid_accept_header(request):
-        return create_error_response("Accept header must include application/json", 400)
-
     if not isinstance(message, dict):
         return create_error_response("Invalid message format", 400)
 
@@ -534,6 +627,18 @@ async def handle_post_request(request: ApiRequest, assistant_id: str) -> Respons
     id_ = message.get("id")
     method = message.get("method")
 
+    accept_header = request.headers.get("Accept") or ""
+    if method == "message/stream":
+        if "text/event-stream" not in accept_header:
+            return create_error_response(
+                "Accept header must include text/event-stream for streaming", 400
+            )
+    else:
+        if "application/json" not in accept_header:
+            return create_error_response(
+                "Accept header must include application/json", 400
+            )
+
     if id_ is not None and method:
         # JSON-RPC request
         return await handle_jsonrpc_request(
@@ -553,19 +658,6 @@ async def handle_post_request(request: ApiRequest, assistant_id: str) -> Respons
         )
 
 
-def is_valid_accept_header(request: ApiRequest) -> bool:
-    """Check if Accept header contains supported content types.
-
-    Args:
-        request: The incoming request
-
-    Returns:
-        True if header contains application/json
-    """
-    accept_header = request.headers.get("Accept", "")
-    return "application/json" in accept_header
-
-
 def create_error_response(message: str, status_code: int) -> Response:
     """Create a JSON error response.
 
@@ -603,9 +695,10 @@ async def handle_jsonrpc_request(
     """
     method = message["method"]
     params = message.get("params", {})
-
     # Route to appropriate A2A method handler
-    if method == "message/send":
+    if method == "message/stream":
+        return await handle_message_stream(request, params, assistant_id, message["id"])
+    elif method == "message/send":
         result_or_error = await handle_message_send(request, params, assistant_id)
     elif method == "tasks/get":
         result_or_error = await handle_tasks_get(request, params)
@@ -949,7 +1042,9 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
     required = input_schema.get("required", [])
 
     assistant_name = assistant["name"]
-    assistant_description = assistant.get("description", f"{assistant_name} assistant")
+    assistant_description = (
+        assistant.get("description") or f"{assistant_name} assistant"
+    )
 
     # For now, each assistant has one main skill - itself
     skills = [
@@ -978,10 +1073,11 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
         scheme = request.url.scheme
         host = request.url.hostname or "localhost"
         port = request.url.port
+        path = request.url.path.removesuffix("/.well-known/agent-card.json")
         if port and (
             (scheme == "http" and port != 80) or (scheme == "https" and port != 443)
         ):
-            base_url = f"{scheme}://{host}:{port}"
+            base_url = f"{scheme}://{host}:{port}{path}"
         else:
             base_url = f"{scheme}://{host}"
 
@@ -992,7 +1088,7 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
         "url": f"{base_url}/a2a/{assistant_id}",
         "preferredTransport": "JSONRPC",
         "capabilities": {
-            "streaming": False,  # Not implemented yet
+            "streaming": True,
             "pushNotifications": False,  # Not implemented yet
             "stateTransitionHistory": False,
         },
@@ -1062,6 +1158,281 @@ async def handle_agent_card_endpoint(request: ApiRequest) -> Response:
         )
 
 
+# ============================================================================
+# Message Streaming
+# ============================================================================
+
+
+async def handle_message_stream(
+    request: ApiRequest,
+    params: dict[str, Any],
+    assistant_id: str,
+    rpc_id: str | int,
+) -> Response:
+    """Handle message/stream requests and stream JSON-RPC responses via SSE.
+
+    Each SSE "data" is a JSON-RPC 2.0 response object. We emit:
+    - An initial TaskStatusUpdateEvent with state "submitted".
+    - Optionally a TaskStatusUpdateEvent with state "working" on first update.
+    - A final Task result when the run completes.
+    - A JSON-RPC error if anything fails.
+    """
+    client = _client()
+
+    async def stream_body():
+        try:
+            message = params.get("message")
+            if not message:
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_INVALID_PARAMS,
+                            "message": "Missing 'message' in params",
+                        },
+                    },
+                )
+                return
+
+            parts = message.get("parts", [])
+            if not parts:
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_INVALID_PARAMS,
+                            "message": "Message must contain at least one part",
+                        },
+                    },
+                )
+                return
+
+            try:
+                assistant = await _get_assistant(client, assistant_id, request.headers)
+                await _validate_supports_messages(
+                    client, assistant, request.headers, parts
+                )
+            except ValueError as e:
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_INVALID_PARAMS,
+                            "message": str(e),
+                        },
+                    },
+                )
+                return
+
+            # Process A2A message parts into LangChain messages format
+            try:
+                message_role = message.get("role", "user")
+                input_content = _process_a2a_message_parts(parts, message_role)
+            except ValueError as e:
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_CONTENT_TYPE_NOT_SUPPORTED,
+                            "message": str(e),
+                        },
+                    },
+                )
+                return
+
+            run = await client.runs.create(
+                thread_id=message.get("contextId"),
+                assistant_id=assistant_id,
+                stream_mode=["messages", "values"],
+                if_not_exists="create",
+                input=input_content,
+                headers=request.headers,
+            )
+            context_id = run["thread_id"]
+            # Emit initial Task object to establish task context
+            initial_task = {
+                "id": run["run_id"],
+                "contextId": context_id,
+                "history": [
+                    {
+                        **message,
+                        "taskId": run["run_id"],
+                        "contextId": context_id,
+                        "kind": "message",
+                    }
+                ],
+                "kind": "task",
+                "status": {
+                    "state": "submitted",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                },
+            }
+            yield (b"message", {"jsonrpc": "2.0", "id": rpc_id, "result": initial_task})
+            task_id = run["run_id"]
+            stream = client.runs.join_stream(
+                run_id=task_id,
+                thread_id=context_id,
+                headers=request.headers,
+            )
+            result = None
+            err = None
+            notified_is_working = False
+            async for chunk in stream:
+                try:
+                    if chunk.event == "metadata":
+                        data = chunk.data or {}
+                        if data.get("status") == "run_done":
+                            final_message = None
+                            if isinstance(result, dict):
+                                try:
+                                    final_text = _extract_a2a_response(result)
+                                    final_message = {
+                                        "role": "agent",
+                                        "parts": [{"kind": "text", "text": final_text}],
+                                        "messageId": str(uuid.uuid4()),
+                                        "taskId": task_id,
+                                        "contextId": context_id,
+                                        "kind": "message",
+                                    }
+                                except Exception:
+                                    await logger.aexception(
+                                        "Failed to extract final message from result",
+                                        result=result,
+                                    )
+                            if final_message is None:
+                                final_message = {
+                                    "role": "agent",
+                                    "parts": [{"kind": "text", "text": str(result)}],
+                                    "messageId": str(uuid.uuid4()),
+                                    "taskId": task_id,
+                                    "contextId": context_id,
+                                    "kind": "message",
+                                }
+                            completed = {
+                                "taskId": task_id,
+                                "contextId": context_id,
+                                "kind": "status-update",
+                                "status": {
+                                    "state": "completed",
+                                    "message": final_message,
+                                    "timestamp": datetime.now(UTC).isoformat(),
+                                },
+                                "final": True,
+                            }
+                            yield (
+                                b"message",
+                                {"jsonrpc": "2.0", "id": rpc_id, "result": completed},
+                            )
+                            return
+                        if data.get("run_id") and not notified_is_working:
+                            notified_is_working = True
+                            yield (
+                                b"message",
+                                {
+                                    "jsonrpc": "2.0",
+                                    "id": rpc_id,
+                                    "result": {
+                                        "taskId": task_id,
+                                        "contextId": context_id,
+                                        "kind": "status-update",
+                                        "status": {"state": "working"},
+                                        "final": False,
+                                    },
+                                },
+                            )
+                    elif chunk.event == "error":
+                        err = chunk.data
+                    elif chunk.event == "values":
+                        err = None  # Error was retriable
+                        result = chunk.data
+                    elif chunk.event.startswith("messages"):
+                        err = None  # Error was retriable
+                        items = chunk.data or []
+                        if isinstance(items, list) and items:
+                            update = _lc_items_to_status_update_event(
+                                items,
+                                task_id=task_id,
+                                context_id=context_id,
+                                state="working",
+                            )
+                            yield (
+                                b"message",
+                                {"jsonrpc": "2.0", "id": rpc_id, "result": update},
+                            )
+                    else:
+                        await logger.awarning(
+                            "Ignoring unknown event type: " + chunk.event
+                        )
+
+                except Exception as e:
+                    await logger.aexception("Failed to process message stream")
+                    err = {"error": type(e).__name__, "message": str(e)}
+                    continue
+
+            # If we exit unexpectedly, send a final status based on error presence
+            final_message = None
+            if isinstance(err, dict) and ("__error__" in err or "error" in err):
+                msg = (
+                    err.get("__error__", {}).get("error")
+                    if isinstance(err.get("__error__"), dict)
+                    else err.get("message")
+                )
+                await logger.aerror("Failed to process message stream", err=err)
+                final_message = {
+                    "role": "agent",
+                    "parts": [{"kind": "text", "text": str(msg or "")}],
+                    "messageId": str(uuid.uuid4()),
+                    "taskId": task_id,
+                    "contextId": context_id,
+                    "kind": "message",
+                }
+            fallback = {
+                "taskId": task_id,
+                "contextId": context_id,
+                "kind": "status-update",
+                "status": {
+                    "state": "failed" if err else "completed",
+                    **({"message": final_message} if final_message else {}),
+                    "timestamp": datetime.now(UTC).isoformat(),
+                },
+                "final": True,
+            }
+            yield (b"message", {"jsonrpc": "2.0", "id": rpc_id, "result": fallback})
+        except Exception as e:
+            await logger.aerror(
+                f"Error in message/stream for assistant {assistant_id}: {str(e)}",
+                exc_info=True,
+            )
+            yield (
+                b"message",
+                {
+                    "jsonrpc": "2.0",
+                    "id": rpc_id,
+                    "error": {
+                        "code": ERROR_CODE_INTERNAL_ERROR,
+                        "message": f"Internal server error: {str(e)}",
+                    },
+                },
+            )
+
+    async def consume_():
+        async for chunk in stream_body():
+            await logger.adebug("A2A.stream_body: Yielding chunk", chunk=chunk)
+            yield chunk
+
+    return EventSourceResponse(
+        consume_(), headers={"Content-Type": "text/event-stream"}
+    )
+
+
 # ============================================================================
 # Route Definitions
 # ============================================================================

langgraph_api/api/assistants.py

@@ -17,7 +17,7 @@ from langgraph_api.graph import get_assistant_id, get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.schema import ASSISTANT_FIELDS
-from langgraph_api.serde import ajson_loads
+from langgraph_api.serde import json_loads
 from langgraph_api.utils import (
     fetchone,
     get_pagination_headers,
@@ -240,7 +240,7 @@ async def get_assistant_graph(
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-    config = await ajson_loads(assistant["config"])
+    config = json_loads(assistant["config"])
     configurable = config.setdefault("configurable", {})
     configurable.update(get_configurable_headers(request.headers))
 
@@ -297,7 +297,7 @@ async def get_assistant_subgraphs(
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = await ajson_loads(assistant["config"])
+        config = json_loads(assistant["config"])
         configurable = config.setdefault("configurable", {})
         configurable.update(get_configurable_headers(request.headers))
         async with get_graph(
@@ -345,7 +345,7 @@ async def get_assistant_schemas(
         assistant_ = await Assistants.get(conn, assistant_id)
         # TODO Implementa  cache so we can de-dent and release this connection.
         assistant = await fetchone(assistant_)
-        config = await ajson_loads(assistant["config"])
+        config = json_loads(assistant["config"])
         configurable = config.setdefault("configurable", {})
         configurable.update(get_configurable_headers(request.headers))
         async with get_graph(

langgraph_api/cli.py

@@ -11,12 +11,17 @@ from typing import Literal
 from typing_extensions import TypedDict
 
 if typing.TYPE_CHECKING:
+    from packaging.version import Version
+
     from langgraph_api.config import HttpConfig, StoreConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+SUPPORT_STATUS = Literal["active", "critical", "eol"]
+
+
 def _get_ls_origin() -> str | None:
     from langsmith.client import Client
     from langsmith.utils import tracing_is_enabled
@@ -121,46 +126,6 @@ class AuthConfig(TypedDict, total=False):
     cache: CacheConfig | None
 
 
-def _check_newer_version(pkg: str, timeout: float = 0.2) -> None:
-    """Log a notice if PyPI reports a newer version."""
-    import importlib.metadata as md
-    import json
-    import urllib.request
-
-    from packaging.version import Version
-
-    thread_logger = logging.getLogger("check_version")
-    if not thread_logger.handlers:
-        handler = logging.StreamHandler()
-        handler.setFormatter(logging.Formatter("%(message)s"))
-        thread_logger.addHandler(handler)
-
-    try:
-        current = Version(md.version(pkg))
-        with urllib.request.urlopen(
-            f"https://pypi.org/pypi/{pkg}/json", timeout=timeout
-        ) as resp:
-            latest_str = json.load(resp)["info"]["version"]
-        latest = Version(latest_str)
-        if latest > current:
-            thread_logger.info(
-                "🔔  A newer version of %s is available: %s → %s (pip install -U %s)",
-                pkg,
-                current,
-                latest,
-                pkg,
-            )
-
-    except Exception:
-        pass
-
-    except RuntimeError:
-        thread_logger.info(
-            f"Failed to check for newer version of {pkg}."
-            " To disable version checks, set LANGGRAPH_NO_VERSION_CHECK=true"
-        )
-
-
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -362,8 +327,12 @@ For production use, please use LangGraph Platform.
             threading.Thread(target=_open_browser, daemon=True).start()
         nvc = os.getenv("LANGGRAPH_NO_VERSION_CHECK")
         if nvc is None or nvc.lower() not in ("true", "1"):
+            from langgraph_api import __version__
+
             threading.Thread(
-                target=_check_newer_version, args=("langgraph-api",), daemon=True
+                target=_check_newer_version,
+                args=("langgraph-api", __version__),
+                daemon=True,
             ).start()
         supported_kwargs = {
             k: v
@@ -471,5 +440,133 @@ def main():
     )
 
 
+def _check_newer_version(pkg: str, current_version: str, timeout: float = 0.5) -> None:
+    """Check PyPI for newer versions and log support status.
+
+    Critical = one minor behind on same major, OR latest minor of previous major while latest is X.0.*
+    EOL = two+ minors behind on same major, OR any previous major after X.1.*
+    """
+    import json
+    import urllib.request
+
+    from packaging.version import InvalidVersion, Version
+
+    log = logging.getLogger("version_check")
+    if not log.handlers:
+        h = logging.StreamHandler()
+        h.setFormatter(logging.Formatter("%(message)s"))
+        log.addHandler(h)
+
+    if os.getenv("LANGGRAPH_NO_VERSION_CHECK", "").lower() in ("true", "1"):
+        return
+
+    def _parse(v: str) -> Version | None:
+        try:
+            return Version(v)
+        except InvalidVersion:
+            return None
+
+    try:
+        current = Version(current_version)
+    except InvalidVersion:
+        log.info(
+            f"[version] Could not parse installed version {current_version!r}. Skipping support check."
+        )
+        return
+
+    try:
+        with urllib.request.urlopen(
+            f"https://pypi.org/pypi/{pkg}/json", timeout=timeout
+        ) as resp:
+            payload = json.load(resp)
+        latest_str = payload["info"]["version"]
+        latest = Version(latest_str)
+        releases: dict[str, list[dict]] = payload.get("releases", {})
+    except Exception:
+        log.debug("Failed to retrieve latest version info for %s", pkg)
+        return
+    prev_major_latest_minor: Version | None = None
+    if latest.major > 0:
+        pm = latest.major - 1
+        prev_major_versions = [
+            v
+            for s in releases
+            if (v := _parse(s)) is not None and not v.is_prerelease and v.major == pm
+        ]
+        if prev_major_versions:
+            prev_major_latest_minor = max(
+                prev_major_versions, key=lambda v: (v.major, v.minor, v.micro)
+            )
+
+    if latest > current and not current.is_prerelease:
+        log.info(
+            "[version] A newer version of %s is available: %s → %s  (pip install -U %s)",
+            pkg,
+            current,
+            latest,
+            pkg,
+        )
+
+    level = _support_level(current, latest, prev_major_latest_minor)
+    changelog = (
+        "https://docs.langchain.com/langgraph-platform/langgraph-server-changelog"
+    )
+
+    if level == "critical":
+        # Distinguish same-major vs cross-major grace in the wording
+        if current.major == latest.major and current.minor == latest.minor - 1:
+            tail = "You are one minor version behind the latest (%d.%d.x).\n"
+        else:
+            tail = "You are on the latest minor of the previous major while a new major (%d.%d.x) just released.\n"
+        log.info(
+            "⚠️ [support] %s %s is in Critical support.\n"
+            "Only critical security and installation fixes are provided.\n"
+            + tail
+            + "Please plan an upgrade soon. See changelog: %s",
+            pkg,
+            current,
+            latest.major,
+            latest.minor,
+            changelog,
+        )
+    elif level == "eol":
+        log.info(
+            "⚠️ [support] %s %s is End of Life.\n"
+            "No bug fixes or security updates will be provided.\n"
+            "You are two or more minor versions behind the latest (%d.%d.x).\n"
+            "You should upgrade immediately. See changelog: %s",
+            pkg,
+            current,
+            latest.major,
+            latest.minor,
+            changelog,
+        )
+
+
+def _support_level(
+    cur: "Version", lat: "Version", prev_major_latest_minor: "Version | None"
+) -> SUPPORT_STATUS:
+    if cur.major > lat.major:
+        return "active"
+    if cur.major == lat.major:
+        if cur.minor == lat.minor:
+            return "active"
+        if cur.minor == lat.minor - 1:
+            return "critical"
+        if cur.minor <= lat.minor - 2:
+            return "eol"
+        return "active"
+
+    if cur.major == lat.major - 1 and lat.minor == 0:
+        if (
+            prev_major_latest_minor is not None
+            and cur.minor == prev_major_latest_minor.minor
+        ):
+            return "critical"
+        return "eol"
+
+    return "eol"
+
+
 if __name__ == "__main__":
     main()

langgraph_api/js/package.json

@@ -18,7 +18,7 @@
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
     "exit-hook": "^4.0.0",
-    "hono": "^4.5.4",
+    "hono": "^4.9.7",
     "p-queue": "^8.0.1",
     "p-retry": "^6.2.0",
     "tsx": "^4.19.3",

langgraph_api/js/yarn.lock

@@ -974,10 +974,10 @@ has-flag@^4.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
-hono@^4.5.4:
-  version "4.6.14"
-  resolved "https://registry.yarnpkg.com/hono/-/hono-4.6.14.tgz#f83f51e81b8ae5611dab459570990bf4c977d20c"
-  integrity sha512-j4VkyUp2xazGJ8eCCLN1Vm/bxdvm/j5ZuU9AIjLu9vapn2M44p9L3Ktr9Vnb2RN2QtcR/wVjZVMlT5k7GJQgPw==
+hono@^4.5.4, hono@^4.9.7:
+  version "4.9.7"
+  resolved "https://registry.yarnpkg.com/hono/-/hono-4.9.7.tgz#8ac244477397de71d7d3d393fad129209b5b631e"
+  integrity sha512-t4Te6ERzIaC48W3x4hJmBwgNlLhmiEdEE5ViYb02ffw4ignHNHa5IBtPjmbKstmtKa8X6C35iWwK4HaqvrzG9w==
 
 icss-utils@^5.0.0, icss-utils@^5.1.0:
   version "5.1.0"

langgraph_api/metadata.py

@@ -7,6 +7,8 @@ import langgraph.version
 import orjson
 import structlog
 
+import langgraph_api.config as config
+from langgraph_api.auth.custom import get_auth_instance
 from langgraph_api.config import (
     LANGGRAPH_CLOUD_LICENSE_KEY,
     LANGSMITH_API_KEY,
@@ -17,7 +19,9 @@ from langgraph_api.config import (
     USES_STORE_TTL,
     USES_THREAD_TTL,
 )
+from langgraph_api.graph import GRAPHS, is_js_graph
 from langgraph_api.http import http_request
+from langgraph_api.js.base import is_js_path
 from langgraph_license.validation import plus_features_enabled
 
 logger = structlog.stdlib.get_logger(__name__)
@@ -72,6 +76,36 @@ if LANGSMITH_AUTH_ENDPOINT:
         )
 
 
+def _lang_usage_metadata() -> tuple[dict[str, str], dict[str, int]]:
+    js_graph_count = sum(1 for graph_id in GRAPHS if is_js_graph(graph_id))
+    py_graph_count = len(GRAPHS) - js_graph_count
+
+    auth_instance = get_auth_instance()
+    custom_auth_enabled = auth_instance is not None
+    custom_js_auth_enabled = auth_instance == "js"
+
+    js_proxy_middleware_enabled = False
+    if (
+        config.HTTP_CONFIG
+        and (app := config.HTTP_CONFIG.get("app"))
+        and isinstance(app, str)
+    ):
+        app_path = app.split(":", 1)[0]  # type: ignore[possibly-unresolved-reference]
+        js_proxy_middleware_enabled = is_js_path(app_path)
+
+    tags = {
+        "langgraph.platform.uses_custom_auth": str(custom_auth_enabled),
+        "langgraph.platform.uses_js_custom_auth": str(custom_js_auth_enabled),
+        "langgraph.platform.uses_js_proxy_middleware": str(js_proxy_middleware_enabled),
+    }
+    measures = {
+        "langgraph.platform.py_graphs": py_graph_count,
+        "langgraph.platform.js_graphs": js_graph_count,
+    }
+
+    return tags, measures
+
+
 def incr_runs(*, incr: int = 1) -> None:
     global RUN_COUNTER
     RUN_COUNTER += incr
@@ -111,6 +145,7 @@ async def metadata_loop() -> None:
         RUN_COUNTER = 0
         NODE_COUNTER = 0
         FROM_TIMESTAMP = to_timestamp
+        usage_tags, usage_measures = _lang_usage_metadata()
 
         base_payload = {
             "from_timestamp": from_timestamp,
@@ -131,10 +166,12 @@ async def metadata_loop() -> None:
                 "user_app.uses_custom_auth": str(USES_CUSTOM_AUTH),
                 "user_app.uses_thread_ttl": str(USES_THREAD_TTL),
                 "user_app.uses_store_ttl": str(USES_STORE_TTL),
+                **usage_tags,
             },
             "measures": {
                 "langgraph.platform.runs": runs,
                 "langgraph.platform.nodes": nodes,
+                **usage_measures,
             },
             "logs": [],
         }

langgraph_api/serde.py

@@ -152,6 +152,7 @@ def json_loads(content: bytes | Fragment | dict) -> Any:
     return orjson.loads(cast(bytes, content))
 
 
+# Do not use. orjson holds the GIL the entire time it's running anyway.
 async def ajson_loads(content: bytes | Fragment) -> Any:
     return await asyncio.to_thread(json_loads, content)
 

langgraph_api/server.py

@@ -53,11 +53,13 @@ middleware = []
 if config.ALLOW_PRIVATE_NETWORK:
     middleware.append(Middleware(PrivateNetworkMiddleware))
 
-if (
+JS_PROXY_MIDDLEWARE_ENABLED = (
     config.HTTP_CONFIG
     and (app := config.HTTP_CONFIG.get("app"))
     and is_js_path(app.split(":")[0])
-):
+)
+
+if JS_PROXY_MIDDLEWARE_ENABLED:
     from langgraph_api.js.remote import JSCustomHTTPProxyMiddleware
 
     middleware.append(Middleware(JSCustomHTTPProxyMiddleware))

langgraph_api/stream.py

@@ -8,9 +8,11 @@ import langgraph.version
 import langsmith
 import structlog
 from langchain_core.messages import (
+    AIMessageChunk,
     # TODO: Remove explicit dependency
     BaseMessage,
     BaseMessageChunk,
+    ToolMessageChunk,
     convert_to_messages,
     message_chunk_to_message,
 )
@@ -286,11 +288,23 @@ async def astream_state(
                             msg_, meta = cast(
                                 tuple[BaseMessage | dict, dict[str, Any]], chunk
                             )
-                            msg = (
-                                convert_to_messages([msg_])[0]
-                                if isinstance(msg_, dict)
-                                else cast(BaseMessage, msg_)
-                            )
+                            is_chunk = False
+                            if isinstance(msg_, dict):
+                                if (
+                                    "chunk" in msg_.get("type", "").lower()
+                                    or "chunk" in msg_.get("role", "").lower()
+                                ):
+                                    if "ai" in msg_.get("role", "").lower():
+                                        msg = AIMessageChunk(**msg_)  # type: ignore[arg-type]
+                                    elif "tool" in msg_.get("role", "").lower():
+                                        msg = ToolMessageChunk(**msg_)  # type: ignore[arg-type]
+                                    else:
+                                        msg = BaseMessageChunk(**msg_)  # type: ignore[arg-type]
+                                    is_chunk = True
+                                else:
+                                    msg = convert_to_messages([msg_])[0]
+                            else:
+                                msg = cast(BaseMessage, msg_)
                             if msg.id in messages:
                                 messages[msg.id] += msg
                             else:
@@ -302,7 +316,11 @@ async def astream_state(
                                     if isinstance(msg, BaseMessageChunk)
                                     else "messages/complete"
                                 ),
-                                [message_chunk_to_message(messages[msg.id])],
+                                [
+                                    message_chunk_to_message(messages[msg.id])
+                                    if not is_chunk
+                                    else messages[msg.id]
+                                ],
                             )
                     elif mode in stream_mode:
                         if subgraphs and ns:
@@ -370,12 +388,23 @@ async def astream_state(
                         msg_, meta = cast(
                             tuple[BaseMessage | dict, dict[str, Any]], chunk
                         )
-                        msg = (
-                            convert_to_messages([msg_])[0]
-                            if isinstance(msg_, dict)
-                            else cast(BaseMessage, msg_)
-                        )
-
+                        is_chunk = False
+                        if isinstance(msg_, dict):
+                            if (
+                                "chunk" in msg_.get("type", "").lower()
+                                or "chunk" in msg_.get("role", "").lower()
+                            ):
+                                if "ai" in msg_.get("role", "").lower():
+                                    msg = AIMessageChunk(**msg_)  # type: ignore[arg-type]
+                                elif "tool" in msg_.get("role", "").lower():
+                                    msg = ToolMessageChunk(**msg_)  # type: ignore[arg-type]
+                                else:
+                                    msg = BaseMessageChunk(**msg_)  # type: ignore[arg-type]
+                                is_chunk = True
+                            else:
+                                msg = convert_to_messages([msg_])[0]
+                        else:
+                            msg = cast(BaseMessage, msg_)
                         if msg.id in messages:
                             messages[msg.id] += msg
                         else:
@@ -387,7 +416,11 @@ async def astream_state(
                                 if isinstance(msg, BaseMessageChunk)
                                 else "messages/complete"
                             ),
-                            [message_chunk_to_message(messages[msg.id])],
+                            [
+                                message_chunk_to_message(messages[msg.id])
+                                if not is_chunk
+                                else messages[msg.id]
+                            ],
                         )
                 elif mode in stream_mode:
                     if subgraphs and ns:

{langgraph_api-0.4.20.dist-info → langgraph_api-0.4.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.20
+Version: 0.4.21
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.13.0,>=0.12.0
+Requires-Dist: langgraph-runtime-inmem<0.13.0,>=0.12.1
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45

{langgraph_api-0.4.20.dist-info → langgraph_api-0.4.21.dist-info}/RECORD

@@ -1,7 +1,7 @@
-langgraph_api/__init__.py,sha256=WCSj_sB9bdEmI7lwg4E_Vhy7TRLJmGYIYjp5bfMMYXE,23
+langgraph_api/__init__.py,sha256=HRnyuWvhHjVmMtjn-Iir0_ZbxVK3sjpTYkAqLIRVMIE,23
 langgraph_api/asgi_transport.py,sha256=XtiLOu4WWsd-xizagBLzT5xUkxc9ZG9YqwvETBPjBFE,5161
 langgraph_api/asyncio.py,sha256=FEEkLm_N-15cbElo4vQ309MkDKBZuRqAYV8VJ1DocNw,9860
-langgraph_api/cli.py,sha256=-ruIeKi1imvS6GriOfRDZY-waV4SbWiJ0BEFAciPVYI,16330
+langgraph_api/cli.py,sha256=mUSY41UBsPbJ3mGB01VH8UCAba1YCpA7h4P9tvhKAEw,19540
 langgraph_api/command.py,sha256=Q9XDRhnkCX7jyqW52_Rf2PPYKxjr-Z9BUHazI1HcmB8,817
 langgraph_api/config.py,sha256=r9mmbyZlhBuJLpnTkaOLcNH6ufFNqm_2eCiuOmhqRl0,12241
 langgraph_api/cron_scheduler.py,sha256=25wYzEQrhPEivZrAPYOmzLPDOQa-aFogU37mTXc9TJk,2566
@@ -12,25 +12,25 @@ langgraph_api/graph.py,sha256=h1m6rsLiCocvMO283LLU03A5cBycxAIxixXu9mwzqsQ,25056
 langgraph_api/http.py,sha256=fyK-H-0UfNy_BzuVW3aWWGvhRavmGAVMkDwDArryJ_4,5659
 langgraph_api/http_metrics.py,sha256=MU9ccXt7aBb0AJ2SWEjwtbtbJEWmeqSdx7-CI51e32o,5594
 langgraph_api/logging.py,sha256=qB6q_cUba31edE4_D6dBGhdiUTpW7sXAOepUjYb_R50,5216
-langgraph_api/metadata.py,sha256=fVsbwxVitAj4LGVYpCcadYeIFANEaNtcx6LBxQLcTqg,6949
+langgraph_api/metadata.py,sha256=0eGYhXOW6UIVDj2Y5mOdSJz_RadgJG8xmUsC9WqwsiE,8342
 langgraph_api/patch.py,sha256=iLwSd9ZWoVj6MxozMyGyMvWWbE9RIP5eZX1dpCBSlSU,1480
 langgraph_api/queue_entrypoint.py,sha256=Y0Hu4QXNV7HPZWlBwuNCm8ehqD_n79AMk7ZWDZfBc4U,5631
 langgraph_api/route.py,sha256=EBhELuJ1He-ZYcAnR5YTImcIeDtWthDae5CHELBxPkM,5056
 langgraph_api/schema.py,sha256=AsgF0dIjBvDd_PDy20mGqB_IkBLgVvSj8qRKG_lPlec,8440
-langgraph_api/serde.py,sha256=Ovs37vfnXP9FHbQqIlA8J3ZdFMuFu-3vnS6EqEuaQ54,5440
-langgraph_api/server.py,sha256=uCAqPgCLJ6ckslLs0i_dacSR8mzuR0Y6PkkJYk0O3bE,7196
+langgraph_api/serde.py,sha256=CLAwuiCRJY2-8GCd7gc3IVzJ8GiyBPmrrlLJjh1B0bw,5512
+langgraph_api/server.py,sha256=C9TO7N0mzyrLulT_2FtaJfgfFbm2B4yyYTdAGPxgIeE,7255
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
 langgraph_api/state.py,sha256=AjkLbUQakIwK7oGzJ8oqubazRsXxG3vDMnRa0s0mzDM,4716
 langgraph_api/store.py,sha256=NIoNZojs6NbtG3VLBPQEFNttvp7XPkHAfjbQ3gY7aLY,4701
-langgraph_api/stream.py,sha256=V8jWwA3wBRenMk3WIFkt0OLXm_LhPwg_Yj_tP4Dc6iI,18970
+langgraph_api/stream.py,sha256=TQbrMc1CeT5cMjS0NB-AUEyL7x6TgOfYdNp7c0-X-mY,20961
 langgraph_api/thread_ttl.py,sha256=KyHnvD0e1p1cV4Z_ZvKNVzDztuI2RBCUsUO2V7GlOSw,1951
 langgraph_api/traceblock.py,sha256=Qq5CUdefnMDaRDnyvBSWGBClEj-f3oO7NbH6fedxOSE,630
 langgraph_api/validation.py,sha256=86jftgOsMa7tkeshBw6imYe7zyUXPoVuf5Voh6dFiR8,5285
 langgraph_api/webhook.py,sha256=SvSM1rdnNtiH4q3JQYmAqJUk2Sable5xAcwOLuRhtlo,1723
 langgraph_api/worker.py,sha256=FQRw3kL9ynDv_LNgY_OjjPZQBuAvSQpsW6nECnABvDg,15354
 langgraph_api/api/__init__.py,sha256=raFkYH50tsO-KjRmDbGVoHCuxuH58u1lrZbr-MlITIY,6262
-langgraph_api/api/a2a.py,sha256=ChqlhgTq5fzWt0jbbEl8ec9rf-cvAP19Yge7OFv8-6E,34629
-langgraph_api/api/assistants.py,sha256=JFaBYp9BAXGaJ0yfy1SG_Mr-3xjeWSkdCHtmXpiAqP4,17290
+langgraph_api/api/a2a.py,sha256=QEx-g0bTOREL-YaFsrcwA7oaix4VsaOr8hoQ7PF4Zwk,49382
+langgraph_api/api/assistants.py,sha256=OX83GCWwGR8MuEJKIzAPEC4LC3Aghs5vD3NGLNnijaU,17268
 langgraph_api/api/mcp.py,sha256=qe10ZRMN3f-Hli-9TI8nbQyWvMeBb72YB1PZVbyqBQw,14418
 langgraph_api/api/meta.py,sha256=Qyj6r5czkVJ81tpD6liFY7tlrmFDsiSfBr-4X8HJpRc,4834
 langgraph_api/api/openapi.py,sha256=If-z1ckXt-Yu5bwQytK1LWyX_T7G46UtLfixgEP8hwc,11959
@@ -55,14 +55,14 @@ langgraph_api/js/client.http.mts,sha256=cvn8JV9go4pUMWkcug8FfSYWsp1wTaT8SgJaskqE
 langgraph_api/js/client.mts,sha256=gDvYiW7Qfl4re2YhZ5oNqtuvffnW_Sf7DK5aUbKB3vw,32330
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=j4GhgtQSZ5_cHzjSPcHgMJ8tfBThxrH-pUOrrJGteOU,196
-langgraph_api/js/package.json,sha256=9NJqixH8l_Vqvr2OeyhtXyuURFO1xcYabD8JOf315dQ,1335
+langgraph_api/js/package.json,sha256=TLyPB9pZyZ1KQXC08NvbBbf8X5dKAF8WXc5cyjFtWZE,1335
 langgraph_api/js/remote.py,sha256=VmQ4Ie1V5z5gWEChXdY1m1kxzL3HE6AwKzfyIEfdE2k,38650
 langgraph_api/js/schema.py,sha256=M4fLtr50O1jck8H1hm_0W4cZOGYGdkrB7riLyCes4oY,438
 langgraph_api/js/sse.py,sha256=hHkbncnYnXNIbHhAWneGWYkHp4UhhhGB7-MYtDrY264,4141
 langgraph_api/js/traceblock.mts,sha256=QtGSN5VpzmGqDfbArrGXkMiONY94pMQ5CgzetT_bKYg,761
 langgraph_api/js/tsconfig.json,sha256=imCYqVnqFpaBoZPx8k1nO4slHIWBFsSlmCYhO73cpBs,341
 langgraph_api/js/ui.py,sha256=l9regrvKIxLOjH5SIYE2nhr8QCKLK1Q_1pZgxdL71X4,2488
-langgraph_api/js/yarn.lock,sha256=_aWrwb3UoBi5YXB0spkJjkQbGQfsofMk8ngxemN8ajw,84341
+langgraph_api/js/yarn.lock,sha256=FCizZGxfI4SVoeAZWbezvonYBXsuvlWMUHX-1yACFz8,84352
 langgraph_api/js/src/graph.mts,sha256=9zTQNdtanI_CFnOwNRoamoCVHHQHGbNlbm91aRxDeOc,2675
 langgraph_api/js/src/load.hooks.mjs,sha256=xNVHq75W0Lk6MUKl1pQYrx-wtQ8_neiUyI6SO-k0ecM,2235
 langgraph_api/js/src/preload.mjs,sha256=8m3bYkf9iZLCQzKAYAdU8snxUwAG3dVLwGvAjfGfgIc,959
@@ -98,8 +98,8 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=21wu-NxdxyTQwZctNcEfRkLMnSBi0QhGAfwq5kg8XNU,172618
-langgraph_api-0.4.20.dist-info/METADATA,sha256=8sa6a-gRKNjbsccT6f5NteILecTGP_CuXoKbNCROXXE,3893
-langgraph_api-0.4.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.4.20.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.4.20.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.4.20.dist-info/RECORD,,
+langgraph_api-0.4.21.dist-info/METADATA,sha256=u0MQ-7iSelB0Sytf4gzdD7n_V94Sefh_NVRzz1znYCg,3893
+langgraph_api-0.4.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.4.21.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.4.21.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.4.21.dist-info/RECORD,,