uipath-langchain 0.0.85__py3-none-any.whl → 0.0.88__py3-none-any.whl

uipath_langchain/_cli/_runtime/_context.py

@@ -2,7 +2,7 @@ from typing import Any, Optional, Union
 
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.graph import StateGraph
-from uipath_sdk._cli._runtime._contracts import UiPathRuntimeContext
+from uipath._cli._runtime._contracts import UiPathRuntimeContext
 
 from .._utils._graph import LangGraphConfig
 

uipath_langchain/_cli/_runtime/_escalation.py

@@ -3,8 +3,8 @@ import logging
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
-from uipath_sdk import UiPathSDK
-from uipath_sdk._models.actions import Action
+from uipath import UiPath
+from uipath.models.actions import Action
 
 logger = logging.getLogger(__name__)
 
@@ -230,7 +230,7 @@ class Escalation:
             return None
 
         try:
-            uipath = UiPathSDK()
+            uipath = UiPath()
             action = uipath.actions.create(
                 title=self._config.get("title", "Default escalation"),
                 app_name=self._config.get("appName"),

uipath_langchain/_cli/_runtime/_exception.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from uipath_sdk._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
+from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
 
 
 class LangGraphRuntimeError(UiPathRuntimeError):

uipath_langchain/_cli/_runtime/_input.py

@@ -3,8 +3,8 @@ import logging
 from typing import Any, Optional, cast
 
 from langgraph.types import Command
-from uipath_sdk import UiPathSDK
-from uipath_sdk._cli._runtime._contracts import (
+from uipath import UiPath
+from uipath._cli._runtime._contracts import (
     UiPathErrorCategory,
     UiPathResumeTriggerType,
     UiPathRuntimeStatus,
@@ -39,7 +39,7 @@ class LangGraphInputProcessor:
         """
         self.context = context
         self.escalation = Escalation(self.context.config_path)
-        self.uipath = UiPathSDK()
+        self.uipath = UiPath()
 
     async def process(self) -> Any:
         """

uipath_langchain/_cli/_runtime/_output.py

@@ -6,8 +6,8 @@ from functools import cached_property
 from typing import Any, Dict, Optional, Union, cast
 
 from langgraph.types import Interrupt, StateSnapshot
-from uipath_sdk import UiPathSDK
-from uipath_sdk._cli._runtime._contracts import (
+from uipath import UiPath
+from uipath._cli._runtime._contracts import (
     UiPathApiTrigger,
     UiPathErrorCategory,
     UiPathResumeTrigger,
@@ -15,8 +15,8 @@ from uipath_sdk._cli._runtime._contracts import (
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
-from uipath_sdk._models import CreateAction, InvokeProcess, WaitAction, WaitJob
-from uipath_sdk._models.actions import Action
+from uipath.models import CreateAction, InvokeProcess, WaitAction, WaitJob
+from uipath.models.actions import Action
 
 from ._context import LangGraphRuntimeContext
 from ._escalation import Escalation
@@ -145,11 +145,9 @@ class LangGraphOutputProcessor:
         try:
             if self.context.output is None:
                 return {}
-            if hasattr(self.context.output, "dict"):
-                return self.context.output.dict()
-            elif hasattr(self.context.output, "to_dict"):
-                return self.context.output.to_dict()
-            return dict(self.context.output)
+
+            return self._serialize_object(self.context.output)
+
         except Exception as e:
             raise LangGraphRuntimeError(
                 "OUTPUT_SERIALIZATION_FAILED",
@@ -158,6 +156,31 @@ class LangGraphOutputProcessor:
                 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.
@@ -233,7 +256,7 @@ class LangGraphOutputProcessor:
                             )
                         return
                     if isinstance(self.interrupt_info, InterruptInfo):
-                        uipath_sdk = UiPathSDK()
+                        uipath_sdk = UiPath()
                         if self.interrupt_info.type is UiPathResumeTriggerType.JOB:
                             if isinstance(self.interrupt_value, InvokeProcess):
                                 job = await uipath_sdk.processes.invoke_async(
@@ -243,7 +266,7 @@ class LangGraphOutputProcessor:
                                 if job:
                                     self._resume_trigger = UiPathResumeTrigger(
                                         trigger_type=UiPathResumeTriggerType.JOB,
-                                        item_key=job.Key,
+                                        item_key=job.key,
                                     )
                             elif isinstance(self.interrupt_value, WaitJob):
                                 self._resume_trigger = UiPathResumeTrigger(

uipath_langchain/_cli/_runtime/_runtime.py

@@ -8,7 +8,7 @@ from langchain_core.tracers.langchain import wait_for_all_tracers
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
 from langgraph.graph.state import CompiledStateGraph
-from uipath_sdk._cli._runtime._contracts import (
+from uipath._cli._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
     UiPathRuntimeResult,

uipath_langchain/_cli/cli_init.py

@@ -5,8 +5,8 @@ import uuid
 from typing import Any, Dict
 
 from langgraph.graph.state import CompiledStateGraph
-from uipath_sdk._cli._utils._parse_ast import generate_bindings_json  # type: ignore
-from uipath_sdk._cli.middlewares import MiddlewareResult
+from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
+from uipath._cli.middlewares import MiddlewareResult
 
 from ._utils._graph import LangGraphConfig
 

uipath_langchain/_cli/cli_run.py

@@ -4,8 +4,8 @@ from os import environ as env
 from typing import Optional
 
 from dotenv import load_dotenv
-from uipath_sdk._cli._runtime._contracts import UiPathTraceContext
-from uipath_sdk._cli.middlewares import MiddlewareResult
+from uipath._cli._runtime._contracts import UiPathTraceContext
+from uipath._cli.middlewares import MiddlewareResult
 
 from ._runtime._context import LangGraphRuntimeContext
 from ._runtime._exception import LangGraphRuntimeError

uipath_langchain/middlewares.py

@@ -1,4 +1,4 @@
-from uipath_sdk._cli.middlewares import Middlewares
+from uipath._cli.middlewares import Middlewares
 
 from ._cli.cli_init import langgraph_init_middleware
 from ._cli.cli_run import langgraph_run_middleware

uipath_langchain/retrievers/context_grounding_retriever.py

@@ -1,14 +1,17 @@
 from typing import List, Optional
 
-from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForRetrieverRun,
+    CallbackManagerForRetrieverRun,
+)
 from langchain_core.documents import Document
 from langchain_core.retrievers import BaseRetriever
-from uipath_sdk import UiPathSDK
+from uipath import UiPath
 
 
 class ContextGroundingRetriever(BaseRetriever):
     index_name: str
-    uipath_sdk: Optional[UiPathSDK] = None
+    uipath_sdk: Optional[UiPath] = None
     number_of_results: Optional[int] = 10
 
     def _get_relevant_documents(
@@ -16,7 +19,7 @@ class ContextGroundingRetriever(BaseRetriever):
     ) -> List[Document]:
         """Sync implementations for retriever calls context_grounding API to search the requested index."""
 
-        sdk = self.uipath_sdk if self.uipath_sdk is not None else UiPathSDK()
+        sdk = self.uipath_sdk if self.uipath_sdk is not None else UiPath()
         results = sdk.context_grounding.search(
             self.index_name,
             query,
@@ -33,3 +36,26 @@ class ContextGroundingRetriever(BaseRetriever):
             )
             for x in results
         ]
+
+    async def _aget_relevant_documents(
+        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """Async implementations for retriever calls context_grounding API to search the requested index."""
+
+        sdk = self.uipath_sdk if self.uipath_sdk is not None else UiPath()
+        results = await sdk.context_grounding.search_async(
+            self.index_name,
+            query,
+            self.number_of_results if self.number_of_results is not None else 10,
+        )
+
+        return [
+            Document(
+                page_content=x.content,
+                metadata={
+                    "source": x.source,
+                    "page_number": x.page_number,
+                },
+            )
+            for x in results
+        ]

uipath_langchain/tracers/AsyncUiPathTracer.py

@@ -12,7 +12,7 @@ import httpx
 from langchain_core.tracers.base import AsyncBaseTracer
 from langchain_core.tracers.schemas import Run
 from pydantic import PydanticDeprecationWarning
-from uipath_sdk._cli._runtime._contracts import UiPathTraceContext
+from uipath._cli._runtime._contracts import UiPathTraceContext
 
 from ._events import CustomTraceEvents, FunctionCallEventData
 from ._utils import _setup_tracer_httpx_logging, _simple_serialize_defaults
@@ -118,7 +118,7 @@ class AsyncUiPathTracer(AsyncBaseTracer):
         trace_data = {
             "id": self.context.trace_id,
             "name": re.sub(
-                "[!@#$<>\.]", "", run_name
+                r"[!@#$<>\.]", "", run_name
             ),  # if we use these characters the Agents UI throws some error (but llmops backend seems fine)
             "referenceId": self.context.reference_id,
             "attributes": "{}",

uipath_langchain/tracers/UiPathTracer.py

@@ -74,7 +74,7 @@ class UiPathTracer(BaseTracer):
         trace_data = {
             "id": self.trace_parent,
             "name": re.sub(
-                "[!@#$<>\.]", "", run_name
+                r"[!@#$<>\.]", "", run_name
             ),  # if we use these characters the Agents UI throws some error (but llmops backend seems fine)
             "referenceId": self.referenceId,
             "attributes": "{}",

uipath_langchain/tracers/_events.py

@@ -1,33 +1,33 @@
-from typing import Any, Dict, List, Literal, Optional
-
-RUN_TYPE_T = Literal[
-    "tool", "chain", "llm", "retriever", "embedding", "prompt", "parser"
-]
-
-
-class CustomTraceEvents:
-    UIPATH_TRACE_FUNCTION_CALL = "__uipath_trace_function_call"
-
-
-class FunctionCallEventData:
-    def __init__(
-        self,
-        function_name: str,
-        event_type: str,
-        inputs: Dict[str, Any],
-        call_uuid: str,
-        output: Any,
-        error: Optional[str] = None,
-        run_type: Optional[RUN_TYPE_T] = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ):
-        self.function_name = function_name
-        self.event_type = event_type
-        self.inputs = inputs
-        self.call_uuid = call_uuid
-        self.output = output
-        self.error = error
-        self.run_type = run_type or "chain"
-        self.tags = tags
-        self.metadata = metadata
+from typing import Any, Dict, List, Literal, Optional
+
+RUN_TYPE_T = Literal[
+    "tool", "chain", "llm", "retriever", "embedding", "prompt", "parser"
+]
+
+
+class CustomTraceEvents:
+    UIPATH_TRACE_FUNCTION_CALL = "__uipath_trace_function_call"
+
+
+class FunctionCallEventData:
+    def __init__(
+        self,
+        function_name: str,
+        event_type: str,
+        inputs: Dict[str, Any],
+        call_uuid: str,
+        output: Any,
+        error: Optional[str] = None,
+        run_type: Optional[RUN_TYPE_T] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        self.function_name = function_name
+        self.event_type = event_type
+        self.inputs = inputs
+        self.call_uuid = call_uuid
+        self.output = output
+        self.error = error
+        self.run_type = run_type or "chain"
+        self.tags = tags
+        self.metadata = metadata