langgraph-api 0.4.23__tar.gz → 0.4.25__tar.gz

{langgraph_api-0.4.23 → langgraph_api-0.4.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.23
+Version: 0.4.25
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.4.25/healthcheck.py

@@ -0,0 +1,48 @@
+import json
+import os
+import urllib.request
+from ipaddress import IPv6Address, ip_address
+
+
+def get_healthcheck_host() -> str:
+    server_host = os.environ.get("LANGGRAPH_SERVER_HOST", "0.0.0.0")
+    if server_host in (
+        "0.0.0.0",  # IPv4 wildcard
+        "",  # IPv4/IPv6 dual-stack
+    ):
+        return "localhost"
+
+    try:
+        server_host_ip = ip_address(server_host)
+    except ValueError:
+        return server_host
+
+    return (
+        f"[{server_host_ip.compressed}]"
+        if isinstance(server_host_ip, IPv6Address)
+        else server_host_ip.compressed
+    )
+
+
+def healthcheck():
+    host = get_healthcheck_host()
+
+    prefix = ""
+    mount_prefix = None
+    # Override prefix if it's set in the http config
+    if (http := os.environ.get("LANGGRAPH_HTTP")) and (
+        mount_prefix := json.loads(http).get("mount_prefix")
+    ):
+        prefix = mount_prefix
+    # Override that
+    if os.environ.get("MOUNT_PREFIX"):
+        prefix = os.environ["MOUNT_PREFIX"]
+
+    with urllib.request.urlopen(
+        f"http://{host}:{os.environ['PORT']}{prefix}/ok"
+    ) as response:
+        assert response.status == 200
+
+
+if __name__ == "__main__":
+    healthcheck()

langgraph_api-0.4.25/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.25"

{langgraph_api-0.4.23 → langgraph_api-0.4.25}/langgraph_api/api/a2a.py

@@ -33,6 +33,9 @@ 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)
 
+MAX_HISTORY_LENGTH_REQUESTED = 10
+LANGGRAPH_HISTORY_QUERY_LIMIT = 500
+
 
 # ============================================================================
 # JSON-RPC 2.0 Base Types (shared with MCP)
@@ -99,12 +102,11 @@ def _client() -> LangGraphClient:
 
 
 async def _get_assistant(
-    client: LangGraphClient, assistant_id: str, headers: Headers | dict[str, Any] | None
+    assistant_id: str, headers: Headers | dict[str, Any] | None
 ) -> dict[str, Any]:
     """Get assistant with proper 404 error handling.
 
     Args:
-        client: LangGraph client
         assistant_id: The assistant ID to get
         headers: Request headers
 
@@ -115,7 +117,7 @@ async def _get_assistant(
         ValueError: If assistant not found or other errors
     """
     try:
-        return await client.assistants.get(assistant_id, headers=headers)
+        return await get_client().assistants.get(assistant_id, headers=headers)
     except Exception as e:
         if (
             hasattr(e, "response")
@@ -127,7 +129,6 @@ async def _get_assistant(
 
 
 async def _validate_supports_messages(
-    client: LangGraphClient,
     assistant: dict[str, Any],
     headers: Headers | dict[str, Any] | None,
     parts: list[dict[str, Any]],
@@ -138,7 +139,6 @@ async def _validate_supports_messages(
     If the parts only contain data parts, no validation is performed.
 
     Args:
-        client: LangGraph client
         assistant: The assistant dictionary
         headers: Request headers
         parts: The original A2A message parts
@@ -156,7 +156,9 @@ async def _validate_supports_messages(
         schemas = cached_schemas
     else:
         try:
-            schemas = await client.assistants.get_schemas(assistant_id, headers=headers)
+            schemas = await get_client().assistants.get_schemas(
+                assistant_id, headers=headers
+            )
             _assistant_schemas_cache.set(assistant_id, schemas)
         except Exception as e:
             raise ValueError(
@@ -505,10 +507,50 @@ def _map_runs_get_error_to_rpc(
     }
 
 
-def _create_task_response(
+def _convert_messages_to_a2a_format(
+    messages: list[dict[str, Any]],
+    task_id: str,
+    context_id: str,
+) -> list[dict[str, Any]]:
+    """Convert LangChain messages to A2A message format.
+
+    Args:
+        messages: List of LangChain messages
+        task_id: The task ID to assign to all messages
+        context_id: The context ID to assign to all messages
+
+    Returns:
+        List of A2A messages
+    """
+
+    # Convert each LangChain message to A2A format
+    a2a_messages = []
+    for msg in messages:
+        if isinstance(msg, dict):
+            msg_type = msg.get("type", "ai")
+            msg_role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            # Support both LangChain style (type: "human"/"ai") and OpenAI style (role: "user"/"assistant")
+            # Map to A2A roles: "human"/"user" -> "user", everything else -> "agent"
+            a2a_role = "user" if msg_type == "human" or msg_role == "user" else "agent"
+
+            a2a_message = {
+                "role": a2a_role,
+                "parts": [{"kind": "text", "text": str(content)}],
+                "messageId": str(uuid.uuid4()),
+                "taskId": task_id,
+                "contextId": context_id,
+                "kind": "message",
+            }
+            a2a_messages.append(a2a_message)
+
+    return a2a_messages
+
+
+async def _create_task_response(
     task_id: str,
     context_id: str,
-    message: dict[str, Any],
     result: dict[str, Any],
     assistant_id: str,
 ) -> dict[str, Any]:
@@ -520,16 +562,19 @@ def _create_task_response(
         message: Original A2A message from request
         result: LangGraph execution result
         assistant_id: The assistant ID used
+        headers: Request headers
 
     Returns:
         A2A Task response dictionary
     """
+    # Convert result messages to A2A message format
+    messages = result.get("messages", []) or []
+    thread_history = _convert_messages_to_a2a_format(messages, task_id, context_id)
+
     base_task = {
         "id": task_id,
         "contextId": context_id,
-        "history": [
-            {**message, "taskId": task_id, "contextId": context_id, "kind": "message"}
-        ],
+        "history": thread_history,
         "kind": "task",
     }
 
@@ -796,8 +841,8 @@ async def handle_message_send(
             }
 
         try:
-            assistant = await _get_assistant(client, assistant_id, request.headers)
-            await _validate_supports_messages(client, assistant, request.headers, parts)
+            assistant = await _get_assistant(assistant_id, request.headers)
+            await _validate_supports_messages(assistant, request.headers, parts)
         except ValueError as e:
             return {
                 "error": {
@@ -822,6 +867,10 @@ async def handle_message_send(
 
         context_id = message.get("contextId")
 
+        # If no contextId provided, generate a UUID so we don't pass None to runs.create
+        if context_id is None:
+            context_id = str(uuid.uuid4())
+
         try:
             run = await client.runs.create(
                 thread_id=context_id,
@@ -845,10 +894,9 @@ async def handle_message_send(
         task_id = run["run_id"]
         context_id = run["thread_id"]
 
-        return _create_task_response(
+        return await _create_task_response(
             task_id=task_id,
             context_id=context_id,
-            message=message,
             result=result,
             assistant_id=assistant_id,
         )
@@ -863,6 +911,37 @@ async def handle_message_send(
         }
 
 
+async def _get_historical_messages_for_task(
+    context_id: str,
+    task_run_id: str,
+    request_headers: Headers,
+    history_length: int | None = None,
+) -> list[Any]:
+    """Get historical messages for a specific task by matching run_id."""
+    history = await get_client().threads.get_history(
+        context_id,
+        limit=LANGGRAPH_HISTORY_QUERY_LIMIT,
+        metadata={"run_id": task_run_id},
+        headers=request_headers,
+    )
+
+    if history:
+        # Find the checkpoint with the highest step number (final state for this task)
+        target_checkpoint = max(
+            history, key=lambda c: c.get("metadata", {}).get("step", 0)
+        )
+        values = target_checkpoint["values"]
+        messages = values.get("messages", [])
+
+        # Apply client-requested history length limit per A2A spec
+        if history_length is not None and len(messages) > history_length:
+            # Return the most recent messages up to the limit
+            messages = messages[-history_length:]
+        return messages
+    else:
+        return []
+
+
 async def handle_tasks_get(
     request: ApiRequest, params: dict[str, Any]
 ) -> dict[str, Any]:
@@ -885,6 +964,7 @@ async def handle_tasks_get(
     try:
         task_id = params.get("id")
         context_id = params.get("contextId")
+        history_length = params.get("historyLength")
 
         if not task_id:
             return {
@@ -902,6 +982,23 @@ async def handle_tasks_get(
                 }
             }
 
+        # Validate history_length parameter per A2A spec
+        if history_length is not None:
+            if not isinstance(history_length, int) or history_length < 0:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_PARAMS,
+                        "message": "historyLength must be a non-negative integer",
+                    }
+                }
+            if history_length > MAX_HISTORY_LENGTH_REQUESTED:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_PARAMS,
+                        "message": f"historyLength cannot exceed {MAX_HISTORY_LENGTH_REQUESTED}",
+                    }
+                }
+
         try:
             run_info = await client.runs.get(
                 thread_id=context_id,
@@ -919,7 +1016,7 @@ async def handle_tasks_get(
         if assistant_id:
             try:
                 # Verify that the assistant exists
-                await _get_assistant(client, assistant_id, request.headers)
+                await _get_assistant(assistant_id, request.headers)
             except ValueError as e:
                 return {
                     "error": {
@@ -941,10 +1038,24 @@ async def handle_tasks_get(
         else:
             a2a_state = "submitted"
 
+        try:
+            task_run_id = run_info.get("run_id")
+            messages = await _get_historical_messages_for_task(
+                context_id, task_run_id, request.headers, history_length
+            )
+            thread_history = _convert_messages_to_a2a_format(
+                messages, task_id, context_id
+            )
+        except Exception as e:
+            await logger.aexception(f"Failed to get thread state for tasks/get: {e}")
+            thread_history = []
+
         # Build the A2A Task response
         task_response = {
             "id": task_id,
             "contextId": context_id,
+            "history": thread_history,
+            "kind": "task",
             "status": {
                 "state": a2a_state,
             },
@@ -1033,7 +1144,7 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
     """
     client = _client()
 
-    assistant = await _get_assistant(client, assistant_id, request.headers)
+    assistant = await _get_assistant(assistant_id, request.headers)
     schemas = await client.assistants.get_schemas(assistant_id, headers=request.headers)
 
     # Extract schema information for metadata
@@ -1212,10 +1323,8 @@ async def handle_message_stream(
                 return
 
             try:
-                assistant = await _get_assistant(client, assistant_id, request.headers)
-                await _validate_supports_messages(
-                    client, assistant, request.headers, parts
-                )
+                assistant = await _get_assistant(assistant_id, request.headers)
+                await _validate_supports_messages(assistant, request.headers, parts)
             except ValueError as e:
                 yield (
                     b"message",

{langgraph_api-0.4.23 → langgraph_api-0.4.25}/langgraph_api/queue_entrypoint.py

@@ -81,7 +81,7 @@ async def health_and_metrics_server():
 
     config = uvicorn.Config(
         app,
-        host="0.0.0.0",
+        host=os.getenv("LANGGRAPH_SERVER_HOST", "0.0.0.0"),
         port=port,
         log_level="error",
         access_log=False,

{langgraph_api-0.4.23 → langgraph_api-0.4.25}/langgraph_api/stream.py

@@ -317,9 +317,11 @@ async def astream_state(
                                     else "messages/complete"
                                 ),
                                 [
-                                    message_chunk_to_message(messages[msg.id])
-                                    if not is_chunk
-                                    else messages[msg.id]
+                                    (
+                                        message_chunk_to_message(messages[msg.id])
+                                        if not is_chunk
+                                        else messages[msg.id]
+                                    )
                                 ],
                             )
                     elif mode in stream_mode:
@@ -379,6 +381,7 @@ async def astream_state(
                     elif chunk["type"] == "task_result":
                         on_task_result(chunk["payload"])
                 if mode == "messages":
+                    logger.warning("EVENT BRO", stream_event=event)
                     if "messages-tuple" in stream_mode:
                         if subgraphs and ns:
                             yield f"messages|{'|'.join(ns)}", chunk
@@ -417,9 +420,11 @@ async def astream_state(
                                 else "messages/complete"
                             ),
                             [
-                                message_chunk_to_message(messages[msg.id])
-                                if not is_chunk
-                                else messages[msg.id]
+                                (
+                                    message_chunk_to_message(messages[msg.id])
+                                    if not is_chunk
+                                    else messages[msg.id]
+                                )
                             ],
                         )
                 elif mode in stream_mode:

langgraph_api-0.4.23/healthcheck.py

@@ -1,19 +0,0 @@
-import json
-import os
-import urllib.request
-
-prefix = ""
-mount_prefix = None
-# Override prefix if it's set in the http config
-if (http := os.environ.get("LANGGRAPH_HTTP")) and (
-    mount_prefix := json.loads(http).get("mount_prefix")
-):
-    prefix = mount_prefix
-# Override that
-if os.environ.get("MOUNT_PREFIX"):
-    prefix = os.environ["MOUNT_PREFIX"]
-
-with urllib.request.urlopen(
-    f"http://localhost:{os.environ['PORT']}{prefix}/ok"
-) as response:
-    assert response.status == 200

langgraph_api-0.4.23/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.23"