uipath-langchain 0.0.125__py3-none-any.whl → 0.0.127__py3-none-any.whl

uipath_langchain/_cli/_runtime/_conversation.py

@@ -0,0 +1,298 @@
+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/_input.py

@@ -12,6 +12,7 @@ from uipath._cli._runtime._contracts import (
 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__)
@@ -58,6 +59,10 @@ class LangGraphInputProcessor:
         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:

uipath_langchain/_cli/_runtime/_runtime.py

@@ -20,6 +20,7 @@ from ..._utils import _instrument_traceable_attributes
 from ...tracers import AsyncUiPathTracer
 from .._utils._graph import LangGraphConfig
 from ._context import LangGraphRuntimeContext
+from ._conversation import map_message
 from ._exception import LangGraphRuntimeError
 from ._input import LangGraphInputProcessor
 from ._output import LangGraphOutputProcessor
@@ -98,8 +99,27 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 if max_concurrency is not None:
                     graph_config["max_concurrency"] = int(max_concurrency)
 
+                if self.context.chat_handler:
+                    async for stream_chunk in graph.astream(
+                        processed_input,
+                        graph_config,
+                        stream_mode="messages",
+                        subgraphs=True,
+                    ):
+                        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
+                            continue
+
+                        _, (message, _) = stream_chunk
+                        event = map_message(
+                            message=message,
+                            conversation_id=self.context.execution_id,
+                            exchange_id=self.context.execution_id,
+                        )
+                        if event:
+                            self.context.chat_handler.on_event(event)
+
                 # Stream the output at debug time
-                if self.is_debug_run():
+                elif self.is_debug_run():
                     # Get final chunk while streaming
                     final_chunk = None
                     async for stream_chunk in graph.astream(

{uipath_langchain-0.0.125.dist-info → uipath_langchain-0.0.127.dist-info}/METADATA

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

{uipath_langchain-0.0.125.dist-info → uipath_langchain-0.0.127.dist-info}/RECORD

@@ -6,10 +6,11 @@ uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwv
 uipath_langchain/_cli/cli_new.py,sha256=dL8-Rri6u67ZZdbb4nT38A5xD_Q3fVnG0UK9VSeKaqg,2563
 uipath_langchain/_cli/cli_run.py,sha256=R-cUi3lO3Qd4ysTXD7PW4sa1RsB427v_Y6xUQxWijfQ,3725
 uipath_langchain/_cli/_runtime/_context.py,sha256=yyzYJDmk2fkH4T5gm4cLGRyXtjLESrpzHBT9euqluTA,817
+uipath_langchain/_cli/_runtime/_conversation.py,sha256=S1KTx_q-La7ikPRT3nBcIp8t-J9CF0QB0DCduQIIB28,11149
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
-uipath_langchain/_cli/_runtime/_input.py,sha256=vZ8vfVxvPSaPWmIPghvNx1VRKzbalHsKUMBPiKDvJWM,5492
+uipath_langchain/_cli/_runtime/_input.py,sha256=3IKrZR9xmxYg6l_1TbFpaLOWPDvK8d3nSKIHPGEEGzE,5715
 uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=dRM28l1k3qFf8NLWytRKlOcPwZJ__qUjqmV04wN9JRY,14504
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=9X_8YEny238V1sTb4cjkpd6J69DYQWo6eYVH9kA9gEQ,15383
 uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
 uipath_langchain/_cli/_templates/main.py.template,sha256=nMJQIYPlRk90iANfNVpkJ2EQX20Dxsyq92-BucEz_UM,1189
 uipath_langchain/_cli/_utils/_graph.py,sha256=JPShHNl0UQvl4AdjLIqLpNt_JAjpWH9WWF22Gs47Xew,7445
@@ -31,8 +32,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=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.125.dist-info/METADATA,sha256=-qGeRLnvPNVGjyNyQRn5SQ0bgd8Kn07sgfgmVCYfihg,4235
-uipath_langchain-0.0.125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.125.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.125.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.125.dist-info/RECORD,,
+uipath_langchain-0.0.127.dist-info/METADATA,sha256=-pkEhqb6QF5H9pH-3TVabaJmMZcsWrd-sAH6EMlPhpg,4235
+uipath_langchain-0.0.127.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.127.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.127.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.127.dist-info/RECORD,,