uipath-langchain 0.0.140__py3-none-any.whl → 0.0.142__py3-none-any.whl

uipath_langchain/_cli/_runtime/_context.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Union
+from typing import Optional
 
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from uipath._cli._runtime._contracts import UiPathRuntimeContext
@@ -7,10 +7,4 @@ from uipath._cli._runtime._contracts import UiPathRuntimeContext
 class LangGraphRuntimeContext(UiPathRuntimeContext):
     """Context information passed throughout the runtime execution."""
 
-    output: Optional[Any] = None
-    state: Optional[Any] = (
-        None  # TypedDict issue, the actual type is: Optional[langgraph.types.StateSnapshot]
-    )
     memory: Optional[AsyncSqliteSaver] = None
-    langsmith_tracing_enabled: Union[str, bool, None] = False
-    resume_triggers_table: str = "__uipath_resume_triggers"

uipath_langchain/_cli/_runtime/_input.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Any, Optional, cast
 
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.types import Command
 from uipath._cli._runtime._contracts import (
     UiPathApiTrigger,
@@ -17,123 +18,130 @@ from ._exception import LangGraphRuntimeError
 logger = logging.getLogger(__name__)
 
 
-class LangGraphInputProcessor:
+async def get_graph_input(
+    context: LangGraphRuntimeContext,
+    memory: AsyncSqliteSaver,
+    resume_triggers_table: str = "__uipath_resume_triggers",
+) -> Any:
     """
-    Handles input processing for graph execution, including resume scenarios
-    where it needs to fetch data from UiPath.
+    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
+
+    Args:
+        context: The runtime context for the graph execution.
+        memory: AsyncSqliteSaver. The async database saver used to fetch resume trigger data.
+        resume_triggers_table: str, optional. The name of the database table containing resume triggers (default: "__uipath_resume_triggers").
+
+    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.
     """
-
-    def __init__(self, context: LangGraphRuntimeContext):
-        """
-        Initialize the LangGraphInputProcessor.
-
-        Args:
-            context: The runtime context for the graph execution.
-        """
-        self.context = context
-
-    async def process(self) -> Any:
-        """
-        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}")
-
-        if not self.context.resume:
-            if self.context.input_message:
-                return {
-                    "messages": uipath_to_human_messages(self.context.input_message)
-                }
-            return self.context.input_json
-
-        if self.context.input_json:
-            return Command(resume=self.context.input_json)
-
-        trigger = await self._get_latest_trigger()
-        if not trigger:
-            return Command(resume=self.context.input_json)
-
-        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"Resumed: {context.resume} Input: {context.input_json}")
+
+    # Fresh execution - return input directly
+    if not context.resume:
+        if context.input_message:
+            return {"messages": uipath_to_human_messages(context.input_message)}
+        return context.input_json
+
+    # Resume with explicit input provided
+    if context.input_json:
+        return Command(resume=context.input_json)
+
+    # Resume from database trigger
+    trigger = await _get_latest_trigger(
+        memory, resume_triggers_table=resume_triggers_table
+    )
+    if not trigger:
+        return Command(resume=context.input_json)
+
+    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"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
-            )
-        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 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:
-            await self.context.memory.setup()
-            async with (
-                self.context.memory.lock,
-                self.context.memory.conn.cursor() as cur,
-            ):
-                await cur.execute(f"""
-                    SELECT type, key, folder_path, folder_key, payload
-                    FROM {self.context.resume_triggers_table}
-                    ORDER BY timestamp DESC
-                    LIMIT 1
-                """)
-                result = await cur.fetchone()
-                if result is None:
-                    return None
-                return cast(tuple[str, str, str, str, str], tuple(result))
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "DB_QUERY_FAILED",
-                "Database query failed",
-                f"Error querying resume trigger information: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
+
+    return Command(resume=await HitlReader.read(resume_trigger))
+
+
+async def _get_latest_trigger(
+    memory: AsyncSqliteSaver,
+    resume_triggers_table: str = "__uipath_resume_triggers",
+) -> Optional[tuple[str, str, str, str, str]]:
+    """
+    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
+
+    Args:
+        memory: The AsyncSqliteSaver instance used to access the database.
+        resume_triggers_table: The name of the table containing resume triggers (default: "__uipath_resume_triggers").
+
+    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 memory is None:
+        return None
+
+    try:
+        await memory.setup()
+        async with (
+            memory.lock,
+            memory.conn.cursor() as cur,
+        ):
+            await cur.execute(f"""
+                SELECT type, key, folder_path, folder_key, payload
+                FROM {resume_triggers_table}
+                ORDER BY timestamp DESC
+                LIMIT 1
+            """)
+            result = await cur.fetchone()
+            if result is None:
+                return None
+            return cast(tuple[str, str, str, str, str], tuple(result))
+    except Exception as e:
+        raise LangGraphRuntimeError(
+            "DB_QUERY_FAILED",
+            "Database query failed",
+            f"Error querying resume trigger information: {str(e)}",
+            UiPathErrorCategory.SYSTEM,
+        ) from e

uipath_langchain/_cli/_runtime/_output.py

@@ -1,234 +1,148 @@
 import json
 import logging
-from functools import cached_property
-from typing import Any, Dict, Optional, cast
+from typing import Any
 
-from langgraph.types import Interrupt, StateSnapshot
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from uipath._cli._runtime._contracts import (
     UiPathErrorCategory,
     UiPathResumeTrigger,
-    UiPathRuntimeResult,
-    UiPathRuntimeStatus,
 )
 from uipath._cli._runtime._hitl import HitlProcessor
 
-from ._context import LangGraphRuntimeContext
 from ._exception import LangGraphRuntimeError
 
 logger = logging.getLogger(__name__)
 
 
-class LangGraphOutputProcessor:
-    """
-    Contains and manages the complete output information from graph execution.
-    Handles serialization, interrupt data, and file output.
+def serialize_output(output: Any) -> Any:
     """
+    Recursively serialize an output object.
 
-    def __init__(self, context: LangGraphRuntimeContext) -> None:
-        """
-        Initialize the LangGraphOutputProcessor.
-
-        Args:
-            context: The runtime context for the graph execution.
-        """
-        self.context = context
-        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, context.state)
-        if not state or not hasattr(state, "next") or not state.next:
-            return instance
-
-        for task in state.tasks:
-            if hasattr(task, "interrupts") and task.interrupts:
-                for interrupt in task.interrupts:
-                    if isinstance(interrupt, Interrupt):
-                        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._hitl_processor
-            else UiPathRuntimeStatus.SUCCESSFUL
-        )
-
-    @cached_property
-    def serialized_output(self) -> Dict[str, Any]:
-        """Serializes the graph execution result."""
-        try:
-            if self.context.output is None:
-                return {}
+    Args:
+        output: The object to serialize
 
-            return self._serialize_object(self.context.output)
+    Returns:
+        Dict[str, Any]: Serialized output as dictionary
+    """
+    if output is None:
+        return {}
+
+    # Handle Pydantic models
+    if hasattr(output, "model_dump"):
+        return serialize_output(output.model_dump(by_alias=True))
+    elif hasattr(output, "dict"):
+        return serialize_output(output.dict())
+    elif hasattr(output, "to_dict"):
+        return serialize_output(output.to_dict())
+
+    # Handle dictionaries
+    elif isinstance(output, dict):
+        return {k: serialize_output(v) for k, v in output.items()}
+
+    # Handle lists
+    elif isinstance(output, list):
+        return [serialize_output(item) for item in output]
+
+    # Handle other iterables (convert to dict first)
+    elif hasattr(output, "__iter__") and not isinstance(output, (str, bytes)):
+        try:
+            return serialize_output(dict(output))
+        except (TypeError, ValueError):
+            return output
 
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "OUTPUT_SERIALIZATION_FAILED",
-                "Failed to serialize graph output",
-                f"Error serializing output data: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
+    # Return primitive types as is
+    return output
 
-    def _serialize_object(self, obj):
-        """Recursively serializes an object and all its nested components."""
-        # Handle Pydantic models
-        if hasattr(obj, "dict"):
-            return self._serialize_object(obj.dict())
-        elif hasattr(obj, "model_dump"):
-            return self._serialize_object(obj.model_dump(by_alias=True))
-        elif hasattr(obj, "to_dict"):
-            return self._serialize_object(obj.to_dict())
-        # Handle dictionaries
-        elif isinstance(obj, dict):
-            return {k: self._serialize_object(v) for k, v in obj.items()}
-        # Handle lists
-        elif isinstance(obj, list):
-            return [self._serialize_object(item) for item in obj]
-        # Handle other iterable objects (convert to dict first)
-        elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
-            try:
-                return self._serialize_object(dict(obj))
-            except (TypeError, ValueError):
-                return obj
-        # Return primitive types as is
-        else:
-            return obj
 
-    async def process(self) -> UiPathRuntimeResult:
-        """
-        Process the output and prepare the final execution result.
+async def create_and_save_resume_trigger(
+    interrupt_value: Any,
+    memory: AsyncSqliteSaver,
+    resume_triggers_table: str = "__uipath_resume_triggers",
+) -> UiPathResumeTrigger:
+    """
+    Create a resume trigger from interrupt value and save it to the database.
 
-        Returns:
-            UiPathRuntimeResult: The processed execution result.
+    Args:
+        interrupt_value: The interrupt value from dynamic interrupt
+        memory: The SQLite checkpointer/memory instance
+        resume_triggers_table: Name of the resume triggers table
 
-        Raises:
-            LangGraphRuntimeError: If processing fails.
-        """
-        try:
-            await self._save_resume_trigger()
+    Returns:
+        UiPathResumeTrigger: The created resume trigger
 
-            return UiPathRuntimeResult(
-                output=self.serialized_output,
-                status=self.status,
-                resume=self._resume_trigger if self._resume_trigger else None,
-            )
+    Raises:
+        LangGraphRuntimeError: If database operations fail
+    """
+    # Create HITL processor
+    hitl_processor = HitlProcessor(interrupt_value)
 
-        except LangGraphRuntimeError:
-            raise
+    # Setup database and create table if needed
+    await memory.setup()
+    async with memory.lock, memory.conn.cursor() as cur:
+        try:
+            await cur.execute(f"""
+                CREATE TABLE IF NOT EXISTS {resume_triggers_table} (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    type TEXT NOT NULL,
+                    key TEXT,
+                    folder_key TEXT,
+                    folder_path TEXT,
+                    payload TEXT,
+                    timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%S', 'now', 'utc'))
+                )
+            """)
         except Exception as e:
             raise LangGraphRuntimeError(
-                "OUTPUT_PROCESSING_FAILED",
-                "Failed to process execution output",
-                f"Unexpected error during output processing: {str(e)}",
+                "DB_TABLE_CREATION_FAILED",
+                "Failed to create resume triggers table",
+                f"Database error while creating table: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
             ) from e
 
-    async def _save_resume_trigger(self) -> None:
-        """
-        Stores the resume trigger in the SQLite database if available.
+        # Create resume trigger
+        try:
+            resume_trigger = await hitl_processor.create_resume_trigger()
+        except Exception as e:
+            raise LangGraphRuntimeError(
+                "HITL_EVENT_CREATION_FAILED",
+                "Failed to process HITL request",
+                f"Error while trying to process HITL request: {str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
 
-        Raises:
-            LangGraphRuntimeError: If database operations fail.
-        """
-        if not self._hitl_processor or not self.context.memory:
-            return
+        # Save to database
+        if resume_trigger.api_resume:
+            trigger_key = resume_trigger.api_resume.inbox_id
+        else:
+            trigger_key = resume_trigger.item_key
 
         try:
-            await self.context.memory.setup()
-            async with (
-                self.context.memory.lock,
-                self.context.memory.conn.cursor() as cur,
-            ):
-                try:
-                    await cur.execute(f"""
-                        CREATE TABLE IF NOT EXISTS {self.context.resume_triggers_table} (
-                            id INTEGER PRIMARY KEY AUTOINCREMENT,
-                            type TEXT NOT NULL,
-                            key TEXT,
-                            folder_key TEXT,
-                            folder_path TEXT,
-                            payload TEXT,
-                            timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%S', 'now', 'utc'))
-                        )
-                    """)
-                except Exception as e:
-                    raise LangGraphRuntimeError(
-                        "DB_TABLE_CREATION_FAILED",
-                        "Failed to create resume triggers table",
-                        f"Database error while creating table: {str(e)}",
-                        UiPathErrorCategory.SYSTEM,
-                    ) from e
-
-                try:
-                    self._resume_trigger = (
-                        await self._hitl_processor.create_resume_trigger()
-                    )
-                except Exception as e:
-                    raise LangGraphRuntimeError(
-                        "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
+            logger.debug(
+                f"ResumeTrigger: {resume_trigger.trigger_type} {resume_trigger.item_key}"
+            )
+
+            if isinstance(resume_trigger.payload, dict):
+                payload = json.dumps(resume_trigger.payload)
+            else:
+                payload = str(resume_trigger.payload)
+
+            await cur.execute(
+                f"INSERT INTO {resume_triggers_table} (type, key, payload, folder_path, folder_key) VALUES (?, ?, ?, ?, ?)",
+                (
+                    resume_trigger.trigger_type.value,
+                    trigger_key,
+                    payload,
+                    resume_trigger.folder_path,
+                    resume_trigger.folder_key,
+                ),
+            )
+            await memory.conn.commit()
         except Exception as e:
             raise LangGraphRuntimeError(
-                "RESUME_TRIGGER_SAVE_FAILED",
+                "DB_INSERT_FAILED",
                 "Failed to save resume trigger",
-                f"Unexpected error while saving resume trigger: {str(e)}",
+                f"Database error while saving resume trigger: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
             ) from e
+
+    return resume_trigger