langgraph-api 0.18.0.dev1__py3-none-any.whl → 0.18.0.dev3__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.18.0.dev1"
+__version__ = "0.18.0.dev3"

langgraph_api/api/a2a.py

@@ -2090,6 +2090,19 @@ async def handle_message_send(
                     "message": "Invalid params: 'configuration' must be an object",
                 }
             }
+        for field in ("returnImmediately", "blocking"):
+            if configuration.get(field) is not None and not isinstance(
+                configuration[field], bool
+            ):
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_PARAMS,
+                        "message": f"Invalid params: '{field}' must be a boolean",
+                    }
+                }
+        return_immediately = configuration.get("returnImmediately")
+        if return_immediately is None:
+            return_immediately = configuration.get("blocking") is False
         history_length = configuration.get("historyLength")
         if history_error := _validate_history_length(history_length):
             return {
@@ -2308,6 +2321,36 @@ async def handle_message_send(
         context_id = str(run["thread_id"])
         if task_id is None:
             task_id = _make_task_id(context_id, str(run["run_id"]))
+        if return_immediately:
+            immediate_task: dict[str, Any] = {
+                "kind": "task",
+                "id": task_id,
+                "contextId": context_id,
+                "status": {
+                    "state": _task_state_for_run(run),
+                    "timestamp": _run_timestamp(run),
+                },
+            }
+            if history_length is not None and history_length != 0:
+                run_messages = await _load_run_messages(
+                    context_id, str(run["run_id"]), request.headers
+                )
+                if not run_messages.messages:
+                    run_messages = RunMessages(input_content.get("messages", []), 0)
+                if task_start_id:
+                    task_ids_by_start_id.setdefault(task_start_id, task_id)
+                immediate_task["history"] = _convert_messages_to_a2a_format(
+                    run_messages.stamped(task_id),
+                    task_id,
+                    context_id,
+                    history_length=history_length,
+                    history_scope=history_scope,
+                    a2ui=a2ui,
+                    task_ids_by_start_id=task_ids_by_start_id,
+                )
+            return {"result": {"task": immediate_task}}
+
+        if existing_task_id is None:
             try:
                 runs = await _list_context_runs(
                     client, context_id=context_id, headers=request.headers
@@ -2489,6 +2532,48 @@ async def handle_tasks_get(
         lg_status = run_info.get("status", "unknown")
         a2a_state = task.state
 
+        if a2a_state in ("TASK_STATE_COMPLETED", "TASK_STATE_INPUT_REQUIRED"):
+            states, before = await asyncio.gather(
+                get_client().threads.get_history(
+                    context_id,
+                    limit=1,
+                    metadata={"run_id": str(run_info["run_id"])},
+                    headers=request.headers,
+                ),
+                _latest_messages(
+                    context_id,
+                    {"run_id": str(run_info["run_id"]), "source": "input"},
+                    request.headers,
+                ),
+            )
+            result = dict(states[0]["values"]) if states else {}
+            messages = result.get("messages", []) or []
+            run_messages = (
+                RunMessages.between(before, messages)
+                if before is not None
+                else RunMessages(messages, None)
+            )
+            if "messages" in result:
+                result["messages"] = run_messages.stamped(task_id)
+            if a2a_state == "TASK_STATE_INPUT_REQUIRED":
+                result["__interrupt__"] = (
+                    states[0].get("interrupts", []) if states else []
+                )
+            response = await _create_task_response(
+                task_id=task_id,
+                context_id=context_id,
+                result=result,
+                assistant_id=assistant_id,
+                a2ui=_a2ui_context_for_run(run_info),
+                history_length=history_length,
+                history_scope=history_scope,
+                task_ids_by_start_id=task.task_ids_by_start_id,
+                turn=run_messages.added,
+            )
+            task_response = response["result"]["task"]
+            task_response["status"]["timestamp"] = task.status_timestamp
+            return {"result": task_response}
+
         thread_history = []
         if history_length != 0:
             try:
@@ -2532,16 +2617,7 @@ async def handle_tasks_get(
         if history_length != 0:
             task_response["history"] = thread_history
 
-        # Add result message if completed
-        if a2a_state == "TASK_STATE_COMPLETED":
-            task_response["status"]["message"] = {
-                "kind": "message",
-                "role": "ROLE_AGENT",
-                "parts": [{"kind": "text", "text": "Task completed successfully"}],
-                "messageId": str(uuid.uuid4()),
-                "taskId": task_id,
-            }
-        elif a2a_state == "TASK_STATE_FAILED":
+        if a2a_state == "TASK_STATE_FAILED":
             task_response["status"]["message"] = {
                 "kind": "message",
                 "role": "ROLE_AGENT",
@@ -2554,6 +2630,13 @@ async def handle_tasks_get(
 
         return {"result": task_response}
 
+    except InvalidAgentResponseError as e:
+        return {
+            "error": {
+                "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                "message": str(e),
+            }
+        }
     except Exception as e:
         await logger.aexception(
             f"Error in tasks/get for task {params.get('id')}: {e!s}", exc_info=True

langgraph_api/api/event_streaming.py

@@ -40,6 +40,8 @@ from langgraph_api.serde import json_dumpb
 from langgraph_api.sse import EventSourceResponse
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from starlette.requests import Request
     from starlette.websockets import WebSocket
 
@@ -91,7 +93,12 @@ def _json_response(content: Any, *, status_code: int = 200) -> Response:
     )
 
 
-def _make_manager(thread_id: str, send_event: Any = None) -> ThreadRunManager:
+def _make_manager(
+    thread_id: str,
+    send_event: Any = None,
+    *,
+    headers: Mapping[str, str] | None = None,
+) -> ThreadRunManager:
     # Auth context is propagated via ``ApiRoute``'s ``with_user`` wrapper
     # — ops reads it off the context var, so we don't thread it through
     # the manager explicitly.
@@ -100,6 +107,7 @@ def _make_manager(thread_id: str, send_event: Any = None) -> ThreadRunManager:
         runs=Runs,
         threads=Threads,
         send_event=send_event,
+        headers=headers,
     )
 
 
@@ -353,7 +361,7 @@ async def _thread_command(request: Request) -> Response:
             status_code=400,
         )
 
-    manager = _make_manager(thread_id)
+    manager = _make_manager(thread_id, headers=request.headers)
     try:
         resp = await manager.handle_command(payload)
         return _json_response(resp)

langgraph_api/api/mcp/_calls.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from langgraph_api.api.mcp._protocol import ProtocolError
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class ToolCall:
+    name: str
+    arguments: dict[str, Any]
+    context: dict[str, Any] | None
+
+    @classmethod
+    def of(cls, params: Mapping[str, Any]) -> ToolCall:
+        name = params.get("name")
+        arguments = params.get("arguments", {})
+        context = params.get("context")
+        if not isinstance(name, str) or not name:
+            raise ProtocolError(f"Unknown tool: {name}")
+        if not isinstance(arguments, dict) or (
+            context is not None and not isinstance(context, dict)
+        ):
+            raise ProtocolError("arguments and context must be objects")
+        return cls(name, arguments, context)

langgraph_api/api/mcp/_constants.py

@@ -1,14 +1,15 @@
-# Workaround assistant name not exposed in the Assistants.search API
 MAX_ASSISTANTS = 1000
 DEFAULT_PAGE_SIZE = 100
+MAX_PAGE_OFFSET = 2**63 - 1
+MAX_CURSOR_LENGTH = len(str(MAX_PAGE_OFFSET))
 
-# JSON-RPC error codes: https://www.jsonrpc.org/specification#error_object
+ERROR_CODE_INVALID_REQUEST = -32600
 ERROR_CODE_INVALID_PARAMS = -32602
 ERROR_CODE_METHOD_NOT_FOUND = -32601
+ERROR_CODE_HEADER_MISMATCH = -32020
+ERROR_CODE_UNSUPPORTED_VERSION = -32022
 
-# Supported MCP protocol versions
-# https://modelcontextprotocol.io/specification/2025-11-25/basic/lifecycle
-SUPPORTED_PROTOCOL_VERSIONS = frozenset(
+LEGACY_PROTOCOL_VERSIONS = frozenset(
     (
         "2024-11-05",
         "2025-03-26",
@@ -16,4 +17,12 @@ SUPPORTED_PROTOCOL_VERSIONS = frozenset(
         "2025-11-25",
     )
 )
-LATEST_PROTOCOL_VERSION = "2025-11-25"
+LATEST_LEGACY_PROTOCOL_VERSION = "2025-11-25"
+PROTOCOL_VERSION = "2026-07-28"
+SUPPORTED_PROTOCOL_VERSIONS = LEGACY_PROTOCOL_VERSIONS | {PROTOCOL_VERSION}
+
+PAUSED_TOOL_MESSAGE = (
+    "This tool paused to ask for human input, and this client can't answer it."
+)
+RUN_FAILED_MESSAGE = "The tool's run failed."
+INVALID_CURSOR_MESSAGE = "Invalid cursor"