langgraph-agent-common 2.0.0__tar.gz

langgraph_agent_common-2.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: langgraph-agent-common
+Version: 2.0.0
+Summary: langgraph-agent-common
+Author-email: Aegon <1006785434@qq.com>
+Project-URL: repository, https://github.com/liuxiahuiyi/langgraph-agent-common.git
+Keywords: Langgraph,A2A
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: langchain>=1.3.11
+Requires-Dist: langchain-openai>=1.3.2
+Requires-Dist: langgraph>=1.2.5
+Requires-Dist: langgraph-api>=0.10.0
+Requires-Dist: langgraph-cli>=0.4.30
+Requires-Dist: langgraph-checkpoint-postgres>=3.1.0
+Requires-Dist: deepagents>=0.6.10
+Requires-Dist: a2a-sdk>=1.1.0
+Requires-Dist: a2a-sdk[http-server]>=1.1.0
+Requires-Dist: a2a-sdk[postgresql]>=1.1.0
+Requires-Dist: fastapi>=0.137.1
+Requires-Dist: inflection>=0.5.1
+Requires-Dist: APScheduler>=3.11.2
+Provides-Extra: talos
+Requires-Dist: talos-python3>=3.1.6; extra == "talos"
+
+# langgraph-agent-common
+
+```~/.pypirc
+[distutils]
+index-servers =
+  snapshot
+  stage
+  release
+[snapshot]
+repository:
+username:
+password:
+[stage]
+repository:
+username:
+password:
+[release]
+repository:
+username:
+password:
+```
+
+```~/.pip/pip.conf
+[global]
+timeout=60000
+index-url =
+```
+
+
+```bash
+python -m build --wheel
+twine upload --repository snapshot dist/*.whl
+```
+
+```bash
+brew install snappy
+export CPPFLAGS="-I/opt/homebrew/include"
+export LDFLAGS="-L/opt/homebrew/lib"
+pip install -e .[talos]
+```
+
+`talos-python3` is optional. Default installation does not include it; install the `talos` extra only when Talos integration is needed.

langgraph_agent_common-2.0.0/README.md

@@ -0,0 +1,42 @@
+# langgraph-agent-common
+
+```~/.pypirc
+[distutils]
+index-servers =
+  snapshot
+  stage
+  release
+[snapshot]
+repository:
+username:
+password:
+[stage]
+repository:
+username:
+password:
+[release]
+repository:
+username:
+password:
+```
+
+```~/.pip/pip.conf
+[global]
+timeout=60000
+index-url =
+```
+
+
+```bash
+python -m build --wheel
+twine upload --repository snapshot dist/*.whl
+```
+
+```bash
+brew install snappy
+export CPPFLAGS="-I/opt/homebrew/include"
+export LDFLAGS="-L/opt/homebrew/lib"
+pip install -e .[talos]
+```
+
+`talos-python3` is optional. Default installation does not include it; install the `talos` extra only when Talos integration is needed.

langgraph_agent_common-2.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "langgraph-agent-common"
+version = "2.0.0"
+description = "langgraph-agent-common"
+readme = "README.md"
+authors = [{ name = "Aegon", email = "1006785434@qq.com" }]
+requires-python = ">=3.13"
+keywords = ["Langgraph", "A2A"]
+dependencies = [
+  "langchain>=1.3.11",
+  "langchain-openai>=1.3.2",
+  "langgraph>=1.2.5",
+  "langgraph-api>=0.10.0",
+  "langgraph-cli>=0.4.30",
+  "langgraph-checkpoint-postgres>=3.1.0",
+  "deepagents>=0.6.10",
+  "a2a-sdk>=1.1.0",
+  "a2a-sdk[http-server]>=1.1.0",
+  "a2a-sdk[postgresql]>=1.1.0",
+  "fastapi>=0.137.1",
+  "inflection>=0.5.1",
+  "APScheduler>=3.11.2",
+]
+
+[project.optional-dependencies]
+talos = [
+  "talos-python3>=3.1.6",
+]
+
+[project.urls]
+repository = "https://github.com/liuxiahuiyi/langgraph-agent-common.git"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+langgraph_a2a_api = ["resources/**/*"]
+
+[tool.pyright]
+exclude = [
+  "**/__pycache__",
+  "**/dist",
+  "**/build",
+  "**/node_modules",
+  "**/venv",
+  "**/.venv",
+]

langgraph_agent_common-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langgraph_agent_common-2.0.0/src/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)
+
+