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

uipath_langchain/_cli/_runtime/_conversation.py

@@ -1,298 +0,0 @@
-import uuid
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-
-from langchain_core.messages import (
-    AIMessage,
-    AIMessageChunk,
-    BaseMessage,
-    HumanMessage,
-    ToolMessage,
-)
-from uipath.agent.conversation import (
-    UiPathConversationContentPartChunkEvent,
-    UiPathConversationContentPartEndEvent,
-    UiPathConversationContentPartEvent,
-    UiPathConversationContentPartStartEvent,
-    UiPathConversationEvent,
-    UiPathConversationExchangeEvent,
-    UiPathConversationMessage,
-    UiPathConversationMessageEndEvent,
-    UiPathConversationMessageEvent,
-    UiPathConversationMessageStartEvent,
-    UiPathConversationToolCallEndEvent,
-    UiPathConversationToolCallEvent,
-    UiPathConversationToolCallStartEvent,
-    UiPathInlineValue,
-)
-
-
-def _new_id() -> str:
-    return str(uuid.uuid4())
-
-
-def _wrap_in_conversation_event(
-    msg_event: UiPathConversationMessageEvent,
-    exchange_id: Optional[str] = None,
-    conversation_id: Optional[str] = None,
-) -> UiPathConversationEvent:
-    """Helper to wrap a message event into a conversation-level event."""
-    return UiPathConversationEvent(
-        conversation_id=conversation_id or _new_id(),
-        exchange=UiPathConversationExchangeEvent(
-            exchange_id=exchange_id or _new_id(),
-            message=msg_event,
-        ),
-    )
-
-
-def _extract_text(content) -> str:
-    """Normalize LangGraph message.content to plain text."""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        return "".join(
-            part.get("text", "")
-            for part in content
-            if isinstance(part, dict) and part.get("type") == "text"
-        )
-    return str(content or "")
-
-
-def uipath_to_human_messages(
-    uipath_msg: UiPathConversationMessage,
-) -> List[HumanMessage]:
-    """
-    Converts a UiPathConversationMessage into a list of HumanMessages for LangGraph.
-    Supports multimodal content parts (text, external content) and preserves metadata.
-    """
-    human_messages = []
-
-    # Loop over each content part
-    if uipath_msg.content_parts:
-        for part in uipath_msg.content_parts:
-            data = part.data
-            content = ""
-            metadata: Dict[str, Any] = {
-                "message_id": uipath_msg.message_id,
-                "content_part_id": part.content_part_id,
-                "mime_type": part.mime_type,
-                "created_at": uipath_msg.created_at,
-                "updated_at": uipath_msg.updated_at,
-            }
-
-            if isinstance(data, UiPathInlineValue):
-                content = str(data.inline)
-
-            # Append a HumanMessage for this content part
-            human_messages.append(HumanMessage(content=content, metadata=metadata))
-
-    # Handle the case where there are no content parts
-    else:
-        metadata = {
-            "message_id": uipath_msg.message_id,
-            "role": uipath_msg.role,
-            "created_at": uipath_msg.created_at,
-            "updated_at": uipath_msg.updated_at,
-        }
-        human_messages.append(HumanMessage(content="", metadata=metadata))
-
-    return human_messages
-
-
-def map_message(
-    message: BaseMessage,
-    exchange_id: Optional[str] = None,
-    conversation_id: Optional[str] = None,
-) -> Optional[UiPathConversationEvent]:
-    """Convert LangGraph BaseMessage (chunk or full) into a UiPathConversationEvent."""
-    message_id = getattr(message, "id", None) or _new_id()
-    timestamp = datetime.now().isoformat()
-
-    # --- Streaming AIMessageChunk ---
-    if isinstance(message, AIMessageChunk):
-        msg_event = UiPathConversationMessageEvent(
-            message_id=message.id or _new_id(),
-        )
-
-        if message.content == []:
-            msg_event.start = UiPathConversationMessageStartEvent(
-                role="assistant", timestamp=timestamp
-            )
-            msg_event.content_part = UiPathConversationContentPartEvent(
-                content_part_id=f"chunk-{message.id}-{0}",
-                start=UiPathConversationContentPartStartEvent(mime_type="text/plain"),
-            )
-
-        elif isinstance(message.content, list) and message.content:
-            for chunk in message.content:
-                if not isinstance(chunk, dict):
-                    continue
-                idx = chunk.get("index", 0)
-                ctype = chunk.get("type")
-                id = chunk.get("id", f"chunk-{message.id}-{idx}")
-
-                # Start of a tool call
-                if ctype == "tool_use":
-                    msg_event.tool_call = UiPathConversationToolCallEvent(
-                        tool_call_id=id,
-                        start=UiPathConversationToolCallStartEvent(
-                            tool_name=chunk.get("name") or "",
-                            arguments=UiPathInlineValue(inline=""),
-                            timestamp=timestamp,
-                        ),
-                    )
-
-                # JSON args streaming (content part for tool args)
-                elif ctype == "input_json_delta":
-                    text = chunk.get("partial_json", "")
-                    # first delta: emit content part start + first chunk
-                    if text == "":
-                        msg_event.content_part = UiPathConversationContentPartEvent(
-                            content_part_id=id,
-                            start=UiPathConversationContentPartStartEvent(
-                                mime_type="application/json"
-                            ),
-                        )
-                    else:
-                        msg_event.content_part = UiPathConversationContentPartEvent(
-                            content_part_id=id,
-                            chunk=UiPathConversationContentPartChunkEvent(
-                                data=text,
-                                content_part_sequence=idx,
-                            ),
-                        )
-
-                # Plain text from assistant
-                elif ctype == "text":
-                    text = chunk.get("text", "")
-                    msg_event.content_part = UiPathConversationContentPartEvent(
-                        content_part_id=id,
-                        chunk=UiPathConversationContentPartChunkEvent(
-                            data=text,
-                            content_part_sequence=idx,
-                        ),
-                    )
-
-        stop_reason = message.response_metadata.get("stop_reason")
-        if not message.content and stop_reason in ("tool_use", "end_turn"):
-            msg_event.end = UiPathConversationMessageEndEvent(timestamp=timestamp)
-
-        if (
-            msg_event.start
-            or msg_event.content_part
-            or msg_event.tool_call
-            or msg_event.end
-        ):
-            return _wrap_in_conversation_event(msg_event, exchange_id, conversation_id)
-
-        return None
-
-    text_content = _extract_text(message.content)
-
-    # --- HumanMessage ---
-    if isinstance(message, HumanMessage):
-        return _wrap_in_conversation_event(
-            UiPathConversationMessageEvent(
-                message_id=message_id,
-                start=UiPathConversationMessageStartEvent(
-                    role="user", timestamp=timestamp
-                ),
-                content_part=UiPathConversationContentPartEvent(
-                    content_part_id=f"cp-{message_id}",
-                    start=UiPathConversationContentPartStartEvent(
-                        mime_type="text/plain"
-                    ),
-                    chunk=UiPathConversationContentPartChunkEvent(data=text_content),
-                    end=UiPathConversationContentPartEndEvent(),
-                ),
-                end=UiPathConversationMessageEndEvent(),
-            ),
-            exchange_id,
-            conversation_id,
-        )
-
-    # --- AIMessage ---
-    if isinstance(message, AIMessage):
-        # Extract first tool call if present
-        tool_calls = getattr(message, "tool_calls", []) or []
-        first_tc = tool_calls[0] if tool_calls else None
-
-        return _wrap_in_conversation_event(
-            UiPathConversationMessageEvent(
-                message_id=message_id,
-                start=UiPathConversationMessageStartEvent(
-                    role="assistant", timestamp=timestamp
-                ),
-                content_part=(
-                    UiPathConversationContentPartEvent(
-                        content_part_id=f"cp-{message_id}",
-                        start=UiPathConversationContentPartStartEvent(
-                            mime_type="text/plain"
-                        ),
-                        chunk=UiPathConversationContentPartChunkEvent(
-                            data=text_content
-                        ),
-                        end=UiPathConversationContentPartEndEvent(),
-                    )
-                    if text_content
-                    else None
-                ),
-                tool_call=(
-                    UiPathConversationToolCallEvent(
-                        tool_call_id=first_tc.get("id") or _new_id(),
-                        start=UiPathConversationToolCallStartEvent(
-                            tool_name=first_tc.get("name"),
-                            arguments=UiPathInlineValue(
-                                inline=str(first_tc.get("args", ""))
-                            ),
-                            timestamp=timestamp,
-                        ),
-                    )
-                    if first_tc
-                    else None
-                ),
-                end=UiPathConversationMessageEndEvent(),
-            ),
-            exchange_id,
-            conversation_id,
-        )
-
-    # --- ToolMessage ---
-    if isinstance(message, ToolMessage):
-        return _wrap_in_conversation_event(
-            UiPathConversationMessageEvent(
-                message_id=message_id,
-                tool_call=UiPathConversationToolCallEvent(
-                    tool_call_id=message.tool_call_id,
-                    start=UiPathConversationToolCallStartEvent(
-                        tool_name=message.name or "",
-                        arguments=UiPathInlineValue(inline=""),
-                        timestamp=timestamp,
-                    ),
-                    end=UiPathConversationToolCallEndEvent(
-                        timestamp=timestamp,
-                        result=UiPathInlineValue(inline=message.content),
-                    ),
-                ),
-            ),
-            exchange_id,
-            conversation_id,
-        )
-
-    # --- Fallback ---
-    return _wrap_in_conversation_event(
-        UiPathConversationMessageEvent(
-            message_id=message_id,
-            start=UiPathConversationMessageStartEvent(
-                role="assistant", timestamp=timestamp
-            ),
-            content_part=UiPathConversationContentPartEvent(
-                content_part_id=f"cp-{message_id}",
-                chunk=UiPathConversationContentPartChunkEvent(data=text_content),
-            ),
-            end=UiPathConversationMessageEndEvent(),
-        ),
-        exchange_id,
-        conversation_id,
-    )

uipath_langchain/_cli/_runtime/_exception.py

@@ -1,17 +0,0 @@
-from typing import Optional
-
-from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
-
-
-class LangGraphRuntimeError(UiPathRuntimeError):
-    """Custom exception for LangGraph runtime errors with structured error information."""
-
-    def __init__(
-        self,
-        code: str,
-        title: str,
-        detail: str,
-        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
-        status: Optional[int] = None,
-    ):
-        super().__init__(code, title, detail, category, status, prefix="LANGGRAPH")

uipath_langchain/_cli/_runtime/_input.py

@@ -1,139 +0,0 @@
-import logging
-from typing import Any, Optional, cast
-
-from langgraph.types import Command
-from uipath._cli._runtime._contracts import (
-    UiPathApiTrigger,
-    UiPathErrorCategory,
-    UiPathResumeTrigger,
-    UiPathResumeTriggerType,
-)
-from uipath._cli._runtime._hitl import HitlReader
-
-from ._context import LangGraphRuntimeContext
-from ._conversation import uipath_to_human_messages
-from ._exception import LangGraphRuntimeError
-
-logger = logging.getLogger(__name__)
-
-
-class LangGraphInputProcessor:
-    """
-    Handles input processing for graph execution, including resume scenarios
-    where it needs to fetch data from UiPath.
-    """
-
-    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"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

uipath_langchain/_cli/_runtime/_output.py

@@ -1,234 +0,0 @@
-import json
-import logging
-from functools import cached_property
-from typing import Any, Dict, Optional, cast
-
-from langgraph.types import Interrupt, StateSnapshot
-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 __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 {}
-
-            return self._serialize_object(self.context.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
-
-    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.
-
-        Returns:
-            UiPathRuntimeResult: The processed execution result.
-
-        Raises:
-            LangGraphRuntimeError: If processing fails.
-        """
-        try:
-            await self._save_resume_trigger()
-
-            return UiPathRuntimeResult(
-                output=self.serialized_output,
-                status=self.status,
-                resume=self._resume_trigger if self._resume_trigger else None,
-            )
-
-        except LangGraphRuntimeError:
-            raise
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "OUTPUT_PROCESSING_FAILED",
-                "Failed to process execution output",
-                f"Unexpected error during output processing: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
-
-    async def _save_resume_trigger(self) -> None:
-        """
-        Stores the resume trigger in the SQLite database if available.
-
-        Raises:
-            LangGraphRuntimeError: If database operations fail.
-        """
-        if not self._hitl_processor or not self.context.memory:
-            return
-
-        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
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "RESUME_TRIGGER_SAVE_FAILED",
-                "Failed to save resume trigger",
-                f"Unexpected error while saving resume trigger: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e