uipath-langchain 0.0.133__py3-none-any.whl → 0.1.28__py3-none-any.whl

uipath_langchain/agent/guardrails/guardrail_nodes.py

@@ -0,0 +1,173 @@
+import json
+import logging
+import re
+from typing import Any, Callable
+
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, SystemMessage
+from langgraph.types import Command
+from uipath.platform import UiPath
+from uipath.platform.guardrails import (
+    BaseGuardrail,
+    GuardrailScope,
+)
+
+from uipath_langchain.agent.guardrails.types import ExecutionStage
+
+from .types import AgentGuardrailsGraphState
+
+logger = logging.getLogger(__name__)
+
+
+def _message_text(msg: AnyMessage) -> str:
+    if isinstance(msg, (HumanMessage, SystemMessage)):
+        return msg.content if isinstance(msg.content, str) else str(msg.content)
+    return str(getattr(msg, "content", "")) if hasattr(msg, "content") else ""
+
+
+def _create_guardrail_node(
+    guardrail: BaseGuardrail,
+    scope: GuardrailScope,
+    execution_stage: ExecutionStage,
+    payload_generator: Callable[[AgentGuardrailsGraphState], str],
+    success_node: str,
+    failure_node: str,
+) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
+    """Private factory for guardrail evaluation nodes.
+
+    Returns a node that evaluates the guardrail and routes via Command:
+    - goto success_node on validation pass
+    - goto failure_node on validation fail
+    """
+    raw_node_name = f"{scope.name}_{execution_stage.name}_{guardrail.name}"
+    node_name = re.sub(r"\W+", "_", raw_node_name.lower()).strip("_")
+
+    async def node(
+        state: AgentGuardrailsGraphState,
+    ):
+        text = payload_generator(state)
+        try:
+            uipath = UiPath()
+            result = uipath.guardrails.evaluate_guardrail(text, guardrail)
+        except Exception as exc:
+            logger.error("Failed to evaluate guardrail: %s", exc)
+            raise
+
+        if not result.validation_passed:
+            return Command(
+                goto=failure_node, update={"guardrail_validation_result": result.reason}
+            )
+        return Command(goto=success_node, update={"guardrail_validation_result": None})
+
+    return node_name, node
+
+
+def create_llm_guardrail_node(
+    guardrail: BaseGuardrail,
+    execution_stage: ExecutionStage,
+    success_node: str,
+    failure_node: str,
+) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
+    def _payload_generator(state: AgentGuardrailsGraphState) -> str:
+        if not state.messages:
+            return ""
+        return _message_text(state.messages[-1])
+
+    return _create_guardrail_node(
+        guardrail,
+        GuardrailScope.LLM,
+        execution_stage,
+        _payload_generator,
+        success_node,
+        failure_node,
+    )
+
+
+def create_agent_guardrail_node(
+    guardrail: BaseGuardrail,
+    execution_stage: ExecutionStage,
+    success_node: str,
+    failure_node: str,
+) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
+    # To be implemented in future PR
+    def _payload_generator(state: AgentGuardrailsGraphState) -> str:
+        if not state.messages:
+            return ""
+        return _message_text(state.messages[-1])
+
+    return _create_guardrail_node(
+        guardrail,
+        GuardrailScope.AGENT,
+        execution_stage,
+        _payload_generator,
+        success_node,
+        failure_node,
+    )
+
+
+def create_tool_guardrail_node(
+    guardrail: BaseGuardrail,
+    execution_stage: ExecutionStage,
+    success_node: str,
+    failure_node: str,
+    tool_name: str,
+) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
+    """Create a guardrail node for TOOL scope guardrails.
+
+    Args:
+        guardrail: The guardrail to evaluate.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+        success_node: Node to route to on validation pass.
+        failure_node: Node to route to on validation fail.
+        tool_name: Name of the tool to extract arguments from.
+
+    Returns:
+        A tuple of (node_name, node_function) for the guardrail evaluation node.
+    """
+
+    def _payload_generator(state: AgentGuardrailsGraphState) -> str:
+        """Extract tool call arguments for the specified tool name.
+
+        Args:
+            state: The current agent graph state.
+
+        Returns:
+            JSON string of the tool call arguments, or empty string if not found.
+        """
+        if not state.messages:
+            return ""
+
+        if execution_stage == ExecutionStage.PRE_EXECUTION:
+            if not isinstance(state.messages[-1], AIMessage):
+                return ""
+            message = state.messages[-1]
+
+            if not message.tool_calls:
+                return ""
+
+            # Find the first tool call with matching name
+            for tool_call in message.tool_calls:
+                call_name = (
+                    tool_call.get("name")
+                    if isinstance(tool_call, dict)
+                    else getattr(tool_call, "name", None)
+                )
+                if call_name == tool_name:
+                    # Extract args from the tool call
+                    args = (
+                        tool_call.get("args")
+                        if isinstance(tool_call, dict)
+                        else getattr(tool_call, "args", None)
+                    )
+                    if args is not None:
+                        return json.dumps(args)
+
+        return _message_text(state.messages[-1])
+
+    return _create_guardrail_node(
+        guardrail,
+        GuardrailScope.TOOL,
+        execution_stage,
+        _payload_generator,
+        success_node,
+        failure_node,
+    )

uipath_langchain/agent/guardrails/guardrails_factory.py

@@ -0,0 +1,70 @@
+import logging
+from typing import Sequence
+
+from uipath.agent.models.agent import (
+    AgentGuardrail,
+    AgentGuardrailBlockAction,
+    AgentGuardrailEscalateAction,
+    AgentGuardrailLogAction,
+    AgentGuardrailSeverityLevel,
+    AgentUnknownGuardrail,
+)
+from uipath.platform.guardrails import BaseGuardrail
+
+from uipath_langchain.agent.guardrails.actions import (
+    BlockAction,
+    EscalateAction,
+    GuardrailAction,
+    LogAction,
+)
+
+
+def build_guardrails_with_actions(
+    guardrails: Sequence[AgentGuardrail] | None,
+) -> list[tuple[BaseGuardrail, GuardrailAction]]:
+    """Build a list of (guardrail, action) tuples from model definitions.
+
+    Args:
+        guardrails: Sequence of guardrail model objects or None.
+
+    Returns:
+        A list of tuples pairing each supported guardrail with its executable action.
+    """
+    if not guardrails:
+        return []
+
+    result: list[tuple[BaseGuardrail, GuardrailAction]] = []
+    for guardrail in guardrails:
+        if isinstance(guardrail, AgentUnknownGuardrail):
+            continue
+
+        action = guardrail.action
+
+        if isinstance(action, AgentGuardrailBlockAction):
+            result.append((guardrail, BlockAction(action.reason)))
+        elif isinstance(action, AgentGuardrailLogAction):
+            severity_level_map = {
+                AgentGuardrailSeverityLevel.ERROR: logging.ERROR,
+                AgentGuardrailSeverityLevel.WARNING: logging.WARNING,
+                AgentGuardrailSeverityLevel.INFO: logging.INFO,
+            }
+            level = severity_level_map.get(action.severity_level, logging.INFO)
+            result.append(
+                (
+                    guardrail,
+                    LogAction(message=action.message, level=level),
+                )
+            )
+        elif isinstance(action, AgentGuardrailEscalateAction):
+            result.append(
+                (
+                    guardrail,
+                    EscalateAction(
+                        app_name=action.app.name,
+                        app_folder_path=action.app.folder_name,
+                        version=action.app.version,
+                        assignee=action.recipient.value,
+                    ),
+                )
+            )
+    return result

uipath_langchain/agent/guardrails/guardrails_subgraph.py

@@ -0,0 +1,283 @@
+from functools import partial
+from typing import Any, Callable, Sequence
+
+from langgraph.constants import END, START
+from langgraph.graph import StateGraph
+from langgraph.prebuilt import ToolNode
+from uipath.platform.guardrails import (
+    BaseGuardrail,
+    BuiltInValidatorGuardrail,
+    GuardrailScope,
+)
+
+from uipath_langchain.agent.guardrails.types import ExecutionStage
+
+from .actions.base_action import GuardrailAction, GuardrailActionNode
+from .guardrail_nodes import (
+    create_agent_guardrail_node,
+    create_llm_guardrail_node,
+    create_tool_guardrail_node,
+)
+from .types import AgentGuardrailsGraphState
+
+_VALIDATOR_ALLOWED_STAGES = {
+    "prompt_injection": {ExecutionStage.PRE_EXECUTION},
+    "pii_detection": {ExecutionStage.PRE_EXECUTION, ExecutionStage.POST_EXECUTION},
+}
+
+
+def _filter_guardrails_by_stage(
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+    stage: ExecutionStage,
+) -> list[tuple[BaseGuardrail, GuardrailAction]]:
+    """Filter guardrails that apply to a specific execution stage."""
+    filtered_guardrails = []
+    for guardrail, action in guardrails or []:
+        # Internal knowledge: Check against configured allowed stages
+        if (
+            isinstance(guardrail, BuiltInValidatorGuardrail)
+            and guardrail.validator_type in _VALIDATOR_ALLOWED_STAGES
+            and stage not in _VALIDATOR_ALLOWED_STAGES[guardrail.validator_type]
+        ):
+            continue
+        filtered_guardrails.append((guardrail, action))
+    return filtered_guardrails
+
+
+def _create_guardrails_subgraph(
+    main_inner_node: tuple[str, Any],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+    scope: GuardrailScope,
+    execution_stages: Sequence[ExecutionStage],
+    node_factory: Callable[
+        [
+            BaseGuardrail,
+            ExecutionStage,
+            str,  # success node name
+            str,  # fail node name
+        ],
+        GuardrailActionNode,
+    ] = create_llm_guardrail_node,
+):
+    """Build a subgraph that enforces guardrails around an inner node.
+
+    The constructed graph conditionally includes pre- and/or post-execution guardrail
+    chains based on ``execution_stages``:
+    - If ``ExecutionStage.PRE_EXECUTION`` is included, the graph links
+      START -> first pre-guardrail node -> ... -> inner.
+      Otherwise, it directly links START -> inner.
+    - If ``ExecutionStage.POST_EXECUTION`` is included, the graph links
+      inner -> first post-guardrail node -> ... -> END.
+      Otherwise, it directly links inner -> END.
+
+    No static edges are added between guardrail nodes; each evaluation node routes
+    dynamically to its configured success/failure targets. Failure nodes are added
+    but not chained; they are expected to route via Command to the provided next node.
+    """
+    inner_name, inner_node = main_inner_node
+
+    subgraph = StateGraph(AgentGuardrailsGraphState)
+
+    subgraph.add_node(inner_name, inner_node)
+
+    # Add pre execution guardrail nodes
+    if ExecutionStage.PRE_EXECUTION in execution_stages:
+        pre_guardrails = _filter_guardrails_by_stage(
+            guardrails, ExecutionStage.PRE_EXECUTION
+        )
+        first_pre_exec_guardrail_node = _build_guardrail_node_chain(
+            subgraph,
+            pre_guardrails,
+            scope,
+            ExecutionStage.PRE_EXECUTION,
+            node_factory,
+            inner_name,
+            inner_name,
+        )
+        subgraph.add_edge(START, first_pre_exec_guardrail_node)
+    else:
+        subgraph.add_edge(START, inner_name)
+
+    # Add post execution guardrail nodes
+    if ExecutionStage.POST_EXECUTION in execution_stages:
+        post_guardrails = _filter_guardrails_by_stage(
+            guardrails, ExecutionStage.POST_EXECUTION
+        )
+        first_post_exec_guardrail_node = _build_guardrail_node_chain(
+            subgraph,
+            post_guardrails,
+            scope,
+            ExecutionStage.POST_EXECUTION,
+            node_factory,
+            END,
+            inner_node,
+        )
+        subgraph.add_edge(inner_name, first_post_exec_guardrail_node)
+    else:
+        subgraph.add_edge(inner_name, END)
+
+    return subgraph.compile()
+
+
+def _build_guardrail_node_chain(
+    subgraph: StateGraph[AgentGuardrailsGraphState],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+    scope: GuardrailScope,
+    execution_stage: ExecutionStage,
+    node_factory: Callable[
+        [
+            BaseGuardrail,
+            ExecutionStage,
+            str,  # success node name
+            str,  # fail node name
+        ],
+        GuardrailActionNode,
+    ],
+    next_node: str,
+    guarded_node_name: str,
+) -> str:
+    """Recursively build a chain of guardrail nodes in reverse order.
+
+    This function processes guardrails from last to first, creating a chain where:
+    - Each guardrail node evaluates the guardrail condition
+    - On success, it routes to the next guardrail node (or the final next_node)
+    - On failure, it routes to a failure node that either throws an error or continues to next_node
+
+    Args:
+        subgraph: The StateGraph to add nodes and edges to.
+        guardrails: Sequence of (guardrail, action) tuples to process. Processed in reverse.
+        scope: The scope of the guardrails (LLM, AGENT, or TOOL).
+        execution_stage: Whether this is "PreExecution" or "PostExecution" guardrails.
+        node_factory: Factory function to create guardrail evaluation nodes.
+        next_node: The node name to route to after all guardrails pass.
+
+    Returns:
+        The name of the first guardrail node in the chain (or next_node if no guardrails).
+    """
+    # Base case: no guardrails to process, return the next node directly
+    if not guardrails:
+        return next_node
+
+    guardrail, action = guardrails[-1]
+    remaining_guardrails = guardrails[:-1]
+
+    fail_node_name, fail_node = action.action_node(
+        guardrail=guardrail,
+        scope=scope,
+        execution_stage=execution_stage,
+        guarded_component_name=guarded_node_name,
+    )
+
+    # Create the guardrail evaluation node.
+    guardrail_node_name, guardrail_node = node_factory(
+        guardrail, execution_stage, next_node, fail_node_name
+    )
+
+    # Add both nodes to the subgraph
+    subgraph.add_node(guardrail_node_name, guardrail_node)
+    subgraph.add_node(fail_node_name, fail_node)
+
+    # Failure path route to the next node
+    subgraph.add_edge(fail_node_name, next_node)
+
+    previous_node_name = _build_guardrail_node_chain(
+        subgraph,
+        remaining_guardrails,
+        scope,
+        execution_stage,
+        node_factory,
+        guardrail_node_name,
+        guarded_node_name,
+    )
+
+    return previous_node_name
+
+
+def create_llm_guardrails_subgraph(
+    llm_node: tuple[str, Any],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+):
+    applicable_guardrails = [
+        (guardrail, _)
+        for (guardrail, _) in (guardrails or [])
+        if GuardrailScope.LLM in guardrail.selector.scopes
+    ]
+    if applicable_guardrails is None or len(applicable_guardrails) == 0:
+        return llm_node[1]
+
+    return _create_guardrails_subgraph(
+        main_inner_node=llm_node,
+        guardrails=applicable_guardrails,
+        scope=GuardrailScope.LLM,
+        execution_stages=[ExecutionStage.PRE_EXECUTION, ExecutionStage.POST_EXECUTION],
+        node_factory=create_llm_guardrail_node,
+    )
+
+
+def create_tools_guardrails_subgraph(
+    tool_nodes: dict[str, ToolNode],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+) -> dict[str, ToolNode]:
+    """Create tool nodes with guardrails.
+    Args:
+    """
+    result: dict[str, ToolNode] = {}
+    for tool_name, tool_node in tool_nodes.items():
+        subgraph = create_tool_guardrails_subgraph(
+            (tool_name, tool_node),
+            guardrails,
+        )
+        result[tool_name] = subgraph
+
+    return result
+
+
+def create_agent_guardrails_subgraph(
+    agent_node: tuple[str, Any],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+    execution_stage: ExecutionStage,
+):
+    """Create a subgraph for AGENT-scoped guardrails that applies checks at the specified stage.
+
+    This is intended for wrapping nodes like INIT or TERMINATE, where guardrails should run
+    either before (pre-execution) or after (post-execution) the node logic.
+    """
+    applicable_guardrails = [
+        (guardrail, _)
+        for (guardrail, _) in (guardrails or [])
+        if GuardrailScope.AGENT in guardrail.selector.scopes
+    ]
+    if applicable_guardrails is None or len(applicable_guardrails) == 0:
+        return agent_node[1]
+
+    return _create_guardrails_subgraph(
+        main_inner_node=agent_node,
+        guardrails=applicable_guardrails,
+        scope=GuardrailScope.AGENT,
+        execution_stages=[execution_stage],
+        node_factory=create_agent_guardrail_node,
+    )
+
+
+def create_tool_guardrails_subgraph(
+    tool_node: tuple[str, Any],
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None,
+):
+    tool_name, _ = tool_node
+    applicable_guardrails = [
+        (guardrail, action)
+        for (guardrail, action) in (guardrails or [])
+        if GuardrailScope.TOOL in guardrail.selector.scopes
+        and guardrail.selector.match_names is not None
+        and tool_name in guardrail.selector.match_names
+    ]
+    if applicable_guardrails is None or len(applicable_guardrails) == 0:
+        return tool_node[1]
+
+    return _create_guardrails_subgraph(
+        main_inner_node=tool_node,
+        guardrails=applicable_guardrails,
+        scope=GuardrailScope.TOOL,
+        execution_stages=[ExecutionStage.PRE_EXECUTION, ExecutionStage.POST_EXECUTION],
+        node_factory=partial(create_tool_guardrail_node, tool_name=tool_name),
+    )

uipath_langchain/agent/guardrails/types.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from typing import Annotated, Optional
+
+from langchain_core.messages import AnyMessage
+from langgraph.graph.message import add_messages
+from pydantic import BaseModel
+
+
+class AgentGuardrailsGraphState(BaseModel):
+    """Agent Guardrails Graph state for guardrail subgraph."""
+
+    messages: Annotated[list[AnyMessage], add_messages] = []
+    guardrail_validation_result: Optional[str] = None
+
+
+class ExecutionStage(str, Enum):
+    """Execution stage enumeration."""
+
+    PRE_EXECUTION = "preExecution"
+    POST_EXECUTION = "postExecution"

uipath_langchain/agent/react/__init__.py

@@ -0,0 +1,14 @@
+"""UiPath ReAct Agent implementation"""
+
+from .agent import create_agent
+from .types import AgentGraphConfig, AgentGraphNode, AgentGraphState
+from .utils import resolve_input_model, resolve_output_model
+
+__all__ = [
+    "create_agent",
+    "resolve_output_model",
+    "resolve_input_model",
+    "AgentGraphNode",
+    "AgentGraphState",
+    "AgentGraphConfig",
+]

uipath_langchain/agent/react/agent.py

@@ -0,0 +1,117 @@
+import os
+from typing import Callable, Sequence, Type, TypeVar, cast
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.tools import BaseTool
+from langgraph.constants import END, START
+from langgraph.graph import StateGraph
+from pydantic import BaseModel
+from uipath.platform.guardrails import BaseGuardrail
+
+from ..guardrails import create_llm_guardrails_subgraph
+from ..guardrails.actions import GuardrailAction
+from ..guardrails.guardrails_subgraph import create_tools_guardrails_subgraph
+from ..tools import create_tool_node
+from .init_node import (
+    create_init_node,
+)
+from .llm_node import (
+    create_llm_node,
+)
+from .router import (
+    route_agent,
+)
+from .terminate_node import (
+    create_terminate_node,
+)
+from .tools import create_flow_control_tools
+from .types import AgentGraphConfig, AgentGraphNode, AgentGraphState
+
+InputT = TypeVar("InputT", bound=BaseModel)
+OutputT = TypeVar("OutputT", bound=BaseModel)
+
+
+def create_state_with_input(input_schema: Type[InputT]):
+    InnerAgentGraphState = type(
+        "InnerAgentGraphState",
+        (AgentGraphState, input_schema),
+        {},
+    )
+
+    cast(type[BaseModel], InnerAgentGraphState).model_rebuild()
+    return InnerAgentGraphState
+
+
+def create_agent(
+    model: BaseChatModel,
+    tools: Sequence[BaseTool],
+    messages: Sequence[SystemMessage | HumanMessage]
+    | Callable[[InputT], Sequence[SystemMessage | HumanMessage]],
+    *,
+    input_schema: Type[InputT] | None = None,
+    output_schema: Type[OutputT] | None = None,
+    config: AgentGraphConfig | None = None,
+    guardrails: Sequence[tuple[BaseGuardrail, GuardrailAction]] | None = None,
+) -> StateGraph[AgentGraphState, None, InputT, OutputT]:
+    """Build agent graph with INIT -> AGENT(subgraph) <-> TOOLS loop, terminated by control flow tools.
+
+    The AGENT node is a subgraph that runs:
+    - before-agent guardrail middlewares
+    - the LLM tool-executing node
+    - after-agent guardrail middlewares
+
+    Control flow tools (end_execution, raise_error) are auto-injected alongside regular tools.
+    """
+    if config is None:
+        config = AgentGraphConfig()
+
+    os.environ["LANGCHAIN_RECURSION_LIMIT"] = str(config.recursion_limit)
+
+    agent_tools = list(tools)
+    flow_control_tools: list[BaseTool] = create_flow_control_tools(output_schema)
+    llm_tools: list[BaseTool] = [*agent_tools, *flow_control_tools]
+
+    init_node = create_init_node(messages)
+    tool_nodes = create_tool_node(agent_tools)
+    tool_nodes_with_guardrails = create_tools_guardrails_subgraph(
+        tool_nodes, guardrails
+    )
+    terminate_node = create_terminate_node(output_schema)
+
+    InnerAgentGraphState = create_state_with_input(
+        input_schema if input_schema is not None else BaseModel
+    )
+
+    builder: StateGraph[AgentGraphState, None, InputT, OutputT] = StateGraph(
+        InnerAgentGraphState, input_schema=input_schema, output_schema=output_schema
+    )
+    builder.add_node(AgentGraphNode.INIT, init_node)
+
+    for tool_name, tool_node in tool_nodes_with_guardrails.items():
+        builder.add_node(tool_name, tool_node)
+
+    builder.add_node(AgentGraphNode.TERMINATE, terminate_node)
+
+    builder.add_edge(START, AgentGraphNode.INIT)
+
+    llm_node = create_llm_node(model, llm_tools)
+    llm_with_guardrails_subgraph = create_llm_guardrails_subgraph(
+        (AgentGraphNode.LLM, llm_node), guardrails
+    )
+    builder.add_node(AgentGraphNode.AGENT, llm_with_guardrails_subgraph)
+    builder.add_edge(AgentGraphNode.INIT, AgentGraphNode.AGENT)
+
+    tool_node_names = list(tool_nodes_with_guardrails.keys())
+    builder.add_conditional_edges(
+        AgentGraphNode.AGENT,
+        route_agent,
+        [AgentGraphNode.AGENT, *tool_node_names, AgentGraphNode.TERMINATE],
+    )
+
+    for tool_name in tool_node_names:
+        builder.add_edge(tool_name, AgentGraphNode.AGENT)
+
+    builder.add_edge(AgentGraphNode.TERMINATE, END)
+
+    return builder

uipath_langchain/agent/react/constants.py

@@ -0,0 +1,2 @@
+# Agent routing configuration
+MAX_SUCCESSIVE_COMPLETIONS = 1

uipath_langchain/agent/react/init_node.py

@@ -0,0 +1,20 @@
+"""State initialization node for the ReAct Agent graph."""
+
+from typing import Any, Callable, Sequence
+
+from langchain_core.messages import HumanMessage, SystemMessage
+
+
+def create_init_node(
+    messages: Sequence[SystemMessage | HumanMessage]
+    | Callable[[Any], Sequence[SystemMessage | HumanMessage]],
+):
+    def graph_state_init(state: Any):
+        if callable(messages):
+            resolved_messages = messages(state)
+        else:
+            resolved_messages = messages
+
+        return {"messages": list(resolved_messages)}
+
+    return graph_state_init