langgraph-api 0.13.0rc2__tar.gz → 0.14.0.dev2__tar.gz

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.13.0rc2
+Version: 0.14.0.dev2
 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
 Requires-Python: >=3.11
 Requires-Dist: cloudpickle>=3.0.0
-Requires-Dist: cryptography>=42.0.0
+Requires-Dist: cryptography>=50.0.0
 Requires-Dist: grpcio-health-checking<1.82.0,>=1.81.0
 Requires-Dist: grpcio-tools==1.81.1
 Requires-Dist: grpcio<1.82.0,>=1.81.0
@@ -16,7 +16,7 @@ Requires-Dist: jsonschema-rs<0.45,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langchain-protocol<0.1,>=0.0.18
 Requires-Dist: langgraph-checkpoint<5,>=3.0.1
-Requires-Dist: langgraph-runtime-inmem<0.34.0.dev0,>=0.33.0.dev0
+Requires-Dist: langgraph-runtime-inmem<0.35.0.dev0,>=0.34.0.dev0
 Requires-Dist: langgraph-sdk>=0.3.5
 Requires-Dist: langgraph<2,>=0.4.10
 Requires-Dist: langsmith[otel]>=0.6.3

langgraph_api-0.14.0.dev2/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.14.0.dev2"

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_api/api/a2a.py

@@ -11,6 +11,8 @@ Push notifications are not implemented.
 """
 
 import asyncio
+import base64
+import binascii
 import functools
 import os
 import uuid
@@ -92,6 +94,13 @@ ERROR_CODE_INVALID_AGENT_RESPONSE = -32006
 # ============================================================================
 
 A2A_PROTOCOL_VERSION = "1.0"
+_DEFAULT_A2A_INPUT_MODES = ("application/json", "text/plain")
+_DEFAULT_A2A_OUTPUT_MODES = ("application/json", "text/plain")
+
+
+class InvalidAgentResponseError(ValueError):
+    """Raised when public agent output cannot be represented as an A2A part."""
+
 
 # ============================================================================
 # Legacy (v0.x) format helpers
@@ -592,6 +601,7 @@ _AGENT_MESSAGE_TYPES = {"ai", "aimessage", "aimessagechunk"}
 _ROLE_DEFINED_MESSAGE_TYPES = {"chat", "chatmessage", "chatmessagechunk"}
 _USER_MESSAGE_ROLES = {"human", "user"}
 _AGENT_MESSAGE_ROLES = {"agent", "assistant"}
+_MEDIA_CONTENT_BLOCK_TYPES = {"audio", "file", "image", "video"}
 
 
 def _normalize_message_label(value: Any) -> str:
@@ -630,6 +640,117 @@ def _a2a_role_for_message(
     return type_role or role_role
 
 
+def _content_block_to_a2a_file_part(block: dict[str, Any]) -> dict[str, Any]:
+    """Convert one canonical LangChain media block to an A2A FilePart."""
+
+    source = next(
+        (key for key in ("base64", "data", "url") if block.get(key) is not None),
+        None,
+    )
+    if source is None:
+        raise InvalidAgentResponseError(
+            "Media content blocks must contain 'base64', 'data', or 'url'."
+        )
+
+    value = block[source]
+    file_obj: dict[str, Any] = {}
+    if source == "url":
+        if not isinstance(value, str) or not value:
+            raise InvalidAgentResponseError(
+                "Media content block 'url' must be a non-empty string."
+            )
+        file_obj["uri"] = value
+    else:
+        if source == "data" and isinstance(value, (bytes, bytearray)):
+            value = base64.b64encode(value).decode("ascii")
+        if not isinstance(value, str):
+            raise InvalidAgentResponseError(
+                f"Media content block '{source}' must be base64-encoded text or bytes."
+            )
+        compact_value = "".join(value.split())
+        padded_value = compact_value + ("=" * (-len(compact_value) % 4))
+        try:
+            decoded = base64.b64decode(
+                padded_value,
+                altchars=b"-_",
+                validate=True,
+            )
+        except (binascii.Error, ValueError) as e:
+            raise InvalidAgentResponseError(
+                f"Media content block '{source}' must contain valid base64 data."
+            ) from e
+        file_obj["bytes"] = base64.b64encode(decoded).decode("ascii")
+
+    mime_type = block.get("mime_type")
+    if mime_type is not None:
+        if not isinstance(mime_type, str):
+            raise InvalidAgentResponseError(
+                "Media content block 'mime_type' must be a string."
+            )
+        if mime_type:
+            file_obj["mimeType"] = mime_type
+
+    filename = block.get("filename")
+    if filename is None:
+        extras = block.get("extras")
+        if isinstance(extras, dict):
+            filename = extras.get("filename")
+    if filename is not None:
+        if not isinstance(filename, str):
+            raise InvalidAgentResponseError(
+                "Media content block filename must be a string."
+            )
+        if filename:
+            file_obj["name"] = filename
+
+    return {"kind": "file", "file": file_obj}
+
+
+def _content_to_a2a_parts(content: Any) -> 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:
+        return []
+    if not isinstance(content, list):
+        return [{"kind": "text", "text": str(content)}]
+
+    parts: list[dict[str, Any]] = []
+    text_parts: list[str] = []
+
+    def flush_text() -> None:
+        if text_parts:
+            parts.append({"kind": "text", "text": "".join(text_parts)})
+            text_parts.clear()
+
+    for block in content:
+        if isinstance(block, str):
+            text_parts.append(block)
+        elif isinstance(block, dict) and block.get("type") == "text":
+            text = block.get("text")
+            if isinstance(text, str):
+                text_parts.append(text)
+        elif (
+            isinstance(block, dict) and block.get("type") in _MEDIA_CONTENT_BLOCK_TYPES
+        ):
+            flush_text()
+            parts.append(_content_block_to_a2a_file_part(block))
+
+    flush_text()
+    return parts
+
+
+def _a2a_parts_have_content(parts: list[dict[str, Any]]) -> bool:
+    """Return whether converted parts contain public text or file content."""
+
+    return any(
+        part.get("kind") == "file"
+        or (part.get("kind") == "text" and bool(part.get("text")))
+        for part in parts
+    )
+
+
 def _content_to_text(content: Any) -> str:
     """Convert public LangChain message content to A2A text."""
 
@@ -650,41 +771,41 @@ def _content_to_text(content: Any) -> str:
     return str(content)
 
 
-def _extract_a2a_response(result: dict[str, Any]) -> str:
-    """Extract the last assistant message from graph execution result.
+def _extract_a2a_response(result: dict[str, Any]) -> list[dict[str, Any]]:
+    """Extract public A2A parts from the last assistant response.
 
     Args:
         result: Graph execution result
 
     Returns:
-        Content of the last assistant message
+        Ordered public parts from the last assistant message
 
     Raises:
         ValueError: If result doesn't contain messages or is invalid
     """
     if "__error__" in result:
         # Let the caller handle errors
-        return str(result)
+        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 str(result)
+        return [{"kind": "text", "text": str(result)}]
 
     messages = result["messages"]
     if not isinstance(messages, list) or not messages:
-        return str(result)
+        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:
-            text = _content_to_text(message["content"])
-            if text:
-                return text
+            parts = _content_to_a2a_parts(message["content"])
+            if _a2a_parts_have_content(parts):
+                return parts
 
-    return ""
+    return [{"kind": "text", "text": ""}]
 
 
 def _create_interrupt_artifact(interrupts: list[dict[str, Any]]) -> dict[str, Any]:
@@ -714,25 +835,27 @@ def _create_interrupt_artifact(interrupts: list[dict[str, Any]]) -> dict[str, An
     }
 
 
-def _create_response_artifact(text: str, assistant_id: str) -> dict[str, Any]:
-    """Create an A2A artifact carrying the agent's final response text.
+def _create_response_artifact(
+    parts: list[dict[str, Any]], assistant_id: str
+) -> dict[str, Any]:
+    """Create an A2A artifact carrying the agent's final response parts.
 
     Shared by ``message/send`` and ``message/stream`` so both paths return the
     same first-class Artifact shape. Per A2A spec section 3.7, task outputs
     SHOULD be returned via Artifacts rather than embedded in a status Message.
 
     Args:
-        text: The final response text (from ``_extract_a2a_response``).
+        parts: The final response parts (from ``_extract_a2a_response``).
         assistant_id: The assistant ID, used only for the description.
 
     Returns:
-        A2A artifact dict with a single text part.
+        A2A artifact dict containing the ordered public response parts.
     """
     return {
         "artifactId": str(uuid.uuid4()),
         "name": "Assistant Response",
         "description": f"Response from assistant {assistant_id}",
-        "parts": [{"kind": "text", "text": text}],
+        "parts": parts,
     }
 
 
@@ -740,7 +863,7 @@ def _create_response_artifact_update(
     *,
     task_id: str,
     context_id: str,
-    text: str,
+    parts: list[dict[str, Any]],
     assistant_id: str,
 ) -> dict[str, Any]:
     """Create a final streaming update containing the response artifact."""
@@ -749,7 +872,7 @@ def _create_response_artifact_update(
         "taskId": task_id,
         "contextId": context_id,
         "kind": "artifact-update",
-        "artifact": _create_response_artifact(text, assistant_id),
+        "artifact": _create_response_artifact(parts, assistant_id),
         "append": False,
         "lastChunk": True,
     }
@@ -985,14 +1108,16 @@ def _convert_messages_to_a2a_format(
 
             content = msg.get("content", "")
             id = msg.get("id") or str(uuid7())
-            text = _content_to_text(content)
-            if a2a_role == "ROLE_AGENT" and not text:
+            parts = _content_to_a2a_parts(content)
+            if a2a_role == "ROLE_AGENT" and not _a2a_parts_have_content(parts):
                 continue
+            if not parts:
+                parts = [{"kind": "text", "text": ""}]
 
             a2a_message = {
                 "kind": "message",
                 "role": a2a_role,
-                "parts": [{"kind": "text", "text": text}],
+                "parts": parts,
                 "messageId": id,
                 "taskId": task_id,
                 "contextId": context_id,
@@ -1556,6 +1681,13 @@ async def handle_message_send(
             history_length=history_length,
         )
 
+    except InvalidAgentResponseError as e:
+        return {
+            "error": {
+                "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                "message": str(e),
+            }
+        }
     except Exception:
         logger.exception(f"Error in message/send for assistant {assistant_id}")
         return {
@@ -1704,6 +1836,13 @@ async def handle_tasks_get(
                     context_id,
                     history_length=history_length,
                 )
+            except InvalidAgentResponseError as e:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                        "message": str(e),
+                    }
+                }
             except Exception as e:
                 await logger.aexception(
                     f"Failed to get thread state for tasks/get: {e}"
@@ -2106,6 +2245,13 @@ async def handle_list_tasks(
             }
         }
 
+    except InvalidAgentResponseError as e:
+        return {
+            "error": {
+                "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                "message": str(e),
+            }
+        }
     except Exception:
         logger.exception("Error in ListTasks")
         return {
@@ -2156,6 +2302,60 @@ async def handle_get_extended_card(
 # ============================================================================
 
 
+def _validate_agent_card_modes(
+    value: Any,
+    *,
+    field: str,
+    default: tuple[str, ...],
+) -> list[str]:
+    """Validate one optional assistant A2A media-mode override."""
+
+    if value is None:
+        return list(default)
+    if not isinstance(value, list) or not value:
+        raise ValueError(
+            f"Assistant metadata.a2a.{field} must be a non-empty array of strings."
+        )
+
+    modes: list[str] = []
+    for mode in value:
+        if not isinstance(mode, str) or not mode.strip():
+            raise ValueError(
+                f"Assistant metadata.a2a.{field} must be a non-empty array of strings."
+            )
+        modes.append(mode.strip())
+    return modes
+
+
+def _resolve_agent_card_modes(
+    assistant: dict[str, Any],
+) -> tuple[list[str], list[str]]:
+    """Resolve per-assistant A2A modes with backward-compatible defaults."""
+
+    metadata = assistant.get("metadata") or {}
+    if not isinstance(metadata, dict):
+        raise ValueError("Assistant metadata must be an object.")
+
+    a2a_metadata = metadata.get("a2a")
+    if a2a_metadata is None:
+        return list(_DEFAULT_A2A_INPUT_MODES), list(_DEFAULT_A2A_OUTPUT_MODES)
+    if not isinstance(a2a_metadata, dict):
+        raise ValueError("Assistant metadata.a2a must be an object.")
+
+    return (
+        _validate_agent_card_modes(
+            a2a_metadata.get("input_modes"),
+            field="input_modes",
+            default=_DEFAULT_A2A_INPUT_MODES,
+        ),
+        _validate_agent_card_modes(
+            a2a_metadata.get("output_modes"),
+            field="output_modes",
+            default=_DEFAULT_A2A_OUTPUT_MODES,
+        ),
+    )
+
+
 async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[str, Any]:
     """Generate A2A Agent Card for a specific assistant.
 
@@ -2183,6 +2383,7 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
     assistant_description = (
         assistant.get("description") or f"{assistant_name} assistant"
     )
+    input_modes, output_modes = _resolve_agent_card_modes(assistant)
 
     # For now, each assistant has one main skill - itself
     skills = [
@@ -2192,8 +2393,8 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
             "description": assistant_description,
             "tags": ["assistant", "langgraph"],
             "examples": [],
-            "inputModes": ["application/json", "text/plain"],
-            "outputModes": ["application/json", "text/plain"],
+            "inputModes": input_modes,
+            "outputModes": output_modes,
             "metadata": {
                 "inputSchema": {
                     "required": required,
@@ -2242,8 +2443,8 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
             "pushNotifications": False,  # Not implemented yet
             "stateTransitionHistory": False,
         },
-        "defaultInputModes": ["application/json", "text/plain"],
-        "defaultOutputModes": ["application/json", "text/plain"],
+        "defaultInputModes": input_modes,
+        "defaultOutputModes": output_modes,
         "skills": skills,
         "version": __version__,
     }
@@ -2558,19 +2759,32 @@ async def handle_message_stream(
                             is_interrupt = (
                                 isinstance(result, dict) and "__interrupt__" in result
                             )
-                            # Extract the final response text (shared by both
+                            # Extract the final response parts (shared by both
                             # the completed and interrupt paths).
-                            final_text: str | None = None
+                            final_parts: list[dict[str, Any]] | None = None
                             if isinstance(result, dict):
                                 try:
-                                    final_text = _extract_a2a_response(result)
+                                    final_parts = _extract_a2a_response(result)
+                                except InvalidAgentResponseError as e:
+                                    yield (
+                                        b"message",
+                                        {
+                                            "jsonrpc": "2.0",
+                                            "id": rpc_id,
+                                            "error": {
+                                                "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                                                "message": str(e),
+                                            },
+                                        },
+                                    )
+                                    return
                                 except Exception:
                                     await logger.aexception(
                                         "Failed to extract final message from result",
                                         result=result,
                                     )
-                            if final_text is None:
-                                final_text = str(result)
+                            if final_parts is None:
+                                final_parts = [{"kind": "text", "text": str(result)}]
 
                             if is_interrupt:
                                 # Interrupt path is unchanged: emit the interrupt
@@ -2579,7 +2793,7 @@ async def handle_message_stream(
                                 final_message = {
                                     "kind": "message",
                                     "role": "ROLE_AGENT",
-                                    "parts": [{"kind": "text", "text": final_text}],
+                                    "parts": final_parts,
                                     "messageId": str(uuid.uuid4()),
                                     "taskId": task_id,
                                     "contextId": context_id,
@@ -2634,7 +2848,7 @@ async def handle_message_stream(
                                     "result": _create_response_artifact_update(
                                         task_id=task_id,
                                         context_id=context_id,
-                                        text=final_text,
+                                        parts=final_parts,
                                         assistant_id=assistant_id,
                                     ),
                                 },
@@ -2756,13 +2970,26 @@ async def handle_message_stream(
             # its plain terminal status-update.
             if fallback_state == "TASK_STATE_COMPLETED" and isinstance(result, dict):
                 try:
-                    fallback_text = _extract_a2a_response(result)
+                    fallback_parts = _extract_a2a_response(result)
+                except InvalidAgentResponseError as e:
+                    yield (
+                        b"message",
+                        {
+                            "jsonrpc": "2.0",
+                            "id": rpc_id,
+                            "error": {
+                                "code": ERROR_CODE_INVALID_AGENT_RESPONSE,
+                                "message": str(e),
+                            },
+                        },
+                    )
+                    return
                 except Exception:
                     await logger.aexception(
                         "Failed to extract final message from result",
                         result=result,
                     )
-                    fallback_text = str(result)
+                    fallback_parts = [{"kind": "text", "text": str(result)}]
                 yield (
                     b"message",
                     {
@@ -2771,7 +2998,7 @@ async def handle_message_stream(
                         "result": _create_response_artifact_update(
                             task_id=task_id,
                             context_id=context_id,
-                            text=fallback_text,
+                            parts=fallback_parts,
                             assistant_id=assistant_id,
                         ),
                     },

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_api/js/package.json

@@ -7,7 +7,7 @@
     "format": "prettier --write ."
   },
   "dependencies": {
-    "@hono/node-server": "^2.0.10",
+    "@hono/node-server": "^2.1.0",
     "@hono/zod-validator": "^0.9.0",
     "@langchain/core": "^1.2.3",
     "@langchain/langgraph": "^1.4.9",

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_api/js/yarn.lock

@@ -224,10 +224,10 @@
   resolved "https://registry.yarnpkg.com/@hono/node-server/-/node-server-1.19.14.tgz#e30f844bc77e3ce7be442aac3b1f73ad8b58d181"
   integrity sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==
 
-"@hono/node-server@^2.0.10":
-  version "2.0.11"
-  resolved "https://registry.yarnpkg.com/@hono/node-server/-/node-server-2.0.11.tgz#0e947b19fe8602232cf6049feeda8f15dea47569"
-  integrity sha512-bjD221KPLoJTWUwso1J6fGKiTXEUFedG/s0visavY4zakFPkeGURMRNly+FhBHs7T8Dz4qHaZIMX9ZoJHSJtKA==
+"@hono/node-server@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@hono/node-server/-/node-server-2.1.0.tgz#c1823e1b9add6bdd14807fbbfec39b8b80614b25"
+  integrity sha512-XovyyCCnBzW+zKu+z/zq8hwNs4KOR5rEMAOxo2f40Q5xoOI37IMm6MIg2COOUtUApo0i6850MTBKH2u4QLGIqg==
 
 "@hono/node-ws@^1.3.0":
   version "1.3.1"

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_api/metrics_otlp.py

@@ -475,7 +475,7 @@ class OTelMetricsReporter:
                 resource = Resource.create(
                     {
                         "service.name": SERVICE_NAME,
-                        "host.id": os.getenv("HOSTNAME", ""),
+                        "k8s.pod.name": os.getenv("HOSTNAME", ""),
                         "api_version": os.getenv("LANGSMITH_LANGGRAPH_API_VERSION")
                         or __version__,
                         "project_id": os.getenv("LANGSMITH_HOST_PROJECT_ID", ""),

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_grpc_common/conversion/checkpoint.py

@@ -99,8 +99,7 @@ def checkpoint_to_proto(checkpoint: Checkpoint) -> engine_common_pb2.Checkpoint:
                         )
             elif not isinstance(v, Send):
                 raise ValueError(
-                    "Task must be a Send object objects."
-                    f" Got type={type(v)} value={v}",
+                    f"Task must be a Send object objects. Got type={type(v)} value={v}",
                 )
         if isinstance(v, Send):
             checkpoint_proto.channel_values[k].CopyFrom(

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/langgraph_grpc_common/conversion/value.py

@@ -122,8 +122,7 @@ def value_to_proto(
             send = _coerce_send(v)
             if not isinstance(send, Send):
                 raise ValueError(
-                    "Task must be a Send object objects."
-                    f" Got type={type(v)} value={v}",
+                    f"Task must be a Send object objects. Got type={type(v)} value={v}",
                 )
             coerced.append(send)
         return sends_to_proto(coerced)

{langgraph_api-0.13.0rc2 → langgraph_api-0.14.0.dev2}/pyproject.toml

@@ -36,10 +36,10 @@ dependencies = [
     "jsonschema-rs>=0.20.0,<0.45",
     "structlog>=24.1.0,<26",
     "pyjwt>=2.13.0",
-    "cryptography>=42.0.0",
+    "cryptography>=50.0.0",
     "langgraph-sdk>=0.3.5",
     "cloudpickle>=3.0.0",
-    "langgraph-runtime-inmem>=0.33.0.dev0,<0.34.0.dev0",
+    "langgraph-runtime-inmem>=0.34.0.dev0,<0.35.0.dev0",
     "truststore>=0.1",
     "protobuf>=6.32.1,<7.0.0",
     "grpcio>=1.81.0,<1.82.0",