langgraph-api 0.15.0.dev3__py3-none-any.whl → 0.15.0.dev4__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.15.0.dev3"
+__version__ = "0.15.0.dev4"

langgraph_api/api/a2a.py

@@ -125,6 +125,30 @@ class A2UIContext:
 _A2UI_DISABLED_CONTEXT = A2UIContext(False, False, {}, [])
 
 
+@dataclass(frozen=True)
+class A2ATask:
+    task_id: str
+    context_id: str
+    run: dict[str, Any]
+    state: str
+    status_timestamp: str
+    task_ids_by_start_id: dict[str, str]
+
+
+# Keep each core search rate-limit charge bounded.
+_A2A_CONTEXT_SEARCH_LIMIT = 1000
+_A2A_RUN_SCAN_LIMIT = 1000
+_A2A_LIST_CONCURRENCY = 10
+_TERMINAL_TASK_STATES = frozenset(
+    {
+        "TASK_STATE_COMPLETED",
+        "TASK_STATE_FAILED",
+        "TASK_STATE_CANCELED",
+        "TASK_STATE_REJECTED",
+    }
+)
+
+
 def _a2ui_enabled(assistant: dict[str, Any]) -> bool:
     metadata = assistant.get("metadata")
     a2a_metadata = metadata.get("a2a") if isinstance(metadata, dict) else None
@@ -146,17 +170,30 @@ def _a2ui_context_for_run(
     )
 
 
-def _a2ui_run_metadata(
-    assistant: dict[str, Any], context: A2UIContext
-) -> dict[str, Any] | None:
-    if not context.enabled:
-        return None
+def _a2a_run_metadata(
+    assistant: dict[str, Any],
+    context: A2UIContext,
+    *,
+    task_id: str | None,
+    task_start_id: str | None,
+) -> dict[str, Any]:
     metadata = assistant.get("metadata")
     a2a_metadata = metadata.get("a2a") if isinstance(metadata, dict) else None
+    inherited = (
+        {
+            key: value
+            for key, value in a2a_metadata.items()
+            if key not in {"task_id", "task_start_id"}
+        }
+        if context.enabled and isinstance(a2a_metadata, dict)
+        else {}
+    )
     return {
         "a2a": {
-            **(a2a_metadata if isinstance(a2a_metadata, dict) else {}),
-            "a2ui_active": context.active,
+            **inherited,
+            **({"task_id": task_id} if task_id else {}),
+            **({"task_start_id": task_start_id} if task_start_id else {}),
+            **({"a2ui_active": context.active} if context.enabled else {}),
         }
     }
 
@@ -295,6 +332,180 @@ def _parse_task_id(task_id: str) -> tuple[str, str]:
     return "", task_id
 
 
+def _http_status_code(exception: Exception) -> int | None:
+    response = getattr(exception, "response", None)
+    return getattr(response, "status_code", None)
+
+
+def _run_a2a_metadata(run: dict[str, Any]) -> dict[str, Any]:
+    metadata = run.get("metadata")
+    a2a = metadata.get("a2a") if isinstance(metadata, dict) else None
+    return a2a if isinstance(a2a, dict) else {}
+
+
+def _task_id_for_run(context_id: str, run: dict[str, Any]) -> str:
+    stored_task_id = _run_a2a_metadata(run).get("task_id")
+    if isinstance(stored_task_id, str) and stored_task_id:
+        return stored_task_id
+    return _make_task_id(context_id, str(run["run_id"]))
+
+
+def _task_ids_by_start_id(
+    runs: list[dict[str, Any]], context_id: str, assistant_id: str
+) -> dict[str, str]:
+    task_ids: dict[str, str] = {}
+    for run in runs:
+        if str(run.get("assistant_id")) != assistant_id:
+            continue
+        task_start_id = _run_a2a_metadata(run).get("task_start_id")
+        if isinstance(task_start_id, str) and task_start_id:
+            task_ids[task_start_id] = _task_id_for_run(context_id, run)
+    return task_ids
+
+
+def _run_sort_key(run: dict[str, Any]) -> tuple[str, str]:
+    created_at = run.get("created_at")
+    if isinstance(created_at, datetime):
+        created_at = created_at.isoformat()
+    return str(created_at or ""), str(run.get("run_id") or "")
+
+
+def _latest_run_id(runs: list[dict[str, Any]]) -> str | None:
+    return str(max(runs, key=_run_sort_key).get("run_id")) if runs else None
+
+
+def _runs_for_assistant(
+    runs: list[dict[str, Any]], assistant_id: str
+) -> list[dict[str, Any]]:
+    return sorted(
+        (run for run in runs if str(run.get("assistant_id")) == assistant_id),
+        key=_run_sort_key,
+        reverse=True,
+    )
+
+
+async def _list_context_runs(
+    client: LangGraphClient,
+    *,
+    context_id: str,
+    headers: Headers | dict[str, Any] | None,
+) -> list[dict[str, Any]]:
+    runs = await client.runs.list(
+        context_id,
+        limit=_A2A_RUN_SCAN_LIMIT,
+        headers=headers,
+    )
+    if len(runs) == _A2A_RUN_SCAN_LIMIT:
+        await logger.awarning(
+            "A2A context run scan reached its limit; task state or history may be truncated",
+            context_id=context_id,
+            run_scan_limit=_A2A_RUN_SCAN_LIMIT,
+        )
+    return runs
+
+
+def _lg_status_to_a2a_state(lg_status: str) -> str:
+    """Map a LangGraph run status to an A2A task state."""
+    mapping = {
+        "pending": "TASK_STATE_SUBMITTED",
+        "running": "TASK_STATE_WORKING",
+        "success": "TASK_STATE_COMPLETED",
+        # LangGraph uses this for an externally canceled run. Graph-level HITL
+        # interrupts finish the run successfully and interrupt the thread.
+        "interrupted": "TASK_STATE_CANCELED",
+        "error": "TASK_STATE_FAILED",
+        "timeout": "TASK_STATE_FAILED",
+    }
+    return mapping.get(lg_status, "TASK_STATE_SUBMITTED")
+
+
+def _task_state_for_run(
+    run: dict[str, Any], thread: dict[str, Any] | None = None
+) -> str:
+    state = _lg_status_to_a2a_state(run.get("status", "unknown"))
+    if (
+        run.get("status") == "success"
+        and thread is not None
+        and thread.get("status") == "interrupted"
+    ):
+        return "TASK_STATE_INPUT_REQUIRED"
+    return state
+
+
+def _run_timestamp(run: dict[str, Any]) -> str:
+    timestamp = run.get("updated_at") or run.get("created_at")
+    if isinstance(timestamp, datetime):
+        return timestamp.isoformat()
+    if isinstance(timestamp, str):
+        return timestamp
+    return datetime.now(UTC).isoformat()
+
+
+async def _resolve_task(
+    client: LangGraphClient,
+    *,
+    task_id: str,
+    context_id: str | None,
+    assistant_id: str,
+    headers: Headers | dict[str, Any] | None,
+) -> A2ATask | None:
+    parsed_context_id, anchor_run_id = _parse_task_id(task_id)
+    if parsed_context_id and context_id and parsed_context_id != context_id:
+        return None
+    resolved_context_id = context_id or parsed_context_id
+    if not resolved_context_id:
+        return None
+
+    try:
+        anchor_run, thread = await asyncio.gather(
+            client.runs.get(
+                thread_id=resolved_context_id,
+                run_id=anchor_run_id,
+                headers=headers,
+            ),
+            client.threads.get(resolved_context_id, headers=headers),
+        )
+    except Exception as exc:
+        if _http_status_code(exc) in {400, 404, 422}:
+            return None
+        raise
+    if str(anchor_run.get("assistant_id")) != assistant_id:
+        return None
+
+    anchor_stored_task_id = _run_a2a_metadata(anchor_run).get("task_id")
+    if (
+        isinstance(anchor_stored_task_id, str)
+        and anchor_stored_task_id
+        and anchor_stored_task_id != task_id
+    ):
+        return None
+
+    runs = await _list_context_runs(
+        client, context_id=resolved_context_id, headers=headers
+    )
+    latest_run = anchor_run
+    context_latest_run_id = _latest_run_id(runs)
+    is_context_latest = False
+    for run in _runs_for_assistant(runs, assistant_id):
+        if str(run.get("run_id")) == anchor_run_id or (
+            _run_a2a_metadata(run).get("task_id") == task_id
+        ):
+            latest_run = run
+            is_context_latest = str(run.get("run_id")) == context_latest_run_id
+            break
+
+    return A2ATask(
+        task_id=task_id,
+        context_id=resolved_context_id,
+        run=latest_run,
+        state=_task_state_for_run(latest_run, thread if is_context_latest else None),
+        status_timestamp=_run_timestamp(latest_run),
+        task_ids_by_start_id=_task_ids_by_start_id(
+            runs, resolved_context_id, assistant_id
+        ),
+    )
+
+
 async def _get_assistant(
     assistant_id: str, headers: Headers | dict[str, Any] | None
 ) -> dict[str, Any]:
@@ -532,17 +743,10 @@ async def _maybe_promote_resume_to_command(
 
     if not context_id:
         return None, None, input_content
+    if not task_id:
+        return None, None, input_content
     if not await _is_thread_interrupted(client, context_id, headers):
         return None, None, input_content
-    if not task_id:
-        return (
-            None,
-            {
-                "code": ERROR_CODE_INVALID_PARAMS,
-                "message": "contextId and taskId are required when resuming a task",
-            },
-            input_content,
-        )
 
     if resume_source == "text" and "messages" in input_content:
         input_content = dict(input_content)
@@ -593,6 +797,8 @@ def _process_a2a_message_parts(
     message_id: str,
     *,
     a2ui: A2UIContext,
+    task_id: str | None = None,
+    task_start_id: str | None = None,
 ) -> dict[str, Any]:
     """Convert A2A message parts to LangChain messages format.
 
@@ -699,8 +905,10 @@ def _process_a2a_message_parts(
             }
         )
 
-    if a2ui.metadata or a2ui.extensions:
+    if task_id or task_start_id or a2ui.metadata or a2ui.extensions:
         a2a_data = {
+            **({"task_id": task_id} if task_id else {}),
+            **({"task_start_id": task_start_id} if task_start_id else {}),
             **({"metadata": a2ui.metadata} if a2ui.metadata else {}),
             **({"extensions": a2ui.extensions} if a2ui.extensions else {}),
         }
@@ -1241,62 +1449,6 @@ def _map_runs_create_error_to_rpc(
     }
 
 
-def _map_runs_get_error_to_rpc(
-    exception: Exception, task_id: str, thread_id: str
-) -> dict[str, Any]:
-    """Map runs.get() exceptions to A2A JSON-RPC error responses.
-
-    Args:
-        exception: Exception from runs.get()
-        task_id: The task/run ID that was requested
-        thread_id: The thread ID that was requested
-
-    Returns:
-        A2A error response dictionary
-    """
-    if hasattr(exception, "response") and hasattr(exception.response, "status_code"):
-        status_code = exception.response.status_code
-        error_text = str(exception)
-
-        status_code_handlers = {
-            404: {
-                "error": {
-                    "code": ERROR_CODE_TASK_NOT_FOUND,
-                    "message": f"Task '{task_id}' not found in thread '{thread_id}'",
-                }
-            },
-            400: {
-                "error": {
-                    "code": ERROR_CODE_INVALID_PARAMS,
-                    "message": f"Invalid request: {error_text}",
-                }
-            },
-            403: {
-                "error": {
-                    "code": ERROR_CODE_INVALID_PARAMS,
-                    "message": "Access denied to task",
-                }
-            },
-        }
-
-        return status_code_handlers.get(
-            status_code,
-            {
-                "error": {
-                    "code": ERROR_CODE_INVALID_PARAMS,
-                    "message": f"Failed to get task: {error_text}",
-                }
-            },
-        )
-
-    return {
-        "error": {
-            "code": ERROR_CODE_INTERNAL_ERROR,
-            "message": "Internal server error",
-        }
-    }
-
-
 def _convert_messages_to_a2a_format(
     messages: list[dict[str, Any]],
     task_id: str,
@@ -1304,6 +1456,7 @@ def _convert_messages_to_a2a_format(
     *,
     history_length: int | None = None,
     a2ui: A2UIContext,
+    task_ids_by_start_id: dict[str, str] | None = None,
 ) -> list[dict[str, Any]]:
     """Convert LangChain messages to A2A message format.
 
@@ -1315,7 +1468,7 @@ def _convert_messages_to_a2a_format(
 
     Args:
         messages: List of LangChain messages
-        task_id: The task ID to assign to all messages
+        task_id: The fallback task ID for legacy messages without stored provenance
         context_id: The context ID to assign to all messages
         history_length: Maximum number of visible A2A messages to return.
 
@@ -1325,10 +1478,40 @@ def _convert_messages_to_a2a_format(
 
     history_a2ui = replace(a2ui, drop_invalid=True)
 
+    # A task-stamped user message starts a new provenance segment. Agent and
+    # tool messages that follow belong to that task until the next stamped turn.
+    current_task_id: str | None = task_id
+    known_task_ids = (
+        set(task_ids_by_start_id.values()) if task_ids_by_start_id is not None else None
+    )
+
     # Convert each LangChain message to A2A format
     a2a_messages = []
     for msg in messages:
         if isinstance(msg, dict):
+            additional_kwargs = msg.get("additional_kwargs")
+            stored_a2a = (
+                additional_kwargs.get("a2a")
+                if isinstance(additional_kwargs, dict)
+                else None
+            )
+            stored_task_id = (
+                stored_a2a.get("task_id") if isinstance(stored_a2a, dict) else None
+            )
+            if isinstance(stored_task_id, str) and stored_task_id:
+                current_task_id = (
+                    stored_task_id
+                    if known_task_ids is None or stored_task_id in known_task_ids
+                    else None
+                )
+            elif isinstance(stored_a2a, dict) and task_ids_by_start_id is not None:
+                task_start_id = stored_a2a.get("task_start_id")
+                if isinstance(task_start_id, str):
+                    current_task_id = task_ids_by_start_id.get(task_start_id)
+
+            if current_task_id is None:
+                continue
+
             a2a_role = _a2a_role_for_message(msg)
 
             if a2a_role is None:
@@ -1355,7 +1538,7 @@ def _convert_messages_to_a2a_format(
                 "role": a2a_role,
                 "parts": parts,
                 "messageId": msg.get("id") or str(uuid7()),
-                "taskId": task_id,
+                "taskId": current_task_id,
                 "contextId": context_id,
             }
             a2a_messages.append(a2a_message)
@@ -1374,6 +1557,7 @@ async def _create_task_response(
     assistant_id: str,
     a2ui: A2UIContext,
     history_length: int | None = None,
+    task_ids_by_start_id: dict[str, str] | None = None,
 ) -> dict[str, Any]:
     """Create A2A Task response structure for both success and failure cases.
 
@@ -1395,6 +1579,7 @@ async def _create_task_response(
         context_id,
         history_length=history_length,
         a2ui=a2ui,
+        task_ids_by_start_id=task_ids_by_start_id,
     )
 
     base_task: dict[str, Any] = {
@@ -1685,6 +1870,14 @@ async def handle_jsonrpc_request(
     Returns:
         JSON-RPC response
     """
+    try:
+        assistant_id = str(uuid.UUID(assistant_id))
+    except ValueError:
+        return create_jsonrpc_error_response(
+            ERROR_CODE_INVALID_PARAMS,
+            "Invalid assistant ID: must be a UUID",
+            message["id"],
+        )
     method = message["method"]
     params = message.get("params", {})
     # Route to appropriate A2A method handler
@@ -1695,9 +1888,9 @@ async def handle_jsonrpc_request(
     elif method == "GetTask":
         result_or_error = await handle_tasks_get(request, params, assistant_id)
     elif method == "CancelTask":
-        result_or_error = await handle_tasks_cancel(request, params)
+        result_or_error = await handle_tasks_cancel(request, params, assistant_id)
     elif method == "ListTasks":
-        result_or_error = await handle_list_tasks(request, params)
+        result_or_error = await handle_list_tasks(request, params, assistant_id)
     elif method == "GetExtendedAgentCard":
         result_or_error = await handle_get_extended_card(request, assistant_id)
     else:
@@ -1837,6 +2030,57 @@ async def handle_message_send(
                 }
             }
 
+        requested_context_id = message.get("contextId")
+        existing_task_id = message.get("taskId")
+        if requested_context_id is not None and not isinstance(
+            requested_context_id, str
+        ):
+            return {
+                "error": {
+                    "code": ERROR_CODE_INVALID_PARAMS,
+                    "message": "contextId must be a string",
+                }
+            }
+        if existing_task_id is not None and not isinstance(existing_task_id, str):
+            return {
+                "error": {
+                    "code": ERROR_CODE_INVALID_PARAMS,
+                    "message": "taskId must be a string",
+                }
+            }
+
+        if existing_task_id is None:
+            context_id = requested_context_id or str(uuid.uuid4())
+            task_id = None
+            task_start_id = str(uuid7())
+            task_ids_by_start_id: dict[str, str] = {}
+        else:
+            task = await _resolve_task(
+                client,
+                task_id=existing_task_id,
+                context_id=requested_context_id,
+                assistant_id=assistant_id,
+                headers=request.headers,
+            )
+            if task is None:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_TASK_NOT_FOUND,
+                        "message": f"Task not found: {existing_task_id}",
+                    }
+                }
+            if task.state in _TERMINAL_TASK_STATES:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_UNSUPPORTED_OPERATION,
+                        "message": "A terminal task cannot accept another message",
+                    }
+                }
+            context_id = task.context_id
+            task_id = task.task_id
+            task_start_id = None
+            task_ids_by_start_id = task.task_ids_by_start_id
+
         # Process A2A message parts into LangChain messages format
         try:
             a2ui = _a2ui_message_context(message, assistant)
@@ -1846,6 +2090,8 @@ async def handle_message_send(
                 message_role,
                 message_id,
                 a2ui=a2ui,
+                task_id=task_id,
+                task_start_id=task_start_id,
             )
         except A2UIValidationError as e:
             return {
@@ -1862,12 +2108,10 @@ async def handle_message_send(
                 }
             }
 
-        context_id = message.get("contextId")
-        # Check if this is a continuation (taskId provided in message)
-        existing_task_id = message.get("taskId")
-
         # Extract and validate command (LangGraph extension for resuming interrupts)
-        command, command_error = _extract_and_validate_command(message, context_id)
+        command, command_error = _extract_and_validate_command(
+            message, requested_context_id
+        )
         if command_error:
             return {"error": command_error}
         if command is not None and command.get("resume") and existing_task_id is None:
@@ -1885,7 +2129,7 @@ async def handle_message_send(
             ) = await _maybe_promote_resume_to_command(
                 client=client,
                 parts=parts,
-                context_id=context_id,
+                context_id=context_id if existing_task_id else requested_context_id,
                 task_id=existing_task_id,
                 input_content=input_content,
                 headers=request.headers,
@@ -1899,10 +2143,6 @@ async def handle_message_send(
                 task_id=existing_task_id,
             )
 
-        # 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,
@@ -1910,7 +2150,12 @@ async def handle_message_send(
                 input=input_content,
                 command=command,
                 context=run_context,
-                metadata=_a2ui_run_metadata(assistant, a2ui),
+                metadata=_a2a_run_metadata(
+                    assistant,
+                    a2ui,
+                    task_id=task_id,
+                    task_start_id=task_start_id,
+                ),
                 if_not_exists="create",
                 headers=request.headers,
             )
@@ -1920,17 +2165,31 @@ async def handle_message_send(
                 raise
             return error_response
 
+        context_id = str(run["thread_id"])
+        if task_id is None:
+            task_id = _make_task_id(context_id, str(run["run_id"]))
+            try:
+                runs = await _list_context_runs(
+                    client, context_id=context_id, headers=request.headers
+                )
+                task_ids_by_start_id = _task_ids_by_start_id(
+                    runs, context_id, assistant_id
+                )
+            except Exception:
+                await logger.awarning(
+                    "Failed to resolve A2A history provenance",
+                    context_id=context_id,
+                    exc_info=True,
+                )
+            if task_start_id:
+                task_ids_by_start_id.setdefault(task_start_id, task_id)
+
         result = await client.runs.join(
             thread_id=run["thread_id"],
             run_id=run["run_id"],
             headers=request.headers,
         )
 
-        context_id = str(run["thread_id"])
-        # If continuing an existing task, preserve the original task_id
-        # Otherwise create a new composite task_id
-        task_id = existing_task_id or _make_task_id(context_id, run["run_id"])
-
         return await _create_task_response(
             task_id=task_id,
             context_id=context_id,
@@ -1938,6 +2197,7 @@ async def handle_message_send(
             assistant_id=assistant_id,
             history_length=history_length,
             a2ui=a2ui,
+            task_ids_by_start_id=task_ids_by_start_id,
         )
 
     except InvalidAgentResponseError as e:
@@ -2012,24 +2272,36 @@ async def handle_tasks_get(
                     "message": "Missing required parameter: id (task_id)",
                 }
             }
+        if not isinstance(task_id_raw, str) or (
+            context_id_param is not None and not isinstance(context_id_param, str)
+        ):
+            return {
+                "error": {
+                    "code": ERROR_CODE_INVALID_PARAMS,
+                    "message": "Task id and contextId must be strings",
+                }
+            }
 
-        # Parse composite task_id to extract context_id and run_id
-        parsed_context_id, run_id = _parse_task_id(task_id_raw)
-
-        # Use contextId from params if provided, otherwise from task_id
-        context_id = context_id_param or parsed_context_id
-
-        if not context_id:
-            # If task_id isn't a composite ID and no contextId provided, task doesn't exist
+        task = await _resolve_task(
+            client,
+            task_id=task_id_raw,
+            context_id=context_id_param,
+            assistant_id=assistant_id,
+            headers=request.headers,
+        )
+        if task is None:
+            location = f" in context '{context_id_param}'" if context_id_param else ""
             return {
                 "error": {
                     "code": ERROR_CODE_TASK_NOT_FOUND,
-                    "message": f"Task not found: {task_id_raw}",
+                    "message": f"Task not found: {task_id_raw}{location}",
                 }
             }
 
         # Keep original task_id for A2A response (preserve what was sent/received)
-        task_id = task_id_raw
+        task_id = task.task_id
+        context_id = task.context_id
+        run_info = task.run
 
         if history_error := _validate_history_length(history_length):
             return {
@@ -2039,49 +2311,10 @@ async def handle_tasks_get(
                 }
             }
 
-        try:
-            # TODO: fix the N+1 query issue
-            assistant, run_info, thread_info = await asyncio.gather(
-                _get_assistant(assistant_id, request.headers),
-                client.runs.get(
-                    thread_id=context_id,
-                    run_id=run_id,
-                    headers=request.headers,
-                ),
-                client.threads.get(
-                    thread_id=context_id,
-                    headers=request.headers,
-                ),
-            )
-        except Exception as e:
-            error_response = _map_runs_get_error_to_rpc(e, run_id, context_id)
-            if error_response.get("error", {}).get("code") == ERROR_CODE_INTERNAL_ERROR:
-                # For unmapped errors, re-raise to be caught by outer exception handler
-                raise
-            return error_response
+        assistant = await _get_assistant(assistant_id, request.headers)
 
         lg_status = run_info.get("status", "unknown")
-
-        if lg_status == "pending":
-            a2a_state = "TASK_STATE_SUBMITTED"
-        elif lg_status == "running":
-            a2a_state = "TASK_STATE_WORKING"
-        elif lg_status == "success":
-            # Hack hack: if the thread **at present** is interrupted, assume
-            # the run also is interrupted
-            if thread_info.get("status") == "interrupted":
-                a2a_state = "TASK_STATE_INPUT_REQUIRED"
-            else:
-                # Inspect whether there are next tasks
-                a2a_state = "TASK_STATE_COMPLETED"
-        elif (
-            lg_status == "interrupted"
-        ):  # Note that this is if you interrupt FROM the outside (i.e., with double texting)
-            a2a_state = "TASK_STATE_INPUT_REQUIRED"
-        elif lg_status in ["error", "timeout"]:
-            a2a_state = "TASK_STATE_FAILED"
-        else:
-            a2a_state = "TASK_STATE_SUBMITTED"
+        a2a_state = task.state
 
         thread_history = []
         if history_length != 0:
@@ -2098,6 +2331,7 @@ async def handle_tasks_get(
                     a2ui=_a2ui_context_for_run(
                         run_info, enabled=_a2ui_enabled(assistant)
                     ),
+                    task_ids_by_start_id=task.task_ids_by_start_id,
                 )
             except A2UIValidationError:
                 raise
@@ -2120,6 +2354,7 @@ async def handle_tasks_get(
             "contextId": context_id,
             "status": {
                 "state": a2a_state,
+                "timestamp": task.status_timestamp,
             },
         }
         if history_length != 0:
@@ -2160,7 +2395,7 @@ async def handle_tasks_get(
 
 
 async def handle_tasks_cancel(
-    request: ApiRequest, params: dict[str, Any]
+    request: ApiRequest, params: dict[str, Any], assistant_id: str
 ) -> dict[str, Any]:
     """Handle tasks/cancel requests to cancel running tasks.
 
@@ -2189,87 +2424,111 @@ async def handle_tasks_cancel(
                 "message": "Missing required parameter: id (task_id)",
             }
         }
-
-    # Parse composite task_id to extract context_id and run_id
-    parsed_context_id, run_id = _parse_task_id(task_id_raw)
-    context_id = context_id_param or parsed_context_id
-
-    if not context_id:
-        # If task_id isn't a composite ID and no contextId provided, task doesn't exist
+    if not isinstance(task_id_raw, str) or (
+        context_id_param is not None and not isinstance(context_id_param, str)
+    ):
         return {
             "error": {
-                "code": ERROR_CODE_TASK_NOT_FOUND,
-                "message": f"Task not found: {task_id_raw}",
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": "Task id and contextId must be strings",
             }
         }
 
-    # Check if the task exists first
     try:
-        run_info = await client.runs.get(
-            thread_id=context_id,
-            run_id=run_id,
+        task = await _resolve_task(
+            client,
+            task_id=task_id_raw,
+            context_id=context_id_param,
+            assistant_id=assistant_id,
             headers=request.headers,
         )
-    except Exception as e:
-        # Check if it's a 404 error
-        if (
-            hasattr(e, "response")
-            and hasattr(e.response, "status_code")
-            and e.response.status_code == 404
-        ):
-            return {
-                "error": {
-                    "code": ERROR_CODE_TASK_NOT_FOUND,
-                    "message": f"Task not found: {task_id_raw}",
-                }
-            }
-        # For other errors, return internal error
+    except Exception:
+        logger.exception("Failed to resolve A2A task for cancellation")
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Failed to check task status: {e!s}",
+                "message": "Failed to check task status",
             }
         }
 
-    # Check if the task is in a cancelable state
-    lg_status = run_info.get("status", "unknown")
+    if task is None:
+        return {
+            "error": {
+                "code": ERROR_CODE_TASK_NOT_FOUND,
+                "message": f"Task not found: {task_id_raw}",
+            }
+        }
 
-    # If task is already in a terminal state, return it as "canceled" per A2A spec
-    # The spec expects idempotent behavior - tasks/cancel always returns canceled state
-    if lg_status not in ("pending", "running"):
-        task_response = {
-            "kind": "task",
-            "id": task_id_raw,
-            "contextId": context_id,
-            "status": {
-                "state": "TASK_STATE_CANCELED",
-                "message": {
-                    "kind": "message",
-                    "role": "ROLE_AGENT",
-                    "parts": [
-                        {
-                            "kind": "text",
-                            "text": f"Task cancel acknowledged (was: {lg_status})",
-                        }
-                    ],
-                    "messageId": str(uuid.uuid4()),
-                    "taskId": task_id_raw,
-                },
-            },
+    if task.state in _TERMINAL_TASK_STATES:
+        return {
+            "error": {
+                "code": ERROR_CODE_TASK_NOT_CANCELABLE,
+                "message": "Task is not cancelable in its current state",
+            }
         }
-        return {"result": task_response}
 
-    # Cancel the run
+    marker_run_id: str | None = None
     try:
-        await client.runs.cancel(
-            thread_id=context_id,
-            run_id=run_id,
-            wait=True,  # Wait for cancellation to complete
-            action="interrupt",
-            headers=request.headers,
-        )
+        run_id = str(task.run["run_id"])
+        if task.state == "TASK_STATE_INPUT_REQUIRED":
+            canonical_task_id = _task_id_for_run(task.context_id, task.run)
+            marker_a2a = {**_run_a2a_metadata(task.run), "task_id": canonical_task_id}
+            marker = await client.runs.create(
+                thread_id=task.context_id,
+                assistant_id=assistant_id,
+                metadata={"a2a": marker_a2a},
+                # Keep the marker pending until it is persisted as canceled below.
+                after_seconds=3600,
+                headers=request.headers,
+            )
+            marker_run_id = str(marker["run_id"])
+            await client.runs.cancel(
+                thread_id=task.context_id,
+                run_id=marker_run_id,
+                wait=True,
+                action="interrupt",
+                headers=request.headers,
+            )
+            await client.threads.update_state(
+                task.context_id,
+                None,
+                as_node="__end__",
+                headers=request.headers,
+            )
+        elif task.run.get("status") not in {"pending", "running"}:
+            return {
+                "error": {
+                    "code": ERROR_CODE_TASK_NOT_CANCELABLE,
+                    "message": "Task has no active run to cancel",
+                }
+            }
+        else:
+            await client.runs.cancel(
+                thread_id=task.context_id,
+                run_id=run_id,
+                wait=True,
+                action="interrupt",
+                headers=request.headers,
+            )
     except Exception as e:
-        await logger.aerror(f"Failed to cancel run {run_id}: {e!s}", exc_info=True)
+        if marker_run_id is not None:
+            try:
+                await client.runs.delete(
+                    task.context_id,
+                    marker_run_id,
+                    headers=request.headers,
+                )
+            except Exception:
+                logger.exception(
+                    "Failed to roll back A2A cancellation marker",
+                    task_id=task_id_raw,
+                    marker_run_id=marker_run_id,
+                )
+        await logger.aerror(
+            "Failed to cancel A2A task",
+            task_id=task_id_raw,
+            exc_info=True,
+        )
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
@@ -2281,9 +2540,10 @@ async def handle_tasks_cancel(
     task_response = {
         "kind": "task",
         "id": task_id_raw,
-        "contextId": context_id,
+        "contextId": task.context_id,
         "status": {
             "state": "TASK_STATE_CANCELED",
+            "timestamp": datetime.now(UTC).isoformat(),
             "message": {
                 "kind": "message",
                 "role": "ROLE_AGENT",
@@ -2297,21 +2557,8 @@ async def handle_tasks_cancel(
     return {"result": task_response}
 
 
-def _lg_status_to_a2a_state(lg_status: str) -> str:
-    """Map a LangGraph run status to an A2A task state."""
-    mapping = {
-        "pending": "TASK_STATE_SUBMITTED",
-        "running": "TASK_STATE_WORKING",
-        "success": "TASK_STATE_COMPLETED",
-        "interrupted": "TASK_STATE_INPUT_REQUIRED",
-        "error": "TASK_STATE_FAILED",
-        "timeout": "TASK_STATE_FAILED",
-    }
-    return mapping.get(lg_status, "TASK_STATE_SUBMITTED")
-
-
 async def handle_list_tasks(
-    request: ApiRequest, params: dict[str, Any]
+    request: ApiRequest, params: dict[str, Any], assistant_id: str
 ) -> dict[str, Any]:
     """Handle ListTasks requests to list tasks with filtering and pagination.
 
@@ -2413,43 +2660,84 @@ async def handle_list_tasks(
 
     include_artifacts = params.get("includeArtifacts", False)
     context_id = params.get("contextId")
+    if context_id is not None and not isinstance(context_id, str):
+        return {
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": "contextId must be a string.",
+            }
+        }
 
     client = _client()
 
     try:
         # Determine which threads to search
-        if context_id:
-            thread_ids = [context_id]
+        if context_id is not None:
+            try:
+                thread = await client.threads.get(context_id, headers=request.headers)
+            except Exception as exc:
+                if _http_status_code(exc) not in {400, 404, 422}:
+                    raise
+                threads = []
+            else:
+                threads = [thread]
         else:
             threads = await client.threads.search(
-                limit=1000,
+                limit=_A2A_CONTEXT_SEARCH_LIMIT,
                 headers=request.headers,
             )
-            thread_ids = [t["thread_id"] for t in threads]
 
-        # Collect all runs from matching threads
-        all_tasks: list[dict[str, Any]] = []
+        # ponytail: runs are thread-scoped; bounded fan-out is the smallest safe
+        # option until the core API supports bulk run searches across threads.
+        semaphore = asyncio.Semaphore(_A2A_LIST_CONCURRENCY)
+
+        async def list_thread_runs(thread: dict[str, Any]) -> list[dict[str, Any]]:
+            tid = str(thread["thread_id"])
+            async with semaphore:
+                try:
+                    return await _list_context_runs(
+                        client, context_id=tid, headers=request.headers
+                    )
+                except Exception as exc:
+                    if _http_status_code(exc) in {401, 403}:
+                        raise
+                    await logger.awarning(
+                        "Failed to list runs for A2A context",
+                        context_id=tid,
+                        exc_info=True,
+                    )
+                    return []
+
+        runs_by_thread = await asyncio.gather(
+            *(list_thread_runs(thread) for thread in threads)
+        )
+
+        # Collect all tasks from matching threads.
+        tasks_by_id: dict[str, dict[str, Any]] = {}
+        seen_task_ids: set[str] = set()
         a2ui_by_task_id: dict[str, A2UIContext] = {}
-        for tid in thread_ids:
-            try:
-                runs = await client.runs.list(
-                    tid,
-                    limit=100,
-                    headers=request.headers,
+        run_id_by_task_id: dict[str, str] = {}
+        task_ids_by_start_id_by_context: dict[str, dict[str, str]] = {}
+        for thread, runs in zip(threads, runs_by_thread, strict=True):
+            tid = str(thread["thread_id"])
+            context_latest_run_id = _latest_run_id(runs)
+            task_ids_by_start_id_by_context[tid] = _task_ids_by_start_id(
+                runs, tid, assistant_id
+            )
+            for run in _runs_for_assistant(runs, assistant_id):
+                task_id = _task_id_for_run(tid, run)
+                if task_id in seen_task_ids:
+                    continue
+                seen_task_ids.add(task_id)
+                a2a_state = _task_state_for_run(
+                    run,
+                    thread if str(run.get("run_id")) == context_latest_run_id else None,
                 )
-            except Exception:
-                continue
-
-            for run in runs:
-                task_id = _make_task_id(tid, run["run_id"])
-                a2a_state = _lg_status_to_a2a_state(run.get("status", "unknown"))
 
                 if status_filter and a2a_state != status_filter:
                     continue
 
-                timestamp = run.get("updated_at") or run.get("created_at") or ""
-                if hasattr(timestamp, "isoformat"):
-                    timestamp = timestamp.isoformat()
+                timestamp = _run_timestamp(run)
 
                 if status_timestamp_after and timestamp:
                     try:
@@ -2471,10 +2759,12 @@ async def handle_list_tasks(
                 if not include_artifacts:
                     task["artifacts"] = []
 
-                all_tasks.append(task)
+                tasks_by_id[task_id] = task
                 a2ui_by_task_id[task_id] = _a2ui_context_for_run(run)
+                run_id_by_task_id[task_id] = str(run["run_id"])
 
         # Sort by timestamp descending (newest first)
+        all_tasks = list(tasks_by_id.values())
         all_tasks.sort(
             key=lambda t: t["status"].get("timestamp", ""),
             reverse=True,
@@ -2487,9 +2777,10 @@ async def handle_list_tasks(
         if history_length != 0:
 
             async def populate_history(task: dict[str, Any]) -> None:
-                _, run_id = _parse_task_id(task["id"])
                 messages = await _get_historical_messages_for_task(
-                    task["contextId"], run_id, request.headers
+                    task["contextId"],
+                    run_id_by_task_id[task["id"]],
+                    request.headers,
                 )
                 task["history"] = _convert_messages_to_a2a_format(
                     messages,
@@ -2497,6 +2788,9 @@ async def handle_list_tasks(
                     task["contextId"],
                     history_length=history_length,
                     a2ui=a2ui_by_task_id[task["id"]],
+                    task_ids_by_start_id=task_ids_by_start_id_by_context.get(
+                        task["contextId"]
+                    ),
                 )
 
             await asyncio.gather(*(populate_history(task) for task in page_tasks))
@@ -2908,6 +3202,80 @@ async def handle_message_stream(
                 )
                 return
 
+            context_id_from_message = message.get("contextId")
+            existing_task_id = message.get("taskId")
+            if context_id_from_message is not None and not isinstance(
+                context_id_from_message, str
+            ):
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_INVALID_PARAMS,
+                            "message": "contextId must be a string",
+                        },
+                    },
+                )
+                return
+            if existing_task_id is not None and not isinstance(existing_task_id, str):
+                yield (
+                    b"message",
+                    {
+                        "jsonrpc": "2.0",
+                        "id": rpc_id,
+                        "error": {
+                            "code": ERROR_CODE_INVALID_PARAMS,
+                            "message": "taskId must be a string",
+                        },
+                    },
+                )
+                return
+
+            is_new_task = existing_task_id is None
+            if existing_task_id is None:
+                context_id = context_id_from_message or str(uuid.uuid4())
+                task_id = None
+                task_start_id = str(uuid7())
+            else:
+                task = await _resolve_task(
+                    client,
+                    task_id=existing_task_id,
+                    context_id=context_id_from_message,
+                    assistant_id=assistant_id,
+                    headers=request.headers,
+                )
+                if task is None:
+                    yield (
+                        b"message",
+                        {
+                            "jsonrpc": "2.0",
+                            "id": rpc_id,
+                            "error": {
+                                "code": ERROR_CODE_TASK_NOT_FOUND,
+                                "message": f"Task not found: {existing_task_id}",
+                            },
+                        },
+                    )
+                    return
+                if task.state in _TERMINAL_TASK_STATES:
+                    yield (
+                        b"message",
+                        {
+                            "jsonrpc": "2.0",
+                            "id": rpc_id,
+                            "error": {
+                                "code": ERROR_CODE_UNSUPPORTED_OPERATION,
+                                "message": "A terminal task cannot accept another message",
+                            },
+                        },
+                    )
+                    return
+                context_id = task.context_id
+                task_id = task.task_id
+                task_start_id = None
+
             # Process A2A message parts into LangChain messages format
             try:
                 a2ui = _a2ui_message_context(message, assistant)
@@ -2917,6 +3285,8 @@ async def handle_message_stream(
                     message_role,
                     message_id,
                     a2ui=a2ui,
+                    task_id=task_id,
+                    task_start_id=task_start_id,
                 )
             except A2UIValidationError as e:
                 yield (
@@ -2945,10 +3315,6 @@ async def handle_message_stream(
                 )
                 return
 
-            # Check if this is a continuation (taskId provided in message)
-            existing_task_id = message.get("taskId")
-            context_id_from_message = message.get("contextId")
-
             # Extract and validate command (LangGraph extension for resuming interrupts)
             command, command_error = _extract_and_validate_command(
                 message, context_id_from_message
@@ -2988,7 +3354,9 @@ async def handle_message_stream(
                 ) = await _maybe_promote_resume_to_command(
                     client=client,
                     parts=parts,
-                    context_id=context_id_from_message,
+                    context_id=(
+                        context_id if existing_task_id else context_id_from_message
+                    ),
                     task_id=existing_task_id,
                     input_content=input_content,
                     headers=request.headers,
@@ -3010,10 +3378,6 @@ async def handle_message_stream(
                     task_id=existing_task_id,
                 )
 
-            if context_id_from_message is None:
-                context_id_from_message = str(uuid.uuid4())
-            context_id = context_id_from_message
-
             stream = client.runs.stream(
                 thread_id=context_id,
                 assistant_id=assistant_id,
@@ -3022,7 +3386,12 @@ async def handle_message_stream(
                 input=input_content,
                 command=command,
                 context=run_context,
-                metadata=_a2ui_run_metadata(assistant, a2ui),
+                metadata=_a2a_run_metadata(
+                    assistant,
+                    a2ui,
+                    task_id=task_id,
+                    task_start_id=task_start_id,
+                ),
                 headers=request.headers,
             )
 
@@ -3031,9 +3400,15 @@ async def handle_message_stream(
             run_id = run_event.data.get("run_id")
             if not run_id:
                 raise ValueError("Stream did not include run_id")
+            run = await client.runs.get(
+                thread_id=context_id,
+                run_id=str(run_id),
+                headers=request.headers,
+            )
+            context_id = str(run["thread_id"])
+            if is_new_task:
+                task_id = _make_task_id(context_id, str(run_id))
 
-            # If continuing an existing task, preserve the original task_id
-            task_id = existing_task_id or _make_task_id(context_id, run_id)
             # Emit initial Task object to establish task context
             initial_task = {
                 "kind": "task",

langgraph_api/errors.py

@@ -59,7 +59,7 @@ async def remote_exception_handler(request, exc: RemoteException):
 async def overloaded_error_handler(request, exc: ValueError):
     logger.exception("Overloaded Error", exc_info=exc)
     return await http_exception_handler(
-        request, HTTPException(status_code=503, detail=str(exc))
+        request, HTTPException(status_code=503, detail="Service Unavailable")
     )
 
 

langgraph_api/event_streaming/service.py

@@ -97,6 +97,25 @@ def validate_checkpoint_id_from_runnable_config(params: dict[str, Any]) -> str |
     return None
 
 
+def _langsmith_tracer_from_run_start(
+    params: dict[str, Any],
+) -> dict[str, str] | None:
+    tracer = params.get("langsmith_tracer")
+    if tracer is None:
+        return None
+    if not _is_record(tracer):
+        raise ValueError("langsmith_tracer must be an object.")
+    unknown = tracer.keys() - {"project_name", "example_id"}
+    if unknown:
+        raise ValueError(
+            f"langsmith_tracer has unsupported fields: {sorted(unknown)!r}."
+        )
+    for key, value in tracer.items():
+        if not isinstance(value, str):
+            raise ValueError(f"langsmith_tracer.{key} must be a string.")
+    return dict(tracer)
+
+
 # Concurrency strategies accepted on ``run.start`` — the four values the
 # SDK's ``multitaskStrategy`` option can take, derived from the canonical
 # ``MultitaskStrategy`` literal so the two never drift.
@@ -481,6 +500,10 @@ class ThreadRunManager:
         checkpoint_error = validate_checkpoint_id_from_runnable_config(params)
         if checkpoint_error is not None:
             return self._error(command.get("id"), "invalid_argument", checkpoint_error)
+        try:
+            _langsmith_tracer_from_run_start(params)
+        except ValueError as exc:
+            return self._error(command.get("id"), "invalid_argument", str(exc))
 
         try:
             run = await self._create_or_resume_run(assistant_id, params)
@@ -818,7 +841,7 @@ class ThreadRunManager:
             # every run.start), falling back to ``enqueue`` — the legacy
             # stream-endpoint default — when omitted.
             "multitask_strategy": _multitask_strategy_from_run_start(params),
-            "langsmith_tracer": None,
+            "langsmith_tracer": _langsmith_tracer_from_run_start(params),
             "durability": None,
         }
 

{langgraph_api-0.15.0.dev3.dist-info → langgraph_api-0.15.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.15.0.dev3
+Version: 0.15.0.dev4
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

{langgraph_api-0.15.0.dev3.dist-info → langgraph_api-0.15.0.dev4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=nLH816pG3rd8Cu_3NqfysMzBE2nKGNJZWU9-2nJiNfQ,28
+langgraph_api/__init__.py,sha256=xEaLs9f0npDZ1G1mIIH6E14MywcdoOYvZTm8637A30U,28
 langgraph_api/_factory_utils.py,sha256=_FqW0olMu2PGLsnRq0ylt3a4jDCe12YIFHExMXI6Nyo,5976
 langgraph_api/asgi_transport.py,sha256=XApY3lIWBZTMbbsl8dDJzl0cLGirmAGE0SifqZUnXvs,11896
 langgraph_api/asyncio.py,sha256=smqyAoO9nIyPPQRw1IVSCh85fwoZP4PEo-5dDhxGruc,10676
@@ -7,7 +7,7 @@ langgraph_api/cache.py,sha256=LuB3Te0UdXC8a-uEJoRHoe5XsgXulXI59f_Q6DCJNKc,13005
 langgraph_api/cli.py,sha256=ATtS9s9Cx7QNiGPJceKnMCko29A25ZA-xz39fdxmgfg,22389
 langgraph_api/command.py,sha256=d-k8h6H4ix1n7fSZ-Zb01NbSkEyqrD6cMKfDFXEIYEw,821
 langgraph_api/cron_scheduler.py,sha256=dALZwrDn8H3TJFB8S9GzmXiOuGz8_0aUbrXQU38UwZw,6116
-langgraph_api/errors.py,sha256=zlMW99wAzNkz2xfik-HMkl_wMqmRFvs1j8V-_DZbAUc,2553
+langgraph_api/errors.py,sha256=i1sO67io5Ffe0T2wlX9s8R1byhf0ZsU5eFX3Pjt2cHU,2566
 langgraph_api/feature_flags.py,sha256=nPZGxT_alHytycYvOxNi6bp09xUnMpWiHa8LtGmFsO4,2481
 langgraph_api/graph.py,sha256=ryFwplv0ztnc5g4Sg794GW8xZm2u936uI61fROgU8nQ,38514
 langgraph_api/http.py,sha256=7hPxKbj-xoAKcm7iucBpT5nM_hXOgGVCPbBsCD693Cw,6977
@@ -41,7 +41,7 @@ langgraph_api/_checkpointer/__init__.py,sha256=ofJTJLGy7Hsuzhj-2dpfDvrDloM0BzlhT
 langgraph_api/_checkpointer/_adapter.py,sha256=idGYL-FwyVtUXcmhvfYboARfQAkoj0aFD40L5h9N7F8,22289
 langgraph_api/_checkpointer/protocol.py,sha256=udgYKMNtKWG_eLDwYkHXV3b2bZLZg8Rsfm3fjkhU-rU,3635
 langgraph_api/api/__init__.py,sha256=88elgNmz6Y1tIi81dzhHa94KVhLvvIqyEJjcov4aH5U,9463
-langgraph_api/api/a2a.py,sha256=rvKX9yNM1PC2Zj1zlD6b7agnPX5fq9ylcK4kSPh9gCw,123643
+langgraph_api/api/a2a.py,sha256=l7I6yn_QrrITnUH5-b5MxK663ZjbciRqbk8nMHzFmKU,137203
 langgraph_api/api/a2ui.py,sha256=rgYWyTYbsBCH9KqRdRzj1T7NhhFVZ_JRlcfR74IyYKo,2952
 langgraph_api/api/assistants.py,sha256=rwaS3_Sy2nqf_2aIuG5XDvhw0GNWmT1-WIsESMuz1x0,21719
 langgraph_api/api/event_streaming.py,sha256=jvoBp5qHI92JJHsx4f9LEpb0i0VE31G_qFhS5JQWtlA,17809
@@ -86,7 +86,7 @@ langgraph_api/event_streaming/capabilities.py,sha256=qjVbhCjl1VEQPGeiDxeJAhYGI_7
 langgraph_api/event_streaming/constants.py,sha256=eGsm-NvOlqV3gNxDO5vlr00FdngmgEQf59zuHSi_74E,1378
 langgraph_api/event_streaming/event_normalizers.py,sha256=5bVSqGPW-Uh7WX91qgTfwpK433pCSv_wchpbzW8TLi4,2794
 langgraph_api/event_streaming/namespace.py,sha256=aJDFt45Or2_bQdRpKJgdFhBgTDj6PYl7Coz5GzfbM84,1509
-langgraph_api/event_streaming/service.py,sha256=vn0l1Urly4kkFIhHmCWWM2zCu-of9m9wOIq1kPdbJJA,50504
+langgraph_api/event_streaming/service.py,sha256=xraIeJjLBcKkdYw6H10yuR8M8LqB5kC0Xjgq8xmNogw,51363
 langgraph_api/event_streaming/session.py,sha256=8kx5nxJvJlfIu5fFzQCxEl-8UBJEtxftBLhCYgXMNwo,75947
 langgraph_api/event_streaming/state_normalizers.py,sha256=vgT4O4tJPr9VDBMn1EP994ieDGDYP43sROnOyLjkEAE,13659
 langgraph_api/event_streaming/types.py,sha256=RyZqfqgH-jmmmmAFQj5f6nH9M1rGK93zVG7nlmvqZgc,3647
@@ -244,8 +244,8 @@ langgraph_grpc_common/proto/store_pb2.py,sha256=JKcuJK0YUC1BSwLUZJWHCQ7AWkzVS9Kf
 langgraph_grpc_common/proto/store_pb2.pyi,sha256=ItSuXbA2X9bQlHtuEjDGi0fT_gJj2b0sr7XuQkybe3s,28983
 langgraph_grpc_common/proto/store_pb2_grpc.py,sha256=Kyt8eV2NXkjh3be_BYytGdD19kNf74961cruonMvCrw,3300
 langgraph_grpc_common/proto/store_pb2_grpc.pyi,sha256=oS1h2cDoq2OjyM8xazcmc8LwRDC5oCAD0zto2QUmPQw,2027
-langgraph_api-0.15.0.dev3.dist-info/METADATA,sha256=psnch_n-wl5jpxPICdPx33XTY1R_YmZE8xOmGdY_BIE,4630
-langgraph_api-0.15.0.dev3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-langgraph_api-0.15.0.dev3.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.15.0.dev3.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.15.0.dev3.dist-info/RECORD,,
+langgraph_api-0.15.0.dev4.dist-info/METADATA,sha256=ou5TufTIWr9twyRuUdpwBmLf2MWsvP3e4vWSMw2qSH4,4630
+langgraph_api-0.15.0.dev4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+langgraph_api-0.15.0.dev4.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.15.0.dev4.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.15.0.dev4.dist-info/RECORD,,