uipath-langchain 0.0.142__tar.gz → 0.0.144__tar.gz

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.142
+Version: 0.0.144
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -26,7 +26,7 @@ Requires-Dist: openai>=1.65.5
 Requires-Dist: openinference-instrumentation-langchain>=0.1.50
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.2.0,>=2.1.101
+Requires-Dist: uipath<2.2.0,>=2.1.103
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.142"
+version = "0.0.144"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.101, <2.2.0",
+    "uipath>=2.1.103, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",
@@ -111,4 +111,4 @@ asyncio_mode = "auto"
 name = "testpypi"
 url = "https://test.pypi.org/simple/"
 publish-url = "https://test.pypi.org/legacy/"
-explicit = true
+explicit = true

uipath_langchain-0.0.144/src/uipath_langchain/_cli/_runtime/_exception.py

@@ -0,0 +1,43 @@
+from enum import Enum
+from typing import Optional, Union
+
+from uipath._cli._runtime._contracts import (
+    UiPathBaseRuntimeError,
+    UiPathErrorCategory,
+    UiPathErrorCode,
+)
+
+
+class LangGraphErrorCode(Enum):
+    CONFIG_MISSING = "CONFIG_MISSING"
+    CONFIG_INVALID = "CONFIG_INVALID"
+
+    GRAPH_NOT_FOUND = "GRAPH_NOT_FOUND"
+    GRAPH_IMPORT_ERROR = "GRAPH_IMPORT_ERROR"
+    GRAPH_TYPE_ERROR = "GRAPH_TYPE_ERROR"
+    GRAPH_VALUE_ERROR = "GRAPH_VALUE_ERROR"
+    GRAPH_LOAD_ERROR = "GRAPH_LOAD_ERROR"
+    GRAPH_INVALID_UPDATE = "GRAPH_INVALID_UPDATE"
+    GRAPH_EMPTY_INPUT = "GRAPH_EMPTY_INPUT"
+
+    DB_QUERY_FAILED = "DB_QUERY_FAILED"
+    DB_TABLE_CREATION_FAILED = "DB_TABLE_CREATION_FAILED"
+    HITL_EVENT_CREATION_FAILED = "HITL_EVENT_CREATION_FAILED"
+    DB_INSERT_FAILED = "DB_INSERT_FAILED"
+    LICENSE_NOT_AVAILABLE = "LICENSE_NOT_AVAILABLE"
+
+
+class LangGraphRuntimeError(UiPathBaseRuntimeError):
+    """Custom exception for LangGraph runtime errors with structured error information."""
+
+    def __init__(
+        self,
+        code: Union[LangGraphErrorCode, UiPathErrorCode],
+        title: str,
+        detail: str,
+        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        status: Optional[int] = None,
+    ):
+        super().__init__(
+            code.value, title, detail, category, status, prefix="LANGGRAPH"
+        )

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/_runtime/_graph_resolver.py

@@ -2,12 +2,10 @@ import asyncio
 from typing import Any, Awaitable, Callable, Optional
 
 from langgraph.graph.state import CompiledStateGraph, StateGraph
-from uipath._cli._runtime._contracts import (
-    UiPathErrorCategory,
-)
+from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathErrorCode
 
 from .._utils._graph import GraphConfig, LangGraphConfig
-from ._exception import LangGraphRuntimeError
+from ._exception import LangGraphErrorCode, LangGraphRuntimeError
 
 
 class LangGraphJsonResolver:
@@ -36,7 +34,7 @@ class LangGraphJsonResolver:
         config = LangGraphConfig()
         if not config.exists:
             raise LangGraphRuntimeError(
-                "CONFIG_MISSING",
+                LangGraphErrorCode.CONFIG_MISSING,
                 "Invalid configuration",
                 "Failed to load configuration",
                 UiPathErrorCategory.DEPLOYMENT,
@@ -46,7 +44,7 @@ class LangGraphJsonResolver:
             config.load_config()
         except Exception as e:
             raise LangGraphRuntimeError(
-                "CONFIG_INVALID",
+                LangGraphErrorCode.CONFIG_INVALID,
                 "Invalid configuration",
                 f"Failed to load configuration: {str(e)}",
                 UiPathErrorCategory.DEPLOYMENT,
@@ -59,7 +57,7 @@ class LangGraphJsonResolver:
         elif not entrypoint:
             graph_names = ", ".join(g.name for g in graphs)
             raise LangGraphRuntimeError(
-                "ENTRYPOINT_MISSING",
+                UiPathErrorCode.ENTRYPOINT_MISSING,
                 "Entrypoint required",
                 f"Multiple graphs available. Please specify one of: {graph_names}.",
                 UiPathErrorCategory.DEPLOYMENT,
@@ -69,7 +67,7 @@ class LangGraphJsonResolver:
         self.graph_config = config.get_graph(entrypoint)
         if not self.graph_config:
             raise LangGraphRuntimeError(
-                "GRAPH_NOT_FOUND",
+                LangGraphErrorCode.GRAPH_NOT_FOUND,
                 "Graph not found",
                 f"Graph '{entrypoint}' not found.",
                 UiPathErrorCategory.DEPLOYMENT,
@@ -83,28 +81,28 @@ class LangGraphJsonResolver:
             )
         except ImportError as e:
             raise LangGraphRuntimeError(
-                "GRAPH_IMPORT_ERROR",
+                LangGraphErrorCode.GRAPH_IMPORT_ERROR,
                 "Graph import failed",
                 f"Failed to import graph '{entrypoint}': {str(e)}",
                 UiPathErrorCategory.USER,
             ) from e
         except TypeError as e:
             raise LangGraphRuntimeError(
-                "GRAPH_TYPE_ERROR",
+                LangGraphErrorCode.GRAPH_TYPE_ERROR,
                 "Invalid graph type",
                 f"Graph '{entrypoint}' is not a valid StateGraph or CompiledStateGraph: {str(e)}",
                 UiPathErrorCategory.USER,
             ) from e
         except ValueError as e:
             raise LangGraphRuntimeError(
-                "GRAPH_VALUE_ERROR",
+                LangGraphErrorCode.GRAPH_VALUE_ERROR,
                 "Invalid graph value",
                 f"Invalid value in graph '{entrypoint}': {str(e)}",
                 UiPathErrorCategory.USER,
             ) from e
         except Exception as e:
             raise LangGraphRuntimeError(
-                "GRAPH_LOAD_ERROR",
+                LangGraphErrorCode.GRAPH_LOAD_ERROR,
                 "Failed to load graph",
                 f"Unexpected error loading graph '{entrypoint}': {str(e)}",
                 UiPathErrorCategory.USER,

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/_runtime/_input.py

@@ -13,7 +13,7 @@ from uipath._cli._runtime._hitl import HitlReader
 
 from ._context import LangGraphRuntimeContext
 from ._conversation import uipath_to_human_messages
-from ._exception import LangGraphRuntimeError
+from ._exception import LangGraphErrorCode, LangGraphRuntimeError
 
 logger = logging.getLogger(__name__)
 
@@ -140,7 +140,7 @@ async def _get_latest_trigger(
             return cast(tuple[str, str, str, str, str], tuple(result))
     except Exception as e:
         raise LangGraphRuntimeError(
-            "DB_QUERY_FAILED",
+            LangGraphErrorCode.DB_QUERY_FAILED,
             "Database query failed",
             f"Error querying resume trigger information: {str(e)}",
             UiPathErrorCategory.SYSTEM,

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/_runtime/_output.py

@@ -3,13 +3,10 @@ import logging
 from typing import Any
 
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from uipath._cli._runtime._contracts import (
-    UiPathErrorCategory,
-    UiPathResumeTrigger,
-)
+from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathResumeTrigger
 from uipath._cli._runtime._hitl import HitlProcessor
 
-from ._exception import LangGraphRuntimeError
+from ._exception import LangGraphErrorCode, LangGraphRuntimeError
 
 logger = logging.getLogger(__name__)
 
@@ -93,7 +90,7 @@ async def create_and_save_resume_trigger(
             """)
         except Exception as e:
             raise LangGraphRuntimeError(
-                "DB_TABLE_CREATION_FAILED",
+                LangGraphErrorCode.DB_TABLE_CREATION_FAILED,
                 "Failed to create resume triggers table",
                 f"Database error while creating table: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
@@ -104,7 +101,7 @@ async def create_and_save_resume_trigger(
             resume_trigger = await hitl_processor.create_resume_trigger()
         except Exception as e:
             raise LangGraphRuntimeError(
-                "HITL_EVENT_CREATION_FAILED",
+                LangGraphErrorCode.HITL_EVENT_CREATION_FAILED,
                 "Failed to process HITL request",
                 f"Error while trying to process HITL request: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
@@ -139,7 +136,7 @@ async def create_and_save_resume_trigger(
             await memory.conn.commit()
         except Exception as e:
             raise LangGraphRuntimeError(
-                "DB_INSERT_FAILED",
+                LangGraphErrorCode.DB_INSERT_FAILED,
                 "Failed to save resume trigger",
                 f"Database error while saving resume trigger: {str(e)}",
                 UiPathErrorCategory.SYSTEM,

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -12,6 +12,7 @@ from uipath._cli._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathBreakpointResult,
     UiPathErrorCategory,
+    UiPathErrorCode,
     UiPathResumeTrigger,
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
@@ -23,7 +24,7 @@ from uipath._events._events import (
 )
 
 from ._context import LangGraphRuntimeContext
-from ._exception import LangGraphRuntimeError
+from ._exception import LangGraphErrorCode, LangGraphRuntimeError
 from ._graph_resolver import AsyncResolver, LangGraphJsonResolver
 from ._input import get_graph_input
 from ._output import create_and_save_resume_trigger, serialize_output
@@ -79,7 +80,11 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 graph_config = self._get_graph_config()
 
                 # Execute without streaming
-                graph_output = await compiled_graph.ainvoke(graph_input, graph_config)
+                graph_output = await compiled_graph.ainvoke(
+                    graph_input,
+                    graph_config,
+                    interrupt_before=self.context.breakpoints,
+                )
 
                 # Get final state and create result
                 self.context.result = await self._create_runtime_result(
@@ -140,6 +145,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 async for stream_chunk in compiled_graph.astream(
                     graph_input,
                     graph_config,
+                    interrupt_before=self.context.breakpoints,
                     stream_mode=["messages", "updates"],
                     subgraphs=True,
                 ):
@@ -426,7 +432,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
         if isinstance(e, GraphRecursionError):
             return LangGraphRuntimeError(
-                "GRAPH_RECURSION_ERROR",
+                LangGraphErrorCode.GRAPH_LOAD_ERROR,
                 "Graph recursion limit exceeded",
                 detail,
                 UiPathErrorCategory.USER,
@@ -434,7 +440,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
         if isinstance(e, InvalidUpdateError):
             return LangGraphRuntimeError(
-                "GRAPH_INVALID_UPDATE",
+                LangGraphErrorCode.GRAPH_INVALID_UPDATE,
                 str(e),
                 detail,
                 UiPathErrorCategory.USER,
@@ -442,14 +448,14 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
         if isinstance(e, EmptyInputError):
             return LangGraphRuntimeError(
-                "GRAPH_EMPTY_INPUT",
+                LangGraphErrorCode.GRAPH_EMPTY_INPUT,
                 "The input data is empty",
                 detail,
                 UiPathErrorCategory.USER,
             )
 
         return LangGraphRuntimeError(
-            "EXECUTION_ERROR",
+            UiPathErrorCode.EXECUTION_ERROR,
             "Graph execution failed",
             detail,
             UiPathErrorCategory.USER,

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/cli_debug.py

@@ -12,8 +12,9 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
 )
 from uipath._cli.middlewares import MiddlewareResult
+from uipath.tracing import LlmOpsHttpExporter
 
-from .._tracing import LangChainExporter, _instrument_traceable_attributes
+from .._tracing import _instrument_traceable_attributes
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import (  # type: ignore[attr-defined]
     LangGraphRuntimeContext,
@@ -61,7 +62,9 @@ def langgraph_debug_middleware(
             )
 
             if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
+                runtime_factory.add_span_exporter(
+                    LlmOpsHttpExporter(extra_process_spans=True)
+                )
 
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/cli_eval.py

@@ -15,12 +15,12 @@ from uipath._cli._utils._eval_set import EvalHelpers
 from uipath._cli.middlewares import MiddlewareResult
 from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
+from uipath.tracing import LlmOpsHttpExporter
 
 from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
 from uipath_langchain._cli._runtime._runtime import LangGraphScriptRuntime
 from uipath_langchain._cli._utils._graph import LangGraphConfig
 from uipath_langchain._tracing import (
-    LangChainExporter,
     _instrument_traceable_attributes,
 )
 
@@ -41,7 +41,7 @@ def langgraph_eval_middleware(
 
         if kwargs.get("register_progress_reporter", False):
             progress_reporter = StudioWebProgressReporter(
-                spans_exporter=LangChainExporter()
+                spans_exporter=LlmOpsHttpExporter(extra_process_spans=True)
             )
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
         console_reporter = ConsoleProgressReporter()
@@ -76,7 +76,9 @@ def langgraph_eval_middleware(
         )
 
         if eval_context.job_id:
-            runtime_factory.add_span_exporter(LangChainExporter())
+            runtime_factory.add_span_exporter(
+                LlmOpsHttpExporter(extra_process_spans=True)
+            )
 
         runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_cli/cli_run.py

@@ -13,8 +13,11 @@ from uipath._cli._runtime._contracts import (
 )
 from uipath._cli.middlewares import MiddlewareResult
 from uipath._events._events import UiPathAgentStateEvent
+from uipath.tracing import JsonLinesFileExporter, LlmOpsHttpExporter
 
-from .._tracing import LangChainExporter, _instrument_traceable_attributes
+from .._tracing import (
+    _instrument_traceable_attributes,
+)
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import (  # type: ignore[attr-defined]
     LangGraphRuntimeContext,
@@ -24,7 +27,11 @@ from ._utils._graph import LangGraphConfig
 
 
 def langgraph_run_middleware(
-    entrypoint: Optional[str], input: Optional[str], resume: bool, **kwargs
+    entrypoint: Optional[str],
+    input: Optional[str],
+    resume: bool,
+    trace_file: Optional[str] = None,
+    **kwargs,
 ) -> MiddlewareResult:
     """Middleware to handle LangGraph execution"""
     config = LangGraphConfig()
@@ -61,8 +68,13 @@ def langgraph_run_middleware(
 
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 
+            if trace_file:
+                runtime_factory.add_span_exporter(JsonLinesFileExporter(trace_file))
+
             if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
+                runtime_factory.add_span_exporter(
+                    LlmOpsHttpExporter(extra_process_spans=True)
+                )
                 await runtime_factory.execute(context)
             else:
                 debug_bridge: UiPathDebugBridge = ConsoleDebugBridge()

uipath_langchain-0.0.144/src/uipath_langchain/_tracing/__init__.py

@@ -0,0 +1,5 @@
+from ._instrument_traceable import _instrument_traceable_attributes
+
+__all__ = [
+    "_instrument_traceable_attributes",
+]

{uipath_langchain-0.0.142 → uipath_langchain-0.0.144}/src/uipath_langchain/_utils/_request_mixin.py

@@ -20,7 +20,10 @@ from tenacity import (
 from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 
-from uipath_langchain._cli._runtime._exception import LangGraphRuntimeError
+from uipath_langchain._cli._runtime._exception import (
+    LangGraphErrorCode,
+    LangGraphRuntimeError,
+)
 from uipath_langchain._utils._settings import (
     UiPathClientFactorySettings,
     UiPathClientSettings,
@@ -371,7 +374,7 @@ class UiPathRequestMixin(BaseModel):
                 title = body.get("title", "").lower()
                 if title == "license not available":
                     raise LangGraphRuntimeError(
-                        code="LICENSE_NOT_AVAILABLE",
+                        code=LangGraphErrorCode.LICENSE_NOT_AVAILABLE,
                         title=body.get("title", "License Not Available"),
                         detail=body.get(
                             "detail", "License not available for this service"

uipath_langchain-0.0.144/src/uipath_langchain/agent/react/__init__.py

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

uipath_langchain-0.0.144/src/uipath_langchain/agent/react/agent.py

@@ -0,0 +1,76 @@
+import os
+from typing import Sequence, Type
+
+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 ..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 .state import AgentGraphNode, AgentGraphState
+from .terminate_node import (
+    create_terminate_node,
+)
+from .tools import create_flow_control_tools
+
+
+def create_agent(
+    model: BaseChatModel,
+    tools: Sequence[BaseTool],
+    messages: Sequence[SystemMessage | HumanMessage],
+    *,
+    state_schema: Type[AgentGraphState] = AgentGraphState,
+    response_format: type[BaseModel] | None = None,
+    recursion_limit: int = 50,
+) -> StateGraph[AgentGraphState]:
+    """Build agent graph with INIT -> AGENT <-> TOOLS loop, terminated by control flow tools.
+
+    Control flow tools (end_execution, raise_error) are auto-injected alongside regular tools.
+    """
+    os.environ["LANGCHAIN_RECURSION_LIMIT"] = str(recursion_limit)
+
+    agent_tools = list(tools)
+    flow_control_tools: list[BaseTool] = create_flow_control_tools(response_format)
+    llm_tools: list[BaseTool] = [*agent_tools, *flow_control_tools]
+
+    init_node = create_init_node(messages)
+    agent_node = create_llm_node(model, llm_tools)
+    tool_nodes = create_tool_node(agent_tools)
+    terminate_node = create_terminate_node(response_format)
+
+    builder: StateGraph[AgentGraphState] = StateGraph(state_schema)
+    builder.add_node(AgentGraphNode.INIT, init_node)
+    builder.add_node(AgentGraphNode.AGENT, agent_node)
+
+    for tool_name, tool_node in tool_nodes.items():
+        builder.add_node(tool_name, tool_node)
+
+    builder.add_node(AgentGraphNode.TERMINATE, terminate_node)
+
+    builder.add_edge(START, AgentGraphNode.INIT)
+    builder.add_edge(AgentGraphNode.INIT, AgentGraphNode.AGENT)
+
+    tool_node_names = list(tool_nodes.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-0.0.144/src/uipath_langchain/agent/react/constants.py

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

uipath_langchain-0.0.144/src/uipath_langchain/agent/react/exceptions.py

@@ -0,0 +1,11 @@
+"""Exceptions for the basic agent loop."""
+
+from uipath._cli._runtime._contracts import UiPathRuntimeError
+
+
+class AgentNodeRoutingException(Exception):
+    pass
+
+
+class AgentTerminationException(UiPathRuntimeError):
+    pass

uipath_langchain-0.0.144/src/uipath_langchain/agent/react/init_node.py

@@ -0,0 +1,16 @@
+"""State initialization node for the ReAct Agent graph."""
+
+from typing import Sequence
+
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from .state import AgentGraphState
+
+
+def create_init_node(
+    messages: Sequence[SystemMessage | HumanMessage],
+):
+    def graph_state_init(_: AgentGraphState):
+        return {"messages": list(messages)}
+
+    return graph_state_init

uipath_langchain-0.0.144/src/uipath_langchain/agent/react/llm_node.py

@@ -0,0 +1,44 @@
+"""LLM node implementation for LangGraph."""
+
+from typing import Sequence
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AIMessage, AnyMessage
+from langchain_core.tools import BaseTool
+
+from .constants import MAX_SUCCESSIVE_COMPLETIONS
+from .state import AgentGraphState
+from .utils import count_successive_completions
+
+
+def create_llm_node(
+    model: BaseChatModel,
+    tools: Sequence[BaseTool] | None = None,
+):
+    """Invoke LLM with tools and dynamically control tool_choice based on successive completions.
+
+    When successive completions reach the limit, tool_choice is set to "required" to force
+    the LLM to use a tool and prevent infinite reasoning loops.
+    """
+    bindable_tools = list(tools) if tools else []
+    base_llm = model.bind_tools(bindable_tools) if bindable_tools else model
+
+    async def llm_node(state: AgentGraphState):
+        messages: list[AnyMessage] = state["messages"]
+
+        successive_completions = count_successive_completions(messages)
+
+        if successive_completions >= MAX_SUCCESSIVE_COMPLETIONS and bindable_tools:
+            llm = base_llm.bind(tool_choice="required")
+        else:
+            llm = base_llm
+
+        response = await llm.ainvoke(messages)
+        if not isinstance(response, AIMessage):
+            raise TypeError(
+                f"LLM returned {type(response).__name__} instead of AIMessage"
+            )
+
+        return {"messages": [response]}
+
+    return llm_node