langgraph-api 0.16.0.dev11__py3-none-any.whl → 0.16.0.dev12__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.16.0.dev11"
+__version__ = "0.16.0.dev12"

langgraph_api/api/a2a.py

@@ -18,7 +18,7 @@ import os
 import uuid
 from dataclasses import dataclass, replace
 from datetime import UTC, datetime
-from typing import Any, Literal, NotRequired, cast
+from typing import Any, Literal, NotRequired, Self, cast
 
 import orjson
 import structlog
@@ -37,7 +37,11 @@ from langgraph_api.api.a2ui import (
     validate_client_metadata,
     validate_payload,
 )
-from langgraph_api.config import A2A_ALLOWED_TOOL_CALL_RESULTS
+from langgraph_api.config import (
+    A2A_A2UI_ENABLED,
+    A2A_A2UI_TOOL_CALL_RESULTS,
+    A2A_ALLOWED_TOOL_CALL_RESULTS,
+)
 from langgraph_api.metadata import USER_API_URL
 from langgraph_api.route import ApiRequest, ApiRoute
 from langgraph_api.schema import RunCommand
@@ -52,7 +56,6 @@ logger = structlog.stdlib.get_logger(__name__)
 _assistant_schemas_cache = LRUCache[dict[str, Any]](max_size=1000, ttl=60)
 
 MAX_HISTORY_LENGTH_REQUESTED = 10
-LANGGRAPH_HISTORY_QUERY_LIMIT = 500
 HISTORY_SCOPE_EXTENSION_URI = "https://langchain.com/a2a/extensions/history-scope/v1"
 HISTORY_SCOPE_HEADER = "LangGraph-A2A-History-Scope"
 A2A_EXTENSIONS_HEADER = "A2A-Extensions"
@@ -127,6 +130,45 @@ class A2UIContext:
     drop_invalid: bool = False
     mime_type: str = A2UI_MIME_TYPE
 
+    @property
+    def negotiated(self) -> bool:
+        return self.enabled and self.active
+
+    def part_for(
+        self,
+        data: object,
+        metadata: dict[str, Any],
+        *,
+        direction: Literal["client", "server"],
+    ) -> dict[str, Any] | None:
+        if not self.negotiated:
+            return None
+        try:
+            validate_payload(data, direction=direction)
+        except A2UIValidationError:
+            if not self.drop_invalid:
+                raise
+            logger.warning("Dropping invalid A2UI payload", direction=direction)
+            return None
+        return {
+            "kind": "data",
+            "data": data,
+            "metadata": normalize_metadata(metadata, mime_type=self.mime_type),
+        }
+
+    def parts_per_message(
+        self,
+        data: object,
+        metadata: dict[str, Any],
+        *,
+        direction: Literal["client", "server"],
+    ) -> list[dict[str, Any]]:
+        part = self.part_for(data, metadata, direction=direction)
+        if part is None:
+            return []
+        messages = part["data"] if isinstance(part["data"], list) else [part["data"]]
+        return [{**part, "data": message} for message in messages]
+
 
 _A2UI_DISABLED_CONTEXT = A2UIContext(False, False, {}, [])
 
@@ -141,6 +183,59 @@ class A2ATask:
     task_ids_by_start_id: dict[str, str]
 
 
+@dataclass(frozen=True)
+class RunMessages:
+    messages: list[Any]
+    added_from: int | None
+
+    @classmethod
+    def between(cls, before: list[Any], messages: list[Any]) -> Self:
+        if messages[: len(before)] == before:
+            return cls(messages, len(before))
+        before_ids = {
+            message.get("id") for message in before if isinstance(message, dict)
+        }
+        if len(before_ids) != len(before) or None in before_ids:
+            return cls(messages, None)
+        last_kept = max(
+            (
+                index
+                for index, message in enumerate(messages)
+                if isinstance(message, dict) and message.get("id") in before_ids
+            ),
+            default=-1,
+        )
+        return cls(messages, last_kept + 1)
+
+    @property
+    def added(self) -> list[Any] | None:
+        return None if self.added_from is None else self.messages[self.added_from :]
+
+    def stamped(self, task_id: str) -> list[Any]:
+        if self.added_from is None or self.added_from >= len(self.messages):
+            return self.messages
+        message = self.messages[self.added_from]
+        if not isinstance(message, dict):
+            return self.messages
+        additional_kwargs = message.get("additional_kwargs")
+        additional_kwargs = (
+            dict(additional_kwargs) if isinstance(additional_kwargs, dict) else {}
+        )
+        stored_a2a = additional_kwargs.get("a2a")
+        stored_a2a = dict(stored_a2a) if isinstance(stored_a2a, dict) else {}
+        if stored_a2a.get("task_id") or stored_a2a.get("task_start_id"):
+            return self.messages
+        messages = list(self.messages)
+        messages[self.added_from] = {
+            **message,
+            "additional_kwargs": {
+                **additional_kwargs,
+                "a2a": {**stored_a2a, "task_id": task_id},
+            },
+        }
+        return messages
+
+
 # Keep each core search rate-limit charge bounded.
 _A2A_CONTEXT_SEARCH_LIMIT = 1000
 _A2A_RUN_SCAN_LIMIT = 1000
@@ -158,18 +253,17 @@ _TERMINAL_TASK_STATES = frozenset(
 def _a2ui_enabled(assistant: dict[str, Any]) -> bool:
     metadata = assistant.get("metadata")
     a2a_metadata = metadata.get("a2a") if isinstance(metadata, dict) else None
-    return isinstance(a2a_metadata, dict) and a2a_metadata.get("a2ui") is True
+    override = a2a_metadata.get("a2ui") if isinstance(a2a_metadata, dict) else None
+    return override if isinstance(override, bool) else A2A_A2UI_ENABLED
 
 
-def _a2ui_context_for_run(
-    run: dict[str, Any], *, enabled: bool | None = None
-) -> A2UIContext:
+def _a2ui_context_for_run(run: dict[str, Any]) -> A2UIContext:
     metadata = run.get("metadata")
     a2a_metadata = metadata.get("a2a") if isinstance(metadata, dict) else None
     if not isinstance(a2a_metadata, dict):
         a2a_metadata = {}
     return A2UIContext(
-        enabled=a2a_metadata.get("a2ui") is True if enabled is None else enabled,
+        enabled=a2a_metadata.get("a2ui") is True,
         active=a2a_metadata.get("a2ui_active") is True,
         metadata={},
         extensions=[],
@@ -204,12 +298,10 @@ def _a2a_run_metadata(
             **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 {}),
             **(
-                {"a2ui_mime_type": context.mime_type}
-                if context.enabled and context.active
-                else {}
+                {"a2ui": True, "a2ui_active": context.active} if context.enabled else {}
             ),
+            **({"a2ui_mime_type": context.mime_type} if context.negotiated else {}),
         }
     }
 
@@ -1090,8 +1182,6 @@ def _content_to_a2a_parts(
     a2ui: A2UIContext,
     a2ui_direction: Literal["client", "server"] = "server",
 ) -> list[dict[str, Any]]:
-    """Convert public LangChain message content to ordered A2A parts."""
-
     if isinstance(content, str):
         return [{"kind": "text", "text": content}]
     if content is None:
@@ -1120,33 +1210,10 @@ def _content_to_a2a_parts(
             )
             if not is_a2ui_mime_type(metadata.get("mimeType")):
                 continue
-            if not a2ui.enabled:
-                if a2ui.drop_invalid:
-                    continue
-                raise A2UIValidationError(
-                    "Agent emitted A2UI while the extension was disabled"
-                )
-            if not a2ui.active:
-                continue
-            data = block.get("data")
-            try:
-                validate_payload(data, direction=a2ui_direction)
-            except A2UIValidationError:
-                if not a2ui.drop_invalid:
-                    raise
-                logger.warning(
-                    "Dropping invalid A2UI block from task history",
-                    direction=a2ui_direction,
-                )
-                continue
-            flush_text()
-            parts.append(
-                {
-                    "kind": "data",
-                    "data": data,
-                    "metadata": normalize_metadata(metadata, mime_type=a2ui.mime_type),
-                }
-            )
+            part = a2ui.part_for(block.get("data"), metadata, direction=a2ui_direction)
+            if part is not None:
+                flush_text()
+                parts.append(part)
         elif (
             isinstance(block, dict) and block.get("type") in _MEDIA_CONTENT_BLOCK_TYPES
         ):
@@ -1187,46 +1254,45 @@ def _content_to_text(content: Any) -> str:
     return str(content)
 
 
-def _extract_a2a_response(
-    result: dict[str, Any], *, a2ui: A2UIContext
-) -> list[dict[str, Any]]:
-    """Extract public A2A parts from the last assistant response.
+def _current_turn(messages: list[object]) -> list[object]:
+    for index in range(len(messages) - 1, -1, -1):
+        message = messages[index]
+        if isinstance(message, dict) and _a2a_role_for_message(message) == "ROLE_USER":
+            return messages[index + 1 :]
+    return messages
 
-    Args:
-        result: Graph execution result
-
-    Returns:
-        Ordered public parts from the last assistant message
 
-    Raises:
-        ValueError: If result doesn't contain messages or is invalid
-    """
+def _extract_a2a_response(
+    result: dict[str, Any],
+    *,
+    a2ui: A2UIContext,
+    turn: list[object] | None = None,
+) -> list[dict[str, Any]]:
     if "__error__" in result:
-        # Let the caller handle errors
         return [{"kind": "text", "text": str(result)}]
 
     if "messages" not in result:
-        # Fallback to the full result if no messages schema. It is not optimal to do A2A on assistants without
-        # a messages key, but it is not a hard requirement.
         return [{"kind": "text", "text": str(result)}]
 
     messages = result["messages"]
     if not isinstance(messages, list) or not messages:
         return [{"kind": "text", "text": str(result)}]
 
-    # Find the last assistant message
-    for message in reversed(messages):
-        if not isinstance(message, dict):
-            continue
-        if _a2a_role_for_message(message) == "ROLE_AGENT" and "content" in message:
-            parts = _content_to_a2a_parts(
-                message["content"],
-                a2ui=a2ui,
-            )
-            if _a2a_parts_have_content(parts):
-                return parts
+    turn = _current_turn(messages) if turn is None else turn
+    tool_ui = [
+        part for message in turn for part in _tool_result_a2ui_parts(message, a2ui)
+    ]
+    for message in reversed(turn):
+        if (
+            isinstance(message, dict)
+            and _a2a_role_for_message(message) == "ROLE_AGENT"
+            and "content" in message
+        ):
+            reply = _content_to_a2a_parts(message["content"], a2ui=a2ui)
+            if _a2a_parts_have_content(reply):
+                return [*reply, *tool_ui]
 
-    return [{"kind": "text", "text": ""}]
+    return tool_ui or [{"kind": "text", "text": ""}]
 
 
 def _create_interrupt_artifact(interrupts: list[dict[str, Any]]) -> dict[str, Any]:
@@ -1296,19 +1362,14 @@ def _create_response_artifact_update(
     }
 
 
-def _tool_result_data(message: dict[str, Any]) -> dict[str, Any] | None:
-    """Build the published form of one tool result, or None if not publishable.
+def _tool_call_id(message: dict[str, Any]) -> str | None:
+    tool_call_id = message.get("tool_call_id")
+    return tool_call_id if isinstance(tool_call_id, str) and tool_call_id else None
 
-    A tool result is only published when it is correlated to the call that
-    produced it: ``tool_call_id`` is what lets a client match the payload back
-    to its request. Uncorrelated tool output stays internal.
 
-    Only the correlation id, content, tool name, and status are copied. Raw
-    LangChain internals (``response_metadata``, ``additional_kwargs``,
-    ``artifact``) are deliberately excluded.
-    """
-    tool_call_id = message.get("tool_call_id")
-    if not isinstance(tool_call_id, str) or not tool_call_id:
+def _tool_result_data(message: dict[str, Any]) -> dict[str, Any] | None:
+    tool_call_id = _tool_call_id(message)
+    if tool_call_id is None:
         return None
 
     if (
@@ -1334,6 +1395,26 @@ def _tool_results_data_part(tool_results: list[dict[str, Any]]) -> dict[str, Any
     return {"kind": "data", "data": {"tool_results": tool_results}}
 
 
+def _tool_result_a2ui_parts(message: object, a2ui: A2UIContext) -> list[dict[str, Any]]:
+    if (
+        not a2ui.negotiated
+        or not isinstance(message, dict)
+        or message.get("name") not in A2A_A2UI_TOOL_CALL_RESULTS
+        or message.get("status") == "error"
+        or _tool_call_id(message) is None
+    ):
+        return []
+    content = message.get("content")
+    try:
+        data = orjson.loads(content) if isinstance(content, str) else content
+    except orjson.JSONDecodeError:
+        logger.warning("Dropping non-JSON A2UI tool result", tool=message.get("name"))
+        return []
+    return replace(a2ui, drop_invalid=True).parts_per_message(
+        data, {"mimeType": a2ui.mime_type}, direction="server"
+    )
+
+
 def _lc_stream_items_to_a2a_message(
     items: list[dict[str, Any]],
     *,
@@ -1566,13 +1647,13 @@ def _convert_messages_to_a2a_format(
             a2a_role = _a2a_role_for_message(msg)
 
             if a2a_role is None:
-                # Internal message: publish a correlated tool result as data,
-                # drop system prompts and uncorrelated output entirely.
-                tool_result = _tool_result_data(msg)
-                if tool_result is None:
+                parts = []
+                if (tool_result := _tool_result_data(msg)) is not None:
+                    parts.append(_tool_results_data_part([tool_result]))
+                parts.extend(_tool_result_a2ui_parts(msg, history_a2ui))
+                if not parts:
                     continue
                 a2a_role = "ROLE_AGENT"
-                parts = [_tool_results_data_part([tool_result])]
             else:
                 parts = _content_to_a2a_parts(
                     msg.get("content", ""),
@@ -1614,21 +1695,8 @@ async def _create_task_response(
     history_length: int | None = None,
     history_scope: HistoryScope = "context",
     task_ids_by_start_id: dict[str, str] | None = None,
+    turn: list[object] | None = None,
 ) -> dict[str, Any]:
-    """Create A2A Task response structure for both success and failure cases.
-
-    Args:
-        task_id: The task/run ID
-        context_id: The context/thread ID
-        result: LangGraph execution result
-        assistant_id: The assistant ID used
-        history_length: Maximum public history messages to include.
-        history_scope: Whether to return the whole context or only this task.
-
-    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,
@@ -1678,10 +1746,7 @@ async def _create_task_response(
         }
         base_task["artifacts"] = [
             _create_response_artifact(
-                _extract_a2a_response(
-                    result,
-                    a2ui=a2ui,
-                ),
+                _extract_a2a_response(result, a2ui=a2ui, turn=turn),
                 assistant_id,
             )
         ]
@@ -2264,18 +2329,19 @@ async def handle_message_send(
             run_id=run["run_id"],
             headers=request.headers,
         )
-        if (
+        data_only_input = command is None and "messages" not in input_content
+        turn = None
+        if data_only_input or (
             history_scope == "task"
             and history_length != 0
             and "messages" not in input_content
         ):
-            result = dict(result)
-            result["messages"] = await _get_historical_messages_for_task(
-                context_id,
-                str(run["run_id"]),
-                request.headers,
-                task_id=task_id,
+            run_messages = await _load_run_messages(
+                context_id, str(run["run_id"]), request.headers
             )
+            result = {**result, "messages": run_messages.stamped(task_id)}
+            if data_only_input:
+                turn = run_messages.added
 
         return await _create_task_response(
             task_id=task_id,
@@ -2286,6 +2352,7 @@ async def handle_message_send(
             history_scope=history_scope,
             a2ui=a2ui,
             task_ids_by_start_id=task_ids_by_start_id,
+            turn=turn,
         )
 
     except InvalidAgentResponseError as e:
@@ -2305,6 +2372,29 @@ async def handle_message_send(
         }
 
 
+async def _latest_messages(
+    context_id: str, metadata: dict[str, str], headers: Headers
+) -> list[Any] | None:
+    history = await get_client().threads.get_history(
+        context_id, limit=1, metadata=metadata, headers=headers
+    )
+    return (history[0]["values"].get("messages") or []) if history else None
+
+
+async def _load_run_messages(
+    context_id: str, run_id: str, headers: Headers
+) -> RunMessages:
+    messages, before = await asyncio.gather(
+        _latest_messages(context_id, {"run_id": run_id}, headers),
+        _latest_messages(context_id, {"run_id": run_id, "source": "input"}, headers),
+    )
+    if messages is None:
+        return RunMessages([], None)
+    if before is None:
+        return RunMessages(messages, None)
+    return RunMessages.between(before, messages)
+
+
 async def _get_historical_messages_for_task(
     context_id: str,
     task_run_id: str,
@@ -2312,49 +2402,8 @@ async def _get_historical_messages_for_task(
     *,
     task_id: str,
 ) -> 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)
-        )
-        messages = target_checkpoint["values"].get("messages", []) or []
-        input_checkpoint = min(
-            history, key=lambda c: c.get("metadata", {}).get("step", 0)
-        )
-        input_messages = input_checkpoint["values"].get("messages", []) or []
-        new_message_index = len(input_messages)
-        if (
-            new_message_index < len(messages)
-            and messages[:new_message_index] == input_messages
-            and isinstance(messages[new_message_index], dict)
-        ):
-            message = messages[new_message_index]
-            additional_kwargs = message.get("additional_kwargs")
-            additional_kwargs = (
-                dict(additional_kwargs) if isinstance(additional_kwargs, dict) else {}
-            )
-            stored_a2a = additional_kwargs.get("a2a")
-            stored_a2a = dict(stored_a2a) if isinstance(stored_a2a, dict) else {}
-            if not stored_a2a.get("task_id") and not stored_a2a.get("task_start_id"):
-                messages = list(messages)
-                messages[new_message_index] = {
-                    **message,
-                    "additional_kwargs": {
-                        **additional_kwargs,
-                        "a2a": {**stored_a2a, "task_id": task_id},
-                    },
-                }
-        return messages
-    else:
-        return []
+    run_messages = await _load_run_messages(context_id, task_run_id, request_headers)
+    return run_messages.stamped(task_id)
 
 
 async def handle_tasks_get(
@@ -2437,8 +2486,6 @@ async def handle_tasks_get(
                 }
             }
 
-        assistant = await _get_assistant(assistant_id, request.headers)
-
         lg_status = run_info.get("status", "unknown")
         a2a_state = task.state
 
@@ -2455,9 +2502,7 @@ async def handle_tasks_get(
                     context_id,
                     history_length=history_length,
                     history_scope=history_scope,
-                    a2ui=_a2ui_context_for_run(
-                        run_info, enabled=_a2ui_enabled(assistant)
-                    ),
+                    a2ui=_a2ui_context_for_run(run_info),
                     task_ids_by_start_id=task.task_ids_by_start_id,
                 )
             except A2UIValidationError:
@@ -3587,6 +3632,14 @@ async def handle_message_stream(
                 {"jsonrpc": "2.0", "id": rpc_id, "result": {"task": initial_task}},
             )
 
+            async def data_only_turn() -> list[Any] | None:
+                if command is not None or "messages" in input_content:
+                    return None
+                run_messages = await _load_run_messages(
+                    context_id, str(run_id), request.headers
+                )
+                return run_messages.added
+
             result = None
             err = None
             notified_is_working = False
@@ -3602,10 +3655,10 @@ async def handle_message_stream(
                             # the completed and interrupt paths).
                             final_parts: list[dict[str, Any]] | None = None
                             if isinstance(result, dict):
+                                turn = await data_only_turn()
                                 try:
                                     final_parts = _extract_a2a_response(
-                                        result,
-                                        a2ui=a2ui,
+                                        result, a2ui=a2ui, turn=turn
                                     )
                                 except A2UIValidationError:
                                     await logger.aexception(
@@ -3827,11 +3880,9 @@ async def handle_message_stream(
             # and we actually captured a result; a degenerate empty exit keeps
             # its plain terminal status-update.
             if fallback_state == "TASK_STATE_COMPLETED" and isinstance(result, dict):
+                turn = await data_only_turn()
                 try:
-                    fallback_parts = _extract_a2a_response(
-                        result,
-                        a2ui=a2ui,
-                    )
+                    fallback_parts = _extract_a2a_response(result, a2ui=a2ui, turn=turn)
                 except A2UIValidationError:
                     await logger.aexception("Agent emitted an invalid A2UI payload")
                     yield (

langgraph_api/config/__init__.py

@@ -257,15 +257,19 @@ MCP_ENABLED = HTTP_CONFIG is None or not HTTP_CONFIG.get("disable_mcp")
 A2A_ENABLED = HTTP_CONFIG is None or not HTTP_CONFIG.get("disable_a2a")
 
 
-def _parse_allowed_tool_call_results(value: str) -> frozenset[str]:
+def _parse_tool_names(value: str) -> frozenset[str]:
     return frozenset(name.strip() for name in value.split(",") if name.strip())
 
 
 A2A_ALLOWED_TOOL_CALL_RESULTS = env(
     "A2A_ALLOWED_TOOL_CALL_RESULTS",
-    cast=_parse_allowed_tool_call_results,
+    cast=_parse_tool_names,
     default=None,
 )
+A2A_A2UI_ENABLED = env("A2A_A2UI_ENABLED", cast=bool, default=False)
+A2A_A2UI_TOOL_CALL_RESULTS = env(
+    "A2A_A2UI_TOOL_CALL_RESULTS", cast=_parse_tool_names, default=""
+)
 WEBHOOKS_ENABLED = HTTP_CONFIG and HTTP_CONFIG.get("disable_webhooks")
 # Not in public docs: populated by langgraph.json config, not set as env var directly
 STORE_CONFIG = env(

{langgraph_api-0.16.0.dev11.dist-info → langgraph_api-0.16.0.dev12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.16.0.dev11
+Version: 0.16.0.dev12
 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.16.0.dev11.dist-info → langgraph_api-0.16.0.dev12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=sQBkLkeFGX-kqfM2r9VRqEQnIrwyH9Qbgsi2fL1VmDA,29
+langgraph_api/__init__.py,sha256=2lKXoSHF6sBtjdWyMKs386Y_GD2v5ruqOtEBpbLZAjU,29
 langgraph_api/_factory_utils.py,sha256=_FqW0olMu2PGLsnRq0ylt3a4jDCe12YIFHExMXI6Nyo,5976
 langgraph_api/asgi_transport.py,sha256=XApY3lIWBZTMbbsl8dDJzl0cLGirmAGE0SifqZUnXvs,11896
 langgraph_api/asyncio.py,sha256=smqyAoO9nIyPPQRw1IVSCh85fwoZP4PEo-5dDhxGruc,10676
@@ -42,7 +42,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=HdHkqmA1pi49djy1Kfpqy96Gaxy1N9lBH_kwW0SEO2I,11134
-langgraph_api/api/a2a.py,sha256=0jCMN_BXXRYXJJIZfBkS4es9ilARbW5OIzM3rLvNvd4,143588
+langgraph_api/api/a2a.py,sha256=uI4VHJe2KnObUJxfoCwdRW7WrqqJEz5JxV8_i1-YA20,145136
 langgraph_api/api/a2ui.py,sha256=Dx9qwwIOmQ0MfgOwL-UZabBI0F7DEvz3qG1cFkjvnjE,3108
 langgraph_api/api/assistants.py,sha256=rwaS3_Sy2nqf_2aIuG5XDvhw0GNWmT1-WIsESMuz1x0,21719
 langgraph_api/api/event_streaming.py,sha256=jvoBp5qHI92JJHsx4f9LEpb0i0VE31G_qFhS5JQWtlA,17809
@@ -73,7 +73,7 @@ langgraph_api/auth/studio_user.py,sha256=Lx3eMsRA8gxZ3--ApL09hDW84A6qIncaZoBZjSg
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=gaSuZC8JO32XHe8IdqttNpBGO6PCVrtXaq1Negc7vX0,3857
 langgraph_api/auth/langsmith/client.py,sha256=79kwCVeHU64nsHsxWipfZhf44lM6vfs2nlfTxlJF6LU,4142
-langgraph_api/config/__init__.py,sha256=g5gRFH3gmEYxEAsK9cp-5ltjcHwWramT-IGF6WRoC0A,28663
+langgraph_api/config/__init__.py,sha256=irVLC0SYb9s0M5u9yKGCZkUBbLEz2uprfhQ_-AQjHQ8,28807
 langgraph_api/config/_parse.py,sha256=RpfZgFAPJlRMv13AzGr3kAYbIrqHcgjzO8IgeboTw4A,3922
 langgraph_api/config/schemas.py,sha256=Yi3SZ7uNLSncRe0SyFb0eVqWljDpap8csm9B_xH9IWE,21487
 langgraph_api/encryption/__init__.py,sha256=gaCZ00CocSbqSqrDn6XJHaSp2CZCnC8qnrD9G4fbzyI,363
@@ -252,8 +252,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.16.0.dev11.dist-info/METADATA,sha256=XMP4zFlG6KnYUwQ6wVojA_t7gEwhWMUXpJ0jqcRP4Bk,5880
-langgraph_api-0.16.0.dev11.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-langgraph_api-0.16.0.dev11.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.16.0.dev11.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.16.0.dev11.dist-info/RECORD,,
+langgraph_api-0.16.0.dev12.dist-info/METADATA,sha256=ecK57tTJQr6B4reHreWXSFoTCtJiThhl_ueqO3NkBxU,5880
+langgraph_api-0.16.0.dev12.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+langgraph_api-0.16.0.dev12.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.16.0.dev12.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.16.0.dev12.dist-info/RECORD,,