langgraph-agent-common 2.0.0__py3-none-any.whl

langgraph_a2a_api/adaptor/agent_executor.py

@@ -0,0 +1,421 @@
+import logging
+from collections.abc import AsyncIterable
+from typing import Any, Union
+from pydantic import BaseModel
+import asyncio
+import uuid
+from datetime import datetime, timezone
+
+from google.protobuf.json_format import MessageToDict
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from langgraph.graph.state import CompiledStateGraph
+from langchain_core.messages import AnyMessage, AIMessage, HumanMessage, RemoveMessage
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.store.base import BaseStore
+from langgraph.types import Command, StateSnapshot, Interrupt, Overwrite
+from langgraph.typing import ContextT
+from langgraph.errors import GraphRecursionError, GraphDrained
+from langgraph.graph import END
+from langgraph.runtime import RunControl
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.tasks import TaskUpdater, TaskStore
+from a2a.server.context import ServerCallContext
+from a2a.types import Task, Message, Part, TaskState, TaskStatus, Role
+from a2a.utils.errors import InternalError, InvalidParamsError
+from a2a.helpers import new_text_message
+
+from .conversion import a2a_message_to_langgraph, langgraph_message_to_a2a, any_content_to_langgraph, langgraph_part_to_a2a
+from langgraph_a2a_api.utils.types import atomic_type
+from langgraph_a2a_api.utils.lock import AsyncResourceLock
+from .sanitize_messages_for_llm import sanitize_messages_for_llm
+from langgraph_a2a_api.langgraph.validator import validate_HITLResponse, HITLResponseModel
+
+logging.basicConfig(level=logging.WARN)
+logger = logging.getLogger(__name__)
+
+TASK_STATE_SUBMITTED = TaskState.Value("TASK_STATE_SUBMITTED")
+TASK_STATE_WORKING = TaskState.Value("TASK_STATE_WORKING")
+TASK_STATE_COMPLETED = TaskState.Value("TASK_STATE_COMPLETED")
+TASK_STATE_FAILED = TaskState.Value("TASK_STATE_FAILED")
+TASK_STATE_CANCELED = TaskState.Value("TASK_STATE_CANCELED")
+TASK_STATE_INPUT_REQUIRED = TaskState.Value("TASK_STATE_INPUT_REQUIRED")
+TASK_STATE_REJECTED = TaskState.Value("TASK_STATE_REJECTED")
+TASK_STATE_UNSEPCIFIED = TaskState.Value("TASK_STATE_UNSPECIFIED")
+
+negative_graph_state = {TASK_STATE_CANCELED, TASK_STATE_FAILED, TASK_STATE_REJECTED}
+
+class GraphAgentExecutor(AgentExecutor):
+    def __init__(self, graph: CompiledStateGraph, task_store: TaskStore):
+        super().__init__()
+        self.graph = graph
+        self.graph_with_ck = None
+        self.task_store = task_store
+        self.run_controls: dict[str, RunControl] = {}
+        self.lock = AsyncResourceLock()
+
+    def bind_runtime_to_graph(self, checkpointer: BaseCheckpointSaver, store: BaseStore | None = None):
+        runtime = {"checkpointer": checkpointer}
+        if store is not None:
+            runtime["store"] = store
+        self.graph_with_ck = self.graph.copy(runtime)
+
+    async def stream_graph(self, message: Message, history: list[Message], context_id: str, task_id: str, metadata: dict[str, Any], updater: TaskUpdater):
+        context = MessageToDict(message.metadata) if message and message.metadata else {}
+        langgraph_message = a2a_message_to_langgraph(message)
+        langgraph_history = [a2a_message_to_langgraph(m) for m in history]
+        try:
+            recursion_limit = int(float(metadata.get("recursion_limit", 300)))
+        except (ValueError, TypeError):
+            recursion_limit = 300
+        stream_mode = metadata.get("stream_mode", "updates")
+        subgraphs = metadata.get("subgraphs", True)
+
+        config = {
+            "configurable": {
+                **metadata,
+                "thread_id": context_id,
+                "graph_id": self.graph.get_name(),
+                "assistant_id": self.graph.get_name(),
+                "task_id": task_id,
+            },
+            "recursion_limit": recursion_limit,
+        }
+        appended_artifacts = set()
+
+        current_state = await self.graph_with_ck.aget_state(config, subgraphs=subgraphs)
+        current_interrupts = await self._get_interrupts(current_state, subgraphs)
+        if current_interrupts:
+            current_interrupt_ids = [c.id for c in current_interrupts]
+            if isinstance(langgraph_message.content, list) and len(current_interrupts) == len(langgraph_message.content) and all([isinstance(part, dict) and part.get("type") == "non_standard" and validate_HITLResponse(part.get("value")) for part in langgraph_message.content]):
+                decisions = {part.get("value", {}).get("hitl_id"): part.get("value", {}).get("decision") for part in langgraph_message.content}
+                if set(current_interrupt_ids) == set(decisions.keys()):
+                    resume_decisions = []
+                    for hitl_id in current_interrupt_ids:
+                        resume_decisions.append(decisions[hitl_id])
+                    resume_content = {"decisions": resume_decisions}
+                else:
+                    raise ValueError(f"Interrupt resume content: {langgraph_message.content}. Must contain overall original decision ids {current_interrupt_ids}.")
+            else:
+                raise ValueError(f"Invalid interrupt resume content: {langgraph_message.content}. Must be a list with the same length as interrupt ids: {current_interrupt_ids}. Each item in the list must be a data with HITLResponse schema: {HITLResponseModel.schema()}.")
+            inputs = Command(resume = resume_content, update = {"messages": sanitize_messages_for_llm(langgraph_history)})
+            for k, v in current_state.values.items():
+                if k in {"messages", "graph_status"} or not v or not (isinstance(v, list) and isinstance(v, set)):
+                    continue
+                appended_artifacts.add(k)
+        else:
+            inputs = {"messages": sanitize_messages_for_llm(langgraph_history + [langgraph_message])}
+
+        run_control = RunControl()
+        self.run_controls[task_id] = run_control
+        try:
+            if stream_mode == "updates":
+                async for updates in self._stream_graph_updates(inputs, config, context, subgraphs, run_control):
+                    await self._update_task(updates, context_id, task_id, updater, appended_artifacts)
+            elif stream_mode == "custom":
+                async for custom in self._stream_graph_custom(inputs, config, context, subgraphs, run_control):
+                    await self._update_task(custom, context_id, task_id, updater, appended_artifacts)
+            else:
+                raise ValueError(f"Unsupported stream_mode {stream_mode}.")
+        finally:
+            self.run_controls.pop(task_id, None)
+
+    async def _get_interrupts(self, state: StateSnapshot, subgraphs: bool, seen_ids: set[str] = set()) -> list[Interrupt]:
+        interrupts = []
+        for interrupt in state.interrupts:
+            if interrupt.id not in seen_ids:
+                seen_ids.add(interrupt.id)
+                interrupts.append(interrupt)
+        for task in state.tasks:
+            if task.interrupts:
+                for interrupt in task.interrupts:
+                    if interrupt.id not in seen_ids:
+                        seen_ids.add(interrupt.id)
+                        interrupts.append(interrupt)
+            nested_state = task.state
+            if isinstance(nested_state, StateSnapshot):
+                interrupts.extend(await self._get_interrupts(nested_state, subgraphs, seen_ids))
+            elif nested_state:
+                try:
+                    fetched_state = await self.graph_with_ck.aget_state(nested_state, subgraphs=subgraphs)
+                except Exception:
+                    continue
+                interrupts.extend(await self._get_interrupts(fetched_state, subgraphs, seen_ids))
+        return interrupts
+
+    def _normalize_messages(self, messages: Any) -> list[AnyMessage]:
+        if messages is None:
+            return []
+        if isinstance(messages, Overwrite):
+            messages = messages.value
+        if isinstance(messages, list):
+            return messages
+        raise ValueError(f"Unsupported type of messages: {type(messages).__name__}")
+
+    async def _update_task(self, state: dict[str, Any], context_id: str, task_id: str, updater: TaskUpdater, appended_artifacts: set):
+        if not state:
+            return
+        i = 0
+        for k, v in state.items():
+            append = False
+            i = i + 1
+            if k in {"messages", "graph_status"} or not v:
+                continue
+            if isinstance(v, atomic_type):
+                parts = [langgraph_part_to_a2a(str(v))]
+            elif isinstance(v, list) or isinstance(v, tuple):
+                parts = []
+                for part in v:
+                    if isinstance(part, atomic_type):
+                        parts.append(langgraph_part_to_a2a(str(part)))
+                    elif isinstance(part, dict):
+                        parts.append(langgraph_part_to_a2a({"type": "non_standard", "value": part}))
+                    elif isinstance(part, BaseModel):
+                        parts.append(langgraph_part_to_a2a({"type": "non_standard", "value": part.model_dump()}))
+                    else:
+                        raise ValueError(f"Unsupported type of artifact part {part}.")
+                if k in appended_artifacts:
+                    append = True
+                else:
+                    appended_artifacts.add(k)
+            elif isinstance(v, dict):
+                parts = [langgraph_part_to_a2a({"type": "non_standard", "value": v})]
+            elif isinstance(v, BaseModel):
+                parts = [langgraph_part_to_a2a({"type": "non_standard", "value": v.model_dump()})]
+            else:
+                raise ValueError(f"Unsupported type of artifact: {k}:{v}")
+
+            await updater.add_artifact(
+                parts = parts,
+                artifact_id = k,
+                name = k,
+                append = append,
+                last_chunk = False,
+            )
+        messages = [message for message in state.get("messages", []) if not isinstance(message, RemoveMessage)]
+        for message in messages[0:-1]:
+            a2a_message = langgraph_message_to_a2a(message, context_id, task_id)
+            await updater.update_status(
+                state = TASK_STATE_WORKING,
+                message = langgraph_message_to_a2a(message, context_id, task_id),
+            )
+
+        if state["graph_status"] == TASK_STATE_COMPLETED or state["graph_status"] in negative_graph_state or len(messages) > 0:
+            await updater.update_status(
+                state = state["graph_status"],
+                message = langgraph_message_to_a2a(messages[-1], context_id, task_id) if len(messages) > 0 else None,
+            )
+
+    async def _stream_graph_updates(self, inputs: Union[dict[str, list[AnyMessage]], Command], config: RunnableConfig, context: ContextT, subgraphs: bool, control: RunControl) -> AsyncIterable[dict[str, Any]]:
+        graph_status = TASK_STATE_UNSEPCIFIED
+        break_out = False
+        pre_yield = None
+        try:
+            async for space, updates in self.graph_with_ck.astream(inputs, config = config, context = context, stream_mode = "updates", subgraphs = subgraphs, control = control):
+                if break_out:
+                    continue
+                for step, update in updates.items():
+                    if break_out:
+                        continue
+                    if not update:
+                        continue
+                    if pre_yield is not None:
+                        yield pre_yield
+                        pre_yield = None
+                    if step == "__interrupt__":
+                        graph_status = TASK_STATE_INPUT_REQUIRED
+                        pre_yield = {
+                            "messages": [AIMessage(content=any_content_to_langgraph([{"hitl_id": interrupt.id, "content": interrupt.value} for interrupt in update]))],
+                            "graph_status": graph_status,
+                        }
+                        break_out = True
+                    else:
+                        messages = self._normalize_messages(update.get("messages"))
+                        graph_status = TASK_STATE_WORKING
+                        pre_yield = {
+                            **update,
+                            "messages": messages,
+                            "graph_status": graph_status,
+                        }
+            if not break_out:
+                graph_status = TASK_STATE_COMPLETED
+                yield {
+                    **(pre_yield or {}),
+                    "graph_status": graph_status,
+                }
+            else:
+                yield pre_yield
+
+        except GraphRecursionError as e:
+            if pre_yield is not None:
+                yield pre_yield
+            graph_status = TASK_STATE_FAILED
+            yield {
+                "messages": [AIMessage(content=str(e))],
+                "graph_status": graph_status,
+            }
+        except GraphDrained:
+            if pre_yield is not None:
+                yield pre_yield
+            yield {
+                "graph_status": TASK_STATE_CANCELED,
+            }
+    async def _stream_graph_custom(self, inputs: Union[dict[str, list[AnyMessage]], Command], config: RunnableConfig, context: ContextT, subgraphs: bool, control: RunControl) -> AsyncIterable[dict[str, Any]]:
+        graph_recursion_error = None
+        graph_drained = None
+        try:
+            async for space, custom in self.graph_with_ck.astream(inputs, config = config, context = context, stream_mode = "custom", subgraphs = subgraphs, control = control):
+                if not custom:
+                    yield {}
+                    continue
+                yield {
+                    "messages": [AIMessage(content=any_content_to_langgraph(custom))],
+                    "graph_status": TASK_STATE_WORKING,
+                }
+        except GraphRecursionError as e:
+            graph_recursion_error = str(e)
+        except GraphDrained as e:
+            graph_drained = str(e)
+
+        current_state_after = await self.graph_with_ck.aget_state(config, subgraphs=subgraphs)
+        current_interrupts_after = await self._get_interrupts(current_state_after, subgraphs)
+        if current_interrupts_after:
+            yield {
+                "messages": [AIMessage(content=any_content_to_langgraph([{"hitl_id": interrupt.id, "content": interrupt.value} for interrupt in current_interrupts_after]))],
+                "graph_status": TASK_STATE_INPUT_REQUIRED,
+            }
+        else:
+            messages_raw = self._normalize_messages(current_state_after.values.get("messages"))
+            if graph_recursion_error:
+                graph_status = TASK_STATE_FAILED
+                messages_raw = messages_raw + [AIMessage(content=graph_recursion_error)]
+            elif graph_drained:
+                graph_status = TASK_STATE_CANCELED
+                messages_raw = messages_raw + [AIMessage(content=graph_drained)]
+            else:
+                graph_status = TASK_STATE_COMPLETED
+            if len(messages_raw) > 0 and not isinstance(messages_raw[-1], HumanMessage) and messages_raw[-1].content:
+                messages = [messages_raw[-1]]
+                messages_history = messages_raw[0:-1]
+            else:
+                messages = []
+                messages_history = messages_raw
+            yield {
+                **current_state_after.values,
+                "graph_status": graph_status,
+                "messages": messages,
+                "messages_history": [langgraph_message_to_a2a(message, None, None) for message in messages_history],
+            }
+
+    async def _update_task_store_status(self, task: Task, state: int, call_context: ServerCallContext) -> None:
+        ts = Timestamp()
+        ts.FromDatetime(datetime.now(timezone.utc))
+        task.status.state = state
+        task.status.timestamp.CopyFrom(ts)
+        await self.task_store.save(task, call_context)
+
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        if not self.graph_with_ck:
+            raise InternalError(message=f"Can not found checkpointer of langgraph.")
+        if not context.message:
+            raise InvalidParamsError(message=f"Request message is required.")
+
+        task_id = context.current_task.id if context.current_task else context.message.task_id or str(uuid.uuid4())
+        context_id = context.current_task.context_id if context.current_task else context.message.context_id or str(uuid.uuid4())
+        updater = TaskUpdater(event_queue, task_id, context_id)
+
+        @self.lock.async_resource_lock(context_id)
+        async def start_task() -> tuple[bool, list[Task]]:
+            alive_tasks = await self.task_store.get_alive_tasks(context_id)
+            for alive_task in alive_tasks:
+                if alive_task.status.state == TASK_STATE_INPUT_REQUIRED:
+                    if alive_task.id == task_id:
+                        await updater.start_work()
+                        history_tasks = await self.task_store.get_rejected_tasks(context_id)
+                        return (True, history_tasks)
+                    else:
+                        return (False, [alive_task])
+                else:
+                    return (False, [alive_task])
+            await updater.start_work()
+            history_tasks = await self.task_store.get_rejected_tasks(context_id)
+            return (True, history_tasks)
+
+        try:
+            exist_task = await self.task_store.get(task_id, context.call_context)
+            if not exist_task:
+                enqueue_task = Task(
+                    id = task_id,
+                    context_id = context_id,
+                    status = TaskStatus(state = TASK_STATE_SUBMITTED, message = context.message),
+                )
+                await event_queue.enqueue_event(enqueue_task)
+
+            started = False
+            history_tasks = []
+            for _ in range(60):
+                started, history_tasks = await start_task()
+                if started:
+                    break
+                await asyncio.sleep(10)
+            if not started:
+                await updater.update_status(
+                    TASK_STATE_REJECTED,
+                    new_text_message(f"Context {context_id} is working in task {history_tasks[0].id}, place this task to queue."),
+                )
+                return
+
+            history_tasks = sorted(history_tasks, key = lambda t: t.status.timestamp.ToDatetime())
+            history = []
+            history_task_ids = []
+            for history_task in history_tasks:
+                if history_task.history:
+                    history.append(history_task.history[0])
+                history_task_ids.append(history_task.id)
+
+            await self.stream_graph(context.message, history, context_id, task_id, context.metadata or {}, updater)
+            for history_task_id in history_task_ids:
+                task = await self.task_store.get(history_task_id, context.call_context)
+                if task:
+                    await self._update_task_store_status(task, TASK_STATE_COMPLETED, context.call_context)
+        except Exception as e:
+            if not isinstance(e, ValueError):
+                logger.error(f"An error occurred while streaming the response: {e}", exc_info=True)
+            raise InternalError(message=str(e))
+        except asyncio.CancelledError:
+            await updater.cancel()
+            raise
+        finally:
+            await asyncio.sleep(0)
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        task_id = context.current_task.id if context.current_task else context.message.task_id or None
+        if not task_id:
+            raise InvalidParamsError(message="Must assign task_id for canceling task.")
+        context_id = context.current_task.context_id if context.current_task else context.message.context_id or None
+        if not context_id:
+            raise InvalidParamsError(message=f"Can not match context_id for canceling task {task_id}.")
+        exist_task = await self.task_store.get(task_id, context.call_context)
+        if exist_task and exist_task.status.state == TASK_STATE_INPUT_REQUIRED:
+            config = {
+                "configurable": {
+                    "thread_id": context_id,
+                },
+            }
+            try:
+                await self.graph_with_ck.aupdate_state(config, None, as_node=END)
+                await self._update_task_store_status(exist_task, TASK_STATE_CANCELED, context.call_context)
+            except Exception as e:
+                raise InternalError(message=f"Cancel task {task_id} failed. {e}")
+        if task_id in self.run_controls:
+            self.run_controls[task_id].request_drain()
+            for _ in range(200):
+                if task_id not in self.run_controls:
+                    break
+                await asyncio.sleep(2)
+            self.run_controls.pop(task_id, None)
+
+

langgraph_a2a_api/adaptor/conversion.py

@@ -0,0 +1,167 @@
+from typing import Any, Union
+import base64
+import uuid
+
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.struct_pb2 import Value
+
+from a2a.types import Message, Part, Role
+
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage
+from langchain_core.messages.content import KNOWN_BLOCK_TYPES
+
+from langgraph_a2a_api.utils.types import atomic_type
+
+
+def a2a_part_to_langgraph(part: Part) -> Union[str, dict[str, Any]]:
+    part_type = part.WhichOneof("content")
+    if part_type == "text":
+        return {
+            "type": "text",
+            "text": part.text,
+        }
+    elif part_type == "data":
+        data = MessageToDict(part.data)
+        if isinstance(data, dict) and data.get("type") in KNOWN_BLOCK_TYPES:
+            return data
+        return {
+            "type": "non_standard",
+            "value": data,
+        }
+    elif part_type == "raw":
+        file_block = {
+            "type": "file",
+            "base64": base64.b64encode(part.raw).decode("ascii"),
+        }
+        if part.media_type:
+            file_block["mime_type"] = part.media_type
+        if part.filename:
+            file_block["extras"] = {"filename": part.filename}
+        return file_block
+    elif part_type == "url":
+        file_block = {
+            "type": "file",
+            "url": part.url,
+        }
+        if part.media_type:
+            file_block["mime_type"] = part.media_type
+        if part.filename:
+            file_block["extras"] = {"filename": part.filename}
+        return file_block
+    else:
+        raise ValueError(f"Unknown a2a part type {part}.")
+
+
+def langgraph_part_to_a2a(part: Union[str, dict[str, Any]]) -> Part:
+    if isinstance(part, str):
+        return Part(text = part)
+    elif isinstance(part, dict) and part.get("type") in KNOWN_BLOCK_TYPES:
+        part_type = part.get("type")
+        if part_type == "text":
+            return Part(text = part.get("text", ""))
+        elif part_type == "reasoning":
+            return Part(text = part.get("reasoning", ""))
+        elif part_type in {"image", "audio", "video", "file"}:
+            proto = Part()
+            if "base64" in part:
+                proto.raw = base64.b64decode(part["base64"])
+            elif "url" in part:
+                proto.url = part["url"]
+            else:
+                raise ValueError(f"Unknown langgraph file part type {part}.")
+            if part.get("mime_type"):
+                proto.media_type = part["mime_type"]
+            extras = part.get("extras")
+            if isinstance(extras, dict) and extras.get("filename"):
+                proto.filename = extras["filename"]
+            return proto
+        elif part_type == "non_standard":
+            raw = {k: v.model_dump() if hasattr(v, "model_dump") else v for k, v in part["value"].items()}
+            value = ParseDict(raw, Value())
+            proto = Part()
+            proto.data.CopyFrom(value)
+            return proto
+        else:
+            raw = {k: v.model_dump() if hasattr(v, "model_dump") else v for k, v in part.items()}
+            value = ParseDict(raw, Value())
+            proto = Part()
+            proto.data.CopyFrom(value)
+            return proto
+    else:
+        raise ValueError(f"Unknown langgraph part {part}.")
+
+def a2a_message_to_langgraph(message: Message) -> AnyMessage:
+    if message.parts and len(message.parts) == 1 and message.parts[0].WhichOneof("content") == "text":
+        content = message.parts[0].text
+    elif message.parts:
+        content = [a2a_part_to_langgraph(part) for part in message.parts]
+    else:
+        content = ""
+    if message.role == Role.Value("ROLE_USER"):
+        return HumanMessage(
+            id = message.message_id or str(uuid.uuid4()),
+            content = content,
+        )
+    else:
+        return AIMessage(
+            id = message.message_id or str(uuid.uuid4()),
+            content = content,
+        )
+
+
+def langgraph_content_to_a2a(content) -> list[Part]:
+    if isinstance(content, str):
+        return [langgraph_part_to_a2a(content)]
+    return [langgraph_part_to_a2a(part) for part in content]
+
+
+def langgraph_message_to_a2a(message: AnyMessage, context_id: str, task_id: str) -> Message:
+    if isinstance(message, HumanMessage):
+        role = Role.Value("ROLE_USER")
+        parts = langgraph_content_to_a2a(message.content)
+    elif isinstance(message, AIMessage):
+        role = Role.Value("ROLE_AGENT")
+        parts = langgraph_content_to_a2a(message.content)
+        if message.tool_calls:
+            parts.extend([langgraph_part_to_a2a({"type": "non_standard", "value": tc}) for tc in message.tool_calls])
+        if message.invalid_tool_calls:
+            parts.extend([langgraph_part_to_a2a({"type": "non_standard", "value": tc}) for tc in message.invalid_tool_calls])
+    elif isinstance(message, ToolMessage):
+        role = Role.Value("ROLE_AGENT")
+        tool_result = {"type": "tool_result", "tool_call_id": message.tool_call_id, "content": message.content}
+        parts = [langgraph_part_to_a2a({"type": "non_standard", "value": tool_result})]
+    else:
+        role = Role.Value("ROLE_AGENT")
+        parts = langgraph_content_to_a2a(message.content)
+    return Message(
+        role = role,
+        parts = parts,
+        message_id = message.id or str(uuid.uuid4()),
+        task_id = task_id or "",
+        context_id = context_id or "",
+    )
+
+
+def any_content_to_langgraph(custom: Any) -> Union[str, list[Union[str, dict[str, Any]]]]:
+    if isinstance(custom, atomic_type):
+        content = str(custom)
+    elif isinstance(custom, list):
+        content = []
+        for part in custom:
+            if isinstance(part, atomic_type):
+                content.append(str(part))
+            elif isinstance(part, dict):
+                content.append({"type": "non_standard", "value": part})
+            else:
+                raise ValueError(f"Unsupported type of langgraph content part {part}.")
+        if len(content) == 1 and isinstance(content[0], str):
+            content = content[0]
+    elif isinstance(custom, dict):
+        content = [{"type": "non_standard", "value": custom}]
+    else:
+        raise ValueError(f"Unsupported type of langgraph message content {custom}.")
+    try:
+        HumanMessage(content = content)
+    except Exception:
+        raise ValueError(f"Unsupported type of langgraph message content {custom}.")
+    return content

langgraph_a2a_api/adaptor/sanitize_messages_for_llm.py

@@ -0,0 +1,34 @@
+import json
+from langchain_core.messages import AnyMessage
+
+
+LLM_SAFE_CONTENT_TYPES = {"text", "image", "audio", "file", "text-plain", "video"}
+
+
+def sanitize_messages_for_llm(messages: list[AnyMessage]) -> list[AnyMessage]:
+    result = []
+    for msg in messages:
+        if isinstance(msg.content, str):
+            result.append(msg)
+            continue
+        if not isinstance(msg.content, list):
+            raise ValueError(f"Unexpected message content type: {type(msg.content).__name__}, value: {msg.content}")
+        sanitized = []
+        for part in msg.content:
+            if isinstance(part, str):
+                sanitized.append(part)
+            elif isinstance(part, dict) and part.get("type") in LLM_SAFE_CONTENT_TYPES:
+                sanitized.append(part)
+            elif isinstance(part, dict):
+                value = part.get("value", part)
+                sanitized.append({
+                    "type": "text",
+                    "text": json.dumps(value, ensure_ascii=False, default=str),
+                })
+            else:
+                raise ValueError(f"Unexpected content part type: {type(part).__name__}, value: {part}")
+        if not sanitized:
+            result.append(msg.__class__(id=msg.id, content=""))
+        else:
+            result.append(msg.__class__(id=msg.id, content=sanitized))
+    return result