uipath-langchain 0.0.110__py3-none-any.whl → 0.0.111__py3-none-any.whl

uipath_langchain/_cli/_runtime/_input.py

@@ -1,29 +1,22 @@
-import json
 import logging
 from typing import Any, Optional, cast
 
 from langgraph.types import Command
 from uipath import UiPath
 from uipath._cli._runtime._contracts import (
+    UiPathApiTrigger,
     UiPathErrorCategory,
+    UiPathResumeTrigger,
     UiPathResumeTriggerType,
-    UiPathRuntimeStatus,
 )
+from uipath._cli._runtime._hitl import HitlReader
 
 from ._context import LangGraphRuntimeContext
-from ._escalation import Escalation
 from ._exception import LangGraphRuntimeError
 
 logger = logging.getLogger(__name__)
 
 
-def try_convert_to_json_format(value: str) -> str:
-    try:
-        return json.loads(value)
-    except json.decoder.JSONDecodeError:
-        return value
-
-
 class LangGraphInputProcessor:
     """
     Handles input processing for graph execution, including resume scenarios
@@ -38,13 +31,29 @@ class LangGraphInputProcessor:
             context: The runtime context for the graph execution.
         """
         self.context = context
-        self.escalation = Escalation(self.context.config_path)
         self.uipath = UiPath()
 
     async def process(self) -> Any:
         """
-        Process the input data, handling resume scenarios by fetching
-        necessary data from UiPath if needed.
+        Process the input data for graph execution, handling both fresh starts and resume scenarios.
+
+        This method determines whether the graph is being executed fresh or resumed from a previous state.
+        For fresh executions, it returns the input JSON directly. For resume scenarios, it fetches
+        the latest trigger information from the database and constructs a Command object with the
+        appropriate resume data.
+
+        The method handles different types of resume triggers:
+        - API triggers: Creates an UiPathApiTrigger with inbox_id and request payload
+        - Other triggers: Uses the HitlReader to process the resume data
+
+        Returns:
+            Any: For fresh executions, returns the input JSON data directly.
+                 For resume scenarios, returns a Command object containing the resume data
+                 processed through the appropriate trigger handler.
+
+        Raises:
+            LangGraphRuntimeError: If there's an error fetching trigger data from the database
+                during resume processing.
         """
         logger.debug(f"Resumed: {self.context.resume} Input: {self.context.input_json}")
 
@@ -58,47 +67,48 @@ class LangGraphInputProcessor:
         if not trigger:
             return Command(resume=self.context.input_json)
 
-        type, key, folder_path, folder_key, payload = trigger
-        logger.debug(f"ResumeTrigger: {type} {key}")
-        if type == UiPathResumeTriggerType.ACTION.value and key:
-            action = await self.uipath.actions.retrieve_async(
-                key, app_folder_key=folder_key, app_folder_path=folder_path
+        trigger_type, key, folder_path, folder_key, payload = trigger
+        resume_trigger = UiPathResumeTrigger(
+            trigger_type=trigger_type,
+            item_key=key,
+            folder_path=folder_path,
+            folder_key=folder_key,
+            payload=payload,
+        )
+        logger.debug(f"ResumeTrigger: {trigger_type} {key}")
+
+        # populate back expected fields for api_triggers
+        if resume_trigger.trigger_type == UiPathResumeTriggerType.API:
+            resume_trigger.api_resume = UiPathApiTrigger(
+                inbox_id=resume_trigger.item_key, request=resume_trigger.payload
             )
-            logger.debug(f"Action: {action}")
-            if action.data is None:
-                return Command(resume={})
-            if self.escalation and self.escalation.enabled:
-                extracted_value = self.escalation.extract_response_value(action.data)
-                return Command(resume=extracted_value)
-            return Command(resume=action.data)
-        elif type == UiPathResumeTriggerType.API.value and key:
-            payload = await self._get_api_payload(key)
-            if payload:
-                return Command(resume=payload)
-        elif type == UiPathResumeTriggerType.JOB.value and key:
-            job = await self.uipath.jobs.retrieve_async(key)
-            if (
-                job.state
-                and not job.state.lower()
-                == UiPathRuntimeStatus.SUCCESSFUL.value.lower()
-            ):
-                error_code = "INVOKED_PROCESS_FAILURE"
-                error_title = "Invoked process did not finish successfully."
-                error_detail = try_convert_to_json_format(
-                    str(job.job_error or job.info)
-                )
-                raise LangGraphRuntimeError(
-                    error_code,
-                    error_title,
-                    error_detail,
-                    UiPathErrorCategory.USER,
-                )
-            if job.output_arguments:
-                return Command(resume=try_convert_to_json_format(job.output_arguments))
-        return Command(resume=self.context.input_json)
+        return Command(resume=await HitlReader.read(resume_trigger))
 
     async def _get_latest_trigger(self) -> Optional[tuple[str, str, str, str, str]]:
-        """Fetch the most recent trigger from the database."""
+        """
+        Fetch the most recent resume trigger from the database.
+
+        This private method queries the resume triggers table to retrieve the latest trigger
+        information based on timestamp. It handles database connection setup and executes
+        a SQL query to fetch trigger data needed for resume operations.
+
+        The method returns trigger information as a tuple containing:
+        - type: The type of trigger (e.g., 'API', 'MANUAL', etc.)
+        - key: The unique identifier for the trigger/item
+        - folder_path: The path to the folder containing the trigger
+        - folder_key: The unique identifier for the folder
+        - payload: The serialized payload data associated with the trigger
+
+        Returns:
+            Optional[tuple[str, str, str, str, str]]: A tuple containing (type, key, folder_path,
+                folder_key, payload) for the most recent trigger, or None if no triggers are found
+                or if the memory context is not available.
+
+        Raises:
+            LangGraphRuntimeError: If there's an error during database connection setup, query
+                execution, or result fetching. The original exception is wrapped with context
+                about the database operation failure.
+        """
         if self.context.memory is None:
             return None
         try:
@@ -124,30 +134,3 @@ class LangGraphInputProcessor:
                 f"Error querying resume trigger information: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
             ) from e
-
-    async def _get_api_payload(self, inbox_id: str) -> Any:
-        """
-        Fetch payload data for API triggers.
-
-        Args:
-            inbox_id: The Id of the inbox to fetch the payload for.
-
-        Returns:
-            The value field from the API response payload, or None if an error occurs.
-        """
-        try:
-            response = self.uipath.api_client.request(
-                "GET",
-                f"/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
-                include_folder_headers=True,
-            )
-            data = response.json()
-            return data.get("payload")
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "API_CONNECTION_ERROR",
-                "Failed to get trigger payload",
-                f"Error fetching API trigger payload for inbox {inbox_id}: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-                response.status_code,
-            ) from e

uipath_langchain/_cli/_runtime/_output.py

@@ -1,95 +1,30 @@
 import json
 import logging
-import uuid
-from dataclasses import asdict, dataclass
 from functools import cached_property
-from typing import Any, Dict, Optional, Union, cast
+from typing import Any, Dict, Optional, cast
 
 from langgraph.types import Interrupt, StateSnapshot
-from uipath import UiPath
 from uipath._cli._runtime._contracts import (
-    UiPathApiTrigger,
     UiPathErrorCategory,
     UiPathResumeTrigger,
-    UiPathResumeTriggerType,
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
-from uipath.models import CreateAction, InvokeProcess, WaitAction, WaitJob
-from uipath.models.actions import Action
+from uipath._cli._runtime._hitl import HitlProcessor
 
 from ._context import LangGraphRuntimeContext
-from ._escalation import Escalation
 from ._exception import LangGraphRuntimeError
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class InterruptInfo:
-    """Contains all information about an interrupt."""
-
-    value: Any
-
-    @property
-    def type(self) -> Optional[UiPathResumeTriggerType]:
-        """Returns the type of the interrupt value."""
-        if isinstance(self.value, CreateAction):
-            return UiPathResumeTriggerType.ACTION
-        if isinstance(self.value, WaitAction):
-            return UiPathResumeTriggerType.ACTION
-        if isinstance(self.value, InvokeProcess):
-            return UiPathResumeTriggerType.JOB
-        if isinstance(self.value, WaitJob):
-            return UiPathResumeTriggerType.JOB
-        return None
-
-    @property
-    def identifier(self) -> Optional[str]:
-        """Returns the identifier based on the type."""
-        if isinstance(self.value, Action):
-            return str(self.value.key)
-        return None
-
-    def serialize(self) -> str:
-        """
-        Converts the interrupt value to a JSON string if possible,
-        falls back to string representation if not.
-        """
-        try:
-            if hasattr(self.value, "dict"):
-                data = self.value.dict()
-            elif hasattr(self.value, "to_dict"):
-                data = self.value.to_dict()
-            elif hasattr(self.value, "__dataclass_fields__"):
-                data = asdict(self.value)
-            else:
-                data = dict(self.value)
-
-            return json.dumps(data, default=str)
-        except (TypeError, ValueError, json.JSONDecodeError):
-            return str(self.value)
-
-    @cached_property
-    def resume_trigger(self) -> UiPathResumeTrigger:
-        """Creates the resume trigger based on interrupt type."""
-        if self.type is None:
-            return UiPathResumeTrigger(
-                api_resume=UiPathApiTrigger(
-                    inbox_id=str(uuid.uuid4()), request=self.serialize()
-                )
-            )
-        else:
-            return UiPathResumeTrigger(itemKey=self.identifier, triggerType=self.type)
-
-
 class LangGraphOutputProcessor:
     """
     Contains and manages the complete output information from graph execution.
     Handles serialization, interrupt data, and file output.
     """
 
-    def __init__(self, context: LangGraphRuntimeContext):
+    def __init__(self, context: LangGraphRuntimeContext) -> None:
         """
         Initialize the LangGraphOutputProcessor.
 
@@ -97,48 +32,47 @@ class LangGraphOutputProcessor:
             context: The runtime context for the graph execution.
         """
         self.context = context
-        self._interrupt_info: Optional[InterruptInfo] = None
+        self._hitl_processor: Optional[HitlProcessor] = None
         self._resume_trigger: Optional[UiPathResumeTrigger] = None
 
+    @classmethod
+    async def create(
+        cls, context: LangGraphRuntimeContext
+    ) -> "LangGraphOutputProcessor":
+        """
+        Create and initialize a new LangGraphOutputProcessor instance asynchronously.
+
+        Args:
+            context: The runtime context for the graph execution.
+
+        Returns:
+            LangGraphOutputProcessor: A new initialized instance.
+        """
+        instance = cls(context)
+
         # Process interrupt information during initialization
-        state = cast(StateSnapshot, self.context.state)
+        state = cast(StateSnapshot, context.state)
         if not state or not hasattr(state, "next") or not state.next:
-            return
+            return instance
 
         for task in state.tasks:
             if hasattr(task, "interrupts") and task.interrupts:
                 for interrupt in task.interrupts:
                     if isinstance(interrupt, Interrupt):
-                        self._interrupt_info = InterruptInfo(interrupt.value)
-                        self._resume_trigger = self._interrupt_info.resume_trigger
-                        return
+                        instance._hitl_processor = HitlProcessor(interrupt.value)
+                        return instance
+
+        return instance
 
     @property
     def status(self) -> UiPathRuntimeStatus:
         """Determines the execution status based on state."""
         return (
             UiPathRuntimeStatus.SUSPENDED
-            if self._interrupt_info
+            if self._hitl_processor
             else UiPathRuntimeStatus.SUCCESSFUL
         )
 
-    @property
-    def interrupt_value(self) -> Union[Action, InvokeProcess, Any]:
-        """Returns the actual value of the interrupt, with its specific type."""
-        if self.interrupt_info is None:
-            return None
-        return self.interrupt_info.value
-
-    @property
-    def interrupt_info(self) -> Optional[InterruptInfo]:
-        """Gets interrupt information if available."""
-        return self._interrupt_info
-
-    @property
-    def resume_trigger(self) -> Optional[UiPathResumeTrigger]:
-        """Gets resume trigger if interrupted."""
-        return self._resume_trigger
-
     @cached_property
     def serialized_output(self) -> Dict[str, Any]:
         """Serializes the graph execution result."""
@@ -197,7 +131,7 @@ class LangGraphOutputProcessor:
             return UiPathRuntimeResult(
                 output=self.serialized_output,
                 status=self.status,
-                resume=self.resume_trigger if self.resume_trigger else None,
+                resume=self._resume_trigger if self._resume_trigger else None,
             )
 
         except LangGraphRuntimeError:
@@ -217,7 +151,7 @@ class LangGraphOutputProcessor:
         Raises:
             LangGraphRuntimeError: If database operations fail.
         """
-        if not self.resume_trigger or not self.context.memory:
+        if not self._hitl_processor or not self.context.memory:
             return
 
         try:
@@ -247,122 +181,48 @@ class LangGraphOutputProcessor:
                     ) from e
 
                 try:
-                    default_escalation = Escalation()
-                    if default_escalation.enabled and isinstance(
-                        self.interrupt_value, str
-                    ):
-                        action = await default_escalation.create(self.interrupt_value)
-                        if action:
-                            self._resume_trigger = UiPathResumeTrigger(
-                                trigger_type=UiPathResumeTriggerType.ACTION,
-                                item_key=action.key,
-                            )
-                    if isinstance(self.interrupt_info, InterruptInfo):
-                        uipath_sdk = UiPath()
-                        if self.interrupt_info.type is UiPathResumeTriggerType.JOB:
-                            if isinstance(self.interrupt_value, InvokeProcess):
-                                job = await uipath_sdk.processes.invoke_async(
-                                    name=self.interrupt_value.name,
-                                    input_arguments=self.interrupt_value.input_arguments,
-                                )
-                                if job:
-                                    self._resume_trigger = UiPathResumeTrigger(
-                                        trigger_type=UiPathResumeTriggerType.JOB,
-                                        item_key=job.key,
-                                    )
-                            elif isinstance(self.interrupt_value, WaitJob):
-                                self._resume_trigger = UiPathResumeTrigger(
-                                    triggerType=UiPathResumeTriggerType.JOB,
-                                    itemKey=self.interrupt_value.job.key,
-                                )
-                        elif self.interrupt_info.type is UiPathResumeTriggerType.ACTION:
-                            if isinstance(self.interrupt_value, CreateAction):
-                                action = uipath_sdk.actions.create(
-                                    title=self.interrupt_value.title,
-                                    app_name=self.interrupt_value.app_name
-                                    if self.interrupt_value.app_name
-                                    else "",
-                                    app_folder_path=self.interrupt_value.app_folder_path
-                                    if self.interrupt_value.app_folder_path
-                                    else "",
-                                    app_folder_key=self.interrupt_value.app_folder_key
-                                    if self.interrupt_value.app_folder_key
-                                    else "",
-                                    app_key=self.interrupt_value.app_key
-                                    if self.interrupt_value.app_key
-                                    else "",
-                                    app_version=self.interrupt_value.app_version
-                                    if self.interrupt_value.app_version
-                                    else 1,
-                                    assignee=self.interrupt_value.assignee
-                                    if self.interrupt_value.assignee
-                                    else "",
-                                    data=self.interrupt_value.data,
-                                )
-                                if action:
-                                    self._resume_trigger = UiPathResumeTrigger(
-                                        trigger_type=UiPathResumeTriggerType.ACTION,
-                                        item_key=action.key,
-                                        payload=self.interrupt_value.model_dump_json(),
-                                        folder_path=self.interrupt_value.app_folder_path
-                                        if self.interrupt_value.app_folder_path
-                                        else None,
-                                        folder_key=self.interrupt_value.app_folder_key
-                                        if self.interrupt_value.app_folder_key
-                                        else None,
-                                    )
-                            elif isinstance(self.interrupt_value, WaitAction):
-                                self._resume_trigger = UiPathResumeTrigger(
-                                    triggerType=UiPathResumeTriggerType.ACTION,
-                                    itemKey=self.interrupt_value.action.key,
-                                    payload=self.interrupt_value.model_dump_json(),
-                                    folder_path=self.interrupt_value.app_folder_path
-                                    if self.interrupt_value.app_folder_path
-                                    else None,
-                                    folder_key=self.interrupt_value.app_folder_key
-                                    if self.interrupt_value.app_folder_key
-                                    else None,
-                                )
-
-                except Exception as e:
-                    raise LangGraphRuntimeError(
-                        "ESCALATION_CREATION_FAILED",
-                        "Failed to create escalation action",
-                        f"Error while creating escalation action: {str(e)}",
-                        UiPathErrorCategory.SYSTEM,
-                    ) from e
-
-                if (
-                    self.resume_trigger.trigger_type.value
-                    == UiPathResumeTriggerType.API.value
-                    and self.resume_trigger.api_resume
-                ):
-                    trigger_key = self.resume_trigger.api_resume.inbox_id
-                    trigger_type = self.resume_trigger.trigger_type.value
-                else:
-                    trigger_key = self.resume_trigger.item_key
-                    trigger_type = self.resume_trigger.trigger_type.value
-
-                try:
-                    logger.debug(f"ResumeTrigger: {trigger_type} {trigger_key}")
-                    await cur.execute(
-                        f"INSERT INTO {self.context.resume_triggers_table} (type, key, payload, folder_path, folder_key) VALUES (?, ?, ?, ?, ?)",
-                        (
-                            trigger_type,
-                            trigger_key,
-                            self.resume_trigger.payload,
-                            self.resume_trigger.folder_path,
-                            self.resume_trigger.folder_key,
-                        ),
+                    self._resume_trigger = (
+                        await self._hitl_processor.create_resume_trigger()
                     )
-                    await self.context.memory.conn.commit()
                 except Exception as e:
                     raise LangGraphRuntimeError(
-                        "DB_INSERT_FAILED",
-                        "Failed to save resume trigger",
-                        f"Database error while saving resume trigger: {str(e)}",
+                        "HITL_EVENT_CREATION_FAILED",
+                        "Failed to process HITL request",
+                        f"Error while trying to process HITL request: {str(e)}",
                         UiPathErrorCategory.SYSTEM,
                     ) from e
+                    # if API trigger, override item_key and payload
+                if self._resume_trigger:
+                    if self._resume_trigger.api_resume:
+                        trigger_key = self._resume_trigger.api_resume.inbox_id
+                    else:
+                        trigger_key = self._resume_trigger.item_key
+                    try:
+                        logger.debug(
+                            f"ResumeTrigger: {self._resume_trigger.trigger_type} {self._resume_trigger.item_key}"
+                        )
+                        if isinstance(self._resume_trigger.payload, dict):
+                            payload = json.dumps(self._resume_trigger.payload)
+                        else:
+                            payload = str(self._resume_trigger.payload)
+                        await cur.execute(
+                            f"INSERT INTO {self.context.resume_triggers_table} (type, key, payload, folder_path, folder_key) VALUES (?, ?, ?, ?, ?)",
+                            (
+                                self._resume_trigger.trigger_type.value,
+                                trigger_key,
+                                payload,
+                                self._resume_trigger.folder_path,
+                                self._resume_trigger.folder_key,
+                            ),
+                        )
+                        await self.context.memory.conn.commit()
+                    except Exception as e:
+                        raise LangGraphRuntimeError(
+                            "DB_INSERT_FAILED",
+                            "Failed to save resume trigger",
+                            f"Database error while saving resume trigger: {str(e)}",
+                            UiPathErrorCategory.SYSTEM,
+                        ) from e
         except LangGraphRuntimeError:
             raise
         except Exception as e:

uipath_langchain/_cli/_runtime/_runtime.py

@@ -1,9 +1,10 @@
 import json
 import logging
 import os
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from langchain_core.callbacks.base import BaseCallbackHandler
+from langchain_core.messages import BaseMessage
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.tracers.langchain import wait_for_all_tracers
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
@@ -103,48 +104,16 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 if self.context.job_id is None:
                     # Get final chunk while streaming
                     final_chunk = None
-                    async for chunk in graph.astream(
+                    async for stream_chunk in graph.astream(
                         processed_input,
                         graph_config,
-                        stream_mode="values",
+                        stream_mode="updates",
                         subgraphs=True,
                     ):
-                        logger.info("%s", chunk)
-                        final_chunk = chunk
+                        self._pretty_print(stream_chunk)
+                        final_chunk = stream_chunk
 
-                    # Extract data from the subgraph tuple format (namespace, data)
-                    if isinstance(final_chunk, tuple) and len(final_chunk) == 2:
-                        final_chunk = final_chunk[1]
-
-                    # Process the final chunk to match ainvoke's output format
-                    if isinstance(final_chunk, dict) and hasattr(
-                        graph, "output_channels"
-                    ):
-                        output_channels = graph.output_channels
-
-                        # Case 1: Single output channel as string
-                        if (
-                            isinstance(output_channels, str)
-                            and output_channels in final_chunk
-                        ):
-                            self.context.output = final_chunk[output_channels]
-
-                        # Case 2: Sequence of output channels
-                        elif hasattr(output_channels, "__iter__") and not isinstance(
-                            output_channels, str
-                        ):
-                            # Check if all channels are present in the chunk
-                            if all(ch in final_chunk for ch in output_channels):
-                                result = {}
-                                for channel in output_channels:
-                                    result[channel] = final_chunk[channel]
-                                self.context.output = result
-                            else:
-                                # Fallback if not all channels are present
-                                self.context.output = final_chunk
-                    else:
-                        # Use the whole chunk as output if we can't determine output channels
-                        self.context.output = final_chunk
+                    self.context.output = self._extract_graph_result(final_chunk, graph)
                 else:
                     # Execute the graph normally at runtime
                     self.context.output = await graph.ainvoke(
@@ -157,7 +126,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 except Exception:
                     pass
 
-                output_processor = LangGraphOutputProcessor(context=self.context)
+                output_processor = await LangGraphOutputProcessor.create(self.context)
 
                 self.context.result = await output_processor.process()
 
@@ -301,3 +270,102 @@ class LangGraphRuntime(UiPathBaseRuntime):
     async def cleanup(self):
         if hasattr(self, "graph_config") and self.graph_config:
             await self.graph_config.cleanup()
+
+    def _extract_graph_result(self, final_chunk, graph: CompiledStateGraph):
+        """
+        Extract the result from a LangGraph output chunk according to the graph's output channels.
+
+        Args:
+            final_chunk: The final chunk from graph.astream()
+            graph: The LangGraph instance
+
+        Returns:
+            The extracted result according to the graph's output_channels configuration
+        """
+        # Unwrap from subgraph tuple format if needed
+        if isinstance(final_chunk, tuple) and len(final_chunk) == 2:
+            final_chunk = final_chunk[
+                1
+            ]  # Extract data part from (namespace, data) tuple
+
+        # If the result isn't a dict or graph doesn't define output channels, return as is
+        if not isinstance(final_chunk, dict) or not hasattr(graph, "output_channels"):
+            return final_chunk
+
+        output_channels = graph.output_channels
+
+        # Case 1: Single output channel as string
+        if isinstance(output_channels, str):
+            if output_channels in final_chunk:
+                return final_chunk[output_channels]
+            else:
+                return final_chunk
+
+        # Case 2: Multiple output channels as sequence
+        elif hasattr(output_channels, "__iter__") and not isinstance(
+            output_channels, str
+        ):
+            # Check which channels are present
+            available_channels = [ch for ch in output_channels if ch in final_chunk]
+
+            if available_channels:
+                # Create a dict with the available channels
+                return {channel: final_chunk[channel] for channel in available_channels}
+
+        # Fallback for any other case
+        return final_chunk
+
+    def _pretty_print(self, stream_chunk: Union[Tuple[Any, Any], Dict[str, Any], Any]):
+        """
+        Pretty print a chunk from a LangGraph stream with stream_mode="updates" and subgraphs=True.
+
+        Args:
+            stream_chunk: A tuple of (namespace, updates) from graph.astream()
+        """
+        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
+            return
+
+        node_namespace = ""
+        chunk_namespace = stream_chunk[0]
+        node_updates = stream_chunk[1]
+
+        # Extract namespace if available
+        if chunk_namespace and len(chunk_namespace) > 0:
+            node_namespace = chunk_namespace[0]
+
+        if not isinstance(node_updates, dict):
+            logger.info("Raw update: %s", node_updates)
+            return
+
+        # Process each node's updates
+        for node_name, node_result in node_updates.items():
+            # Log node identifier with appropriate namespace context
+            if node_namespace:
+                logger.info("[%s][%s]", node_namespace, node_name)
+            else:
+                logger.info("[%s]", node_name)
+
+            # Handle non-dict results
+            if not isinstance(node_result, dict):
+                logger.info("%s", node_result)
+                continue
+
+            # Process messages specially
+            messages = node_result.get("messages", [])
+            if isinstance(messages, list):
+                for message in messages:
+                    if isinstance(message, BaseMessage):
+                        message.pretty_print()
+
+            # Exclude "messages" from node_result and pretty-print the rest
+            metadata = {k: v for k, v in node_result.items() if k != "messages"}
+            if metadata:
+                try:
+                    formatted_metadata = json.dumps(
+                        metadata,
+                        indent=2,
+                        ensure_ascii=False,
+                    )
+                    logger.info("%s", formatted_metadata)
+                except (TypeError, ValueError):
+                    pass

uipath_langchain/_cli/cli_run.py

@@ -25,12 +25,15 @@ def langgraph_run_middleware(
         )  # Continue with normal flow if no langgraph.json
 
     try:
+        bool_map = {"true": True, "false": False}
+        tracing = env.get("UIPATH_TRACING_ENABLED", True)
+        if isinstance(tracing, str) and tracing.lower() in bool_map:
+            tracing = bool_map[tracing.lower()]
 
         async def execute():
             context = LangGraphRuntimeContext.from_config(
                 env.get("UIPATH_CONFIG_PATH", "uipath.json")
             )
-
             context.entrypoint = entrypoint
             context.input = input
             context.resume = resume
@@ -38,9 +41,9 @@ def langgraph_run_middleware(
             context.logs_min_level = env.get("LOG_LEVEL", "INFO")
             context.job_id = env.get("UIPATH_JOB_KEY")
             context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
+            context.tracing_enabled = tracing
             context.trace_context = UiPathTraceContext(
-                enabled=env.get("UIPATH_TRACING_ENABLED", True),
+                enabled=tracing,
                 trace_id=env.get("UIPATH_TRACE_ID"),
                 parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
                 root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),

uipath_langchain/_utils/_settings.py

@@ -36,8 +36,12 @@ class UiPathClientSettings(BaseSettings):
     base_url: str = Field(default="", alias="UIPATH_BASE_URL")
     org_id: str = Field(default="", alias="UIPATH_ORGANIZATION_ID")
     tenant_id: str = Field(default="", alias="UIPATH_TENANT_ID")
-    requesting_product: str = Field(default="", alias="UIPATH_REQUESTING_PRODUCT")
-    requesting_feature: str = Field(default="", alias="UIPATH_REQUESTING_FEATURE")
+    requesting_product: str = Field(
+        default="uipath-python-sdk", alias="UIPATH_REQUESTING_PRODUCT"
+    )
+    requesting_feature: str = Field(
+        default="langgraph-agent", alias="UIPATH_REQUESTING_FEATURE"
+    )
     timeout_seconds: str = Field(default="120", alias="UIPATH_TIMEOUT_SECONDS")
     action_name: str = Field(default="DefaultActionName", alias="UIPATH_ACTION_NAME")
     action_id: str = Field(default="DefaultActionId", alias="UIPATH_ACTION_ID")

{uipath_langchain-0.0.110.dist-info → uipath_langchain-0.0.111.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.110
+Version: 0.0.111
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -24,7 +24,7 @@ Requires-Dist: langgraph>=0.2.70
 Requires-Dist: openai>=1.65.5
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.1.0,>=2.0.55
+Requires-Dist: uipath<2.1.0,>=2.0.65
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.110.dist-info → uipath_langchain-0.0.111.dist-info}/RECORD

@@ -3,19 +3,18 @@ uipath_langchain/middlewares.py,sha256=tre7o9DFMgWk1DJiEEUmT6_wiP-PPkWtKmG0iOyvr
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
 uipath_langchain/_cli/cli_init.py,sha256=B5BVUA7pDvKyRRGEx5mgmeE5SJvLPM3cnLGt6a9iixY,7417
 uipath_langchain/_cli/cli_new.py,sha256=dL8-Rri6u67ZZdbb4nT38A5xD_Q3fVnG0UK9VSeKaqg,2563
-uipath_langchain/_cli/cli_run.py,sha256=8-7NBguH3ACwN3bHEtyj2d3N-FFLJQLaiHDNI_3hnQE,2863
+uipath_langchain/_cli/cli_run.py,sha256=rGuYp9AEJdhHclOCFPX100Mo0kaDYt6e6pIKBgbS6ek,3023
 uipath_langchain/_cli/_runtime/_context.py,sha256=wr4aNn06ReIXmetEZ6b6AnpAt64p13anQ2trZ5Bzgio,807
-uipath_langchain/_cli/_runtime/_escalation.py,sha256=oA5NvZvCo8ngELFJRyhZNM69DxVHrshhMY6CUk_cukQ,8055
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
-uipath_langchain/_cli/_runtime/_input.py,sha256=gKzPaGW-EzgeAskWJjbCWnfZRLu_BM7lCXkq0XkVGLU,5614
-uipath_langchain/_cli/_runtime/_output.py,sha256=zGSGEUiWHg-q8-Ccm_NU8Vi-7oWCzq5GN1oFqO9FV9Q,16099
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=ai3qxNmdPACxowq7WcNBn9m8-KXe4vFwvpBn0lh6kmQ,11689
+uipath_langchain/_cli/_runtime/_input.py,sha256=vZ8vfVxvPSaPWmIPghvNx1VRKzbalHsKUMBPiKDvJWM,5492
+uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=SjOZkal6c1ZeZNFzW23DoAnF6LNQ2nN0dISSu2cSFhQ,13881
 uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
 uipath_langchain/_cli/_templates/main.py.template,sha256=9JEyPxwc4Ce8Dfd2UAgHgpwkkjuXwWXOQZ-65P53QuM,1195
 uipath_langchain/_cli/_utils/_graph.py,sha256=P7m03i6kcLda8XVpVtppcM8GOrSW62zWcv3rCR1H5zs,7086
 uipath_langchain/_utils/__init__.py,sha256=WoY66enCygRXTh6v5B1UrRcFCnQYuPJ8oqDkwomXzLc,194
 uipath_langchain/_utils/_request_mixin.py,sha256=t_1HWBxqEl-wsSk9ubmIM-8vs9BlNy4ZVBxtDxktn6U,18489
-uipath_langchain/_utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
+uipath_langchain/_utils/_settings.py,sha256=mCJ2-XXfpedjxT7DSXINPITHrXzQJCESgNo-nz3irDk,3450
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
 uipath_langchain/chat/models.py,sha256=sLz8yzEMUMSNsCFyywRxFwe2JisR3TP-n1vbeRKl9H8,10225
@@ -30,8 +29,8 @@ uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHb
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=eTa5sX43-ydB1pj9VNHUPbB-hC36fZK_CGrNe5U2Nrw,9393
-uipath_langchain-0.0.110.dist-info/METADATA,sha256=hgEO7QrBVpVmOUglrPN6Gi0VCZcKXGvuNjjgiC9lIPA,4166
-uipath_langchain-0.0.110.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.110.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.110.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.110.dist-info/RECORD,,
+uipath_langchain-0.0.111.dist-info/METADATA,sha256=joWYzrNDv0StGp2R_xBl4fNFxoCffcIi4mQ-2O84t9o,4166
+uipath_langchain-0.0.111.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.111.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.111.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.111.dist-info/RECORD,,

uipath_langchain/_cli/_runtime/_escalation.py

@@ -1,245 +0,0 @@
-import json
-import logging
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-from uipath import UiPath
-from uipath.models.actions import Action
-
-logger = logging.getLogger(__name__)
-
-
-class Escalation:
-    """
-    Class to handle default escalation.
-    """
-
-    def __init__(self, config_path: Union[str, Path] = "uipath.json"):
-        """
-        Initialize the escalation with a config file path.
-
-        Args:
-            config_path: Path to the configuration file (string or Path object)
-        """
-        self.config_path = Path(config_path)
-        self._config = None
-        self._enabled = False
-
-        self._load_config()
-
-    def _load_config(self) -> None:
-        """
-        Load and validate the default escalation from the config file.
-
-        If the 'defaultEscalation' section exists, validates required fields.
-        Raises error if required fields are missing.
-        """
-        try:
-            config_data = json.loads(self.config_path.read_text(encoding="utf-8"))
-            escalation_config = config_data.get("defaultEscalation")
-
-            if escalation_config:
-                required_fields = {"request", "title"}
-                missing_fields = [
-                    field for field in required_fields if field not in escalation_config
-                ]
-
-                if not any(key in escalation_config for key in ("appName", "appKey")):
-                    missing_fields.append("appName or appKey")
-
-                if missing_fields:
-                    raise ValueError(
-                        f"Missing required fields in configuration: {', '.join(missing_fields)}"
-                    )
-
-                self._config = escalation_config
-                self._enabled = True
-                logger.debug("Escalation configuration loaded successfully")
-            else:
-                self._enabled = False
-
-        except FileNotFoundError:
-            logger.debug(f"Config file not found: {self.config_path}")
-            self._enabled = False
-
-        except json.JSONDecodeError:
-            logger.warning(
-                f"Failed to parse config file {self.config_path}: Invalid JSON"
-            )
-            self._enabled = False
-
-        except ValueError as e:
-            logger.error(str(e))
-            raise
-
-        except Exception as e:
-            logger.error(f"Unexpected error loading config {self.config_path}: {e}")
-            self._enabled = False
-
-    @property
-    def enabled(self) -> bool:
-        """
-        Check if escalation is enabled.
-
-        Returns:
-            True if configuration is valid and loaded
-        """
-        return self._enabled
-
-    def prepare_data(self, value: Any) -> Dict[str, Any]:
-        """
-        Prepare action data by replacing $VALUE placeholders with the provided value.
-
-        Args:
-            value: The value to substitute into the template
-
-        Returns:
-            Prepared data dictionary with substitutions applied
-        """
-        if not self.enabled or not self._config:
-            return {}
-
-        template = self._config.get("request", {})
-
-        if isinstance(value, str):
-            try:
-                value_obj = json.loads(value)
-            except json.JSONDecodeError:
-                value_obj = value
-        else:
-            value_obj = value
-
-        return self._substitute_values(template, value_obj)
-
-    def _substitute_values(
-        self, template: Dict[str, Any], value: Any
-    ) -> Dict[str, Any]:
-        """
-        Replace template placeholders with actual values.
-
-        Args:
-            template: Template dictionary containing placeholders
-            value: Values to substitute into the template
-
-        Returns:
-            Template with values substituted
-        """
-
-        def process_value(template_value):
-            if isinstance(template_value, dict):
-                return {k: process_value(v) for k, v in template_value.items()}
-            elif isinstance(template_value, list):
-                return [process_value(item) for item in template_value]
-            elif isinstance(template_value, str):
-                if template_value == "$VALUE":
-                    return value
-                elif template_value.startswith("$VALUE."):
-                    return self._resolve_value_path(template_value, value)
-
-            return template_value
-
-        return process_value(template)
-
-    def _resolve_value_path(self, path_expr: str, value: Any) -> Any:
-        """
-        Resolve a dot-notation path expression against a value.
-
-        Args:
-            path_expr: Path expression (e.g. "$VALUE.user.name")
-            value: Value object to extract data from
-
-        Returns:
-            Extracted value or None if path doesn't exist
-        """
-        path_parts = path_expr.replace("$VALUE.", "").split(".")
-        current = value
-
-        for part in path_parts:
-            if not isinstance(current, dict) or part not in current:
-                return None
-            current = current.get(part)
-
-        return current
-
-    def extract_response_value(self, action_data: Dict[str, Any]) -> Any:
-        if not self._config:
-            return ""
-
-        response_template = self._config.get("response")
-        if not response_template:
-            return ""
-
-        for key, template_value in response_template.items():
-            if key in action_data:
-                extracted_value = None
-
-                if template_value == "$VALUE":
-                    extracted_value = action_data[key]
-                elif isinstance(template_value, str) and template_value.startswith(
-                    "$VALUE."
-                ):
-                    path_parts = template_value.replace("$VALUE.", "").split(".")
-                    current = action_data[key]
-
-                    valid_path = True
-                    for part in path_parts:
-                        if not isinstance(current, dict) or part not in current:
-                            valid_path = False
-                            break
-                        current = current.get(part)
-
-                    if valid_path:
-                        extracted_value = current
-
-                if extracted_value is not None:
-                    if isinstance(extracted_value, str):
-                        if extracted_value.lower() == "true":
-                            return True
-                        elif extracted_value.lower() == "false":
-                            return False
-
-                        try:
-                            if "." in extracted_value:
-                                return float(extracted_value)
-                            else:
-                                return int(extracted_value)
-                        except ValueError:
-                            pass
-
-                    return extracted_value
-
-        return action_data
-
-    async def create(self, value: Any) -> Optional[Action]:
-        """
-        Create an escalation Action with the prepared data.
-
-        Args:
-            value: The dynamic value to be substituted into the template
-
-        Returns:
-            The created Action object or None if creation fails
-        """
-        if not self.enabled or not self._config:
-            return None
-
-        action_data = self.prepare_data(value)
-
-        if not action_data:
-            logger.warning("Action creation skipped: empty data after preparation")
-            return None
-
-        try:
-            uipath = UiPath()
-            action = uipath.actions.create(
-                title=self._config.get("title", "Default escalation"),
-                app_name=self._config.get("appName"),
-                app_key=self._config.get("appKey"),
-                app_version=self._config.get("appVersion", 1),
-                data=action_data,
-            )
-            logger.info(f"Action created successfully: {action.key}")
-            return action
-        except Exception as e:
-            logger.error(f"Error creating action: {e}")
-            return None