uipath-langchain 0.0.146__py3-none-any.whl → 0.0.148__py3-none-any.whl

uipath_langchain/_utils/_request_mixin.py

@@ -17,7 +17,11 @@ from tenacity import (
     stop_after_attempt,
     wait_exponential_jitter,
 )
-from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
+from uipath._cli._runtime._contracts import (
+    UiPathErrorCategory,
+    UiPathErrorCode,
+    UiPathRuntimeError,
+)
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 
 from uipath_langchain._cli._runtime._exception import (
@@ -59,7 +63,7 @@ def _get_access_token(data):
         return get_uipath_token_header(settings)
     except ValidationError:
         raise UiPathRuntimeError(
-            code="AUTHENTICATION_REQUIRED",
+            UiPathErrorCode.AUTHENTICATION_REQUIRED,
             title="Authorization required",
             detail="Authorization required. Please run uipath auth",
             category=UiPathErrorCategory.USER,

uipath_langchain/agent/react/__init__.py

@@ -1,12 +1,13 @@
 """UiPath ReAct Agent implementation"""
 
 from .agent import create_agent
-from .state import AgentGraphNode, AgentGraphState
+from .types import AgentGraphConfig, AgentGraphNode, AgentGraphState
 from .utils import resolve_output_model
 
 __all__ = [
     "create_agent",
-    "AgentGraphState",
-    "AgentGraphNode",
     "resolve_output_model",
+    "AgentGraphNode",
+    "AgentGraphState",
+    "AgentGraphConfig",
 ]

uipath_langchain/agent/react/agent.py

@@ -18,11 +18,11 @@ from .llm_node import (
 from .router import (
     route_agent,
 )
-from .state import AgentGraphNode, AgentGraphState
 from .terminate_node import (
     create_terminate_node,
 )
 from .tools import create_flow_control_tools
+from .types import AgentGraphConfig, AgentGraphNode, AgentGraphState
 
 
 def create_agent(
@@ -32,13 +32,16 @@ def create_agent(
     *,
     state_schema: Type[AgentGraphState] = AgentGraphState,
     response_format: type[BaseModel] | None = None,
-    recursion_limit: int = 50,
+    config: AgentGraphConfig | None = None,
 ) -> StateGraph[AgentGraphState]:
     """Build agent graph with INIT -> AGENT <-> TOOLS loop, terminated by control flow tools.
 
     Control flow tools (end_execution, raise_error) are auto-injected alongside regular tools.
     """
-    os.environ["LANGCHAIN_RECURSION_LIMIT"] = str(recursion_limit)
+    if config is None:
+        config = AgentGraphConfig()
+
+    os.environ["LANGCHAIN_RECURSION_LIMIT"] = str(config.recursion_limit)
 
     agent_tools = list(tools)
     flow_control_tools: list[BaseTool] = create_flow_control_tools(response_format)

uipath_langchain/agent/react/init_node.py

@@ -4,7 +4,7 @@ from typing import Sequence
 
 from langchain_core.messages import HumanMessage, SystemMessage
 
-from .state import AgentGraphState
+from .types import AgentGraphState
 
 
 def create_init_node(

uipath_langchain/agent/react/llm_node.py

@@ -7,7 +7,7 @@ from langchain_core.messages import AIMessage, AnyMessage
 from langchain_core.tools import BaseTool
 
 from .constants import MAX_SUCCESSIVE_COMPLETIONS
-from .state import AgentGraphState
+from .types import AgentGraphState
 from .utils import count_successive_completions
 
 

uipath_langchain/agent/react/router.py

@@ -7,7 +7,7 @@ from uipath.agent.react import END_EXECUTION_TOOL, RAISE_ERROR_TOOL
 
 from .constants import MAX_SUCCESSIVE_COMPLETIONS
 from .exceptions import AgentNodeRoutingException
-from .state import AgentGraphNode, AgentGraphState
+from .types import AgentGraphNode, AgentGraphState
 from .utils import count_successive_completions
 
 FLOW_CONTROL_TOOLS = [END_EXECUTION_TOOL.name, RAISE_ERROR_TOOL.name]

uipath_langchain/agent/react/terminate_node.py

@@ -11,7 +11,7 @@ from .exceptions import (
     AgentNodeRoutingException,
     AgentTerminationException,
 )
-from .state import AgentGraphState
+from .types import AgentGraphState
 
 
 def create_terminate_node(

uipath_langchain/agent/react/{state.py → types.py}

@@ -3,6 +3,7 @@ from __future__ import annotations
 from enum import StrEnum
 
 from langgraph.graph import MessagesState
+from pydantic import BaseModel, Field
 
 
 class AgentGraphState(MessagesState):
@@ -16,3 +17,9 @@ class AgentGraphNode(StrEnum):
     AGENT = "agent"
     TOOLS = "tools"
     TERMINATE = "terminate"
+
+
+class AgentGraphConfig(BaseModel):
+    recursion_limit: int = Field(
+        default=50, ge=1, description="Maximum recursion limit for the agent graph"
+    )

uipath_langchain/vectorstores/context_grounding_vectorstore.py

@@ -2,23 +2,17 @@
 Vector store implementation that connects to UiPath Context Grounding as a backend.
 
 This is a read-only vector store that uses the UiPath Context Grounding API to retrieve documents.
-
-You need to set the following environment variables (also see .env.example):
-### - UIPATH_URL="https://alpha.uipath.com/{ORG_ID}/{TENANT_ID}"
-### - UIPATH_ACCESS_TOKEN={BEARER_TOKEN_WITH_CONTEXT_GROUNDING_PERMISSIONS}
-### - UIPATH_FOLDER_PATH="" - this can be left empty
-### - UIPATH_FOLDER_KEY="" - this can be left empty
 """
 
 from collections.abc import Iterable
-from typing import Any, Optional, TypeVar
+from typing import Any, Self
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
 from langchain_core.vectorstores import VectorStore
+from typing_extensions import override
 from uipath import UiPath
-
-VST = TypeVar("VST", bound="ContextGroundingVectorStore")
+from uipath.models.context_grounding import ContextGroundingQueryResponse
 
 
 class ContextGroundingVectorStore(VectorStore):
@@ -26,42 +20,32 @@ class ContextGroundingVectorStore(VectorStore):
 
     This class provides a straightforward implementation that connects to the
     UiPath Context Grounding API for semantic searching.
-
-    Example:
-        .. code-block:: python
-
-            from uipath_agents_gym.tools.ecs_vectorstore import ContextGroundingVectorStore
-
-            # Initialize the vector store with an index name
-            vectorstore = ContextGroundingVectorStore(index_name="ECCN")
-
-            # Perform similarity search
-            docs_with_scores = vectorstore.similarity_search_with_score(
-                "How do I process an invoice?", k=5
-            )
     """
 
     def __init__(
         self,
         index_name: str,
-        folder_path: Optional[str] = None,
-        uipath_sdk: Optional[UiPath] = None,
+        uipath_sdk: UiPath | None = None,
+        folder_path: str | None = None,
     ):
         """Initialize the ContextGroundingVectorStore.
 
         Args:
-            index_name: Name of the context grounding index to use
-            uipath_sdk: Optional SDK instance to use. If not provided, a new instance will be created.
+            index_name: Name of the context grounding index to use (schema name)
+            uipath_sdk: Optional UiPath SDK instance.
+            folder_path: Optional folder path for folder-scoped operations
         """
         self.index_name = index_name
         self.folder_path = folder_path
         self.sdk = uipath_sdk or UiPath()
 
+    # VectorStore implementation methods
+
+    @override
     def similarity_search_with_score(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
         """Return documents most similar to the query along with the distances.
-        The distance is 1 - score, where score is the relevance score returned by the Context Grounding API.
 
         Args:
             query: The query string
@@ -70,52 +54,24 @@ class ContextGroundingVectorStore(VectorStore):
         Returns:
             list of tuples of (document, score)
         """
-        # Call the UiPath SDK to perform the search
-        results = self.sdk.context_grounding.search(
-            name=self.index_name,
-            query=query,
-            number_of_results=k,
-            folder_path=self.folder_path,
-        )
-
-        # Convert the results to Documents with scores
-        docs_with_scores = []
-        for result in results:
-            # Create metadata from result fields
-            metadata = {
-                "source": result.source,
-                "id": result.id,
-                "reference": result.reference,
-                "page_number": result.page_number,
-                "source_document_id": result.source_document_id,
-                "caption": result.caption,
-            }
-
-            # Add any operation metadata if available
-            if result.metadata:
-                metadata["operation_id"] = result.metadata.operation_id
-                metadata["strategy"] = result.metadata.strategy
-
-            # Create a Document with the content and metadata
-            doc = Document(
-                page_content=result.content,
-                metadata=metadata,
+        # Use the context grounding service to perform search
+        results: list[ContextGroundingQueryResponse] = (
+            self.sdk.context_grounding.search(
+                name=self.index_name,
+                query=query,
+                number_of_results=k,
+                folder_path=self.folder_path,
             )
+        )
 
-            score = 1.0 - float(result.score)
-
-            docs_with_scores.append((doc, score))
-
-        return docs_with_scores
+        return self._convert_results_to_documents(results)
 
+    @override
     def similarity_search_with_relevance_scores(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
         """Return documents along with their relevance scores on a scale from 0 to 1.
 
-        This directly uses the scores provided by the Context Grounding API,
-        which are already normalized between 0 and 1.
-
         Args:
             query: The query string
             k: Number of documents to return (default=4)
@@ -128,6 +84,7 @@ class ContextGroundingVectorStore(VectorStore):
             for doc, score in self.similarity_search_with_score(query, k, **kwargs)
         ]
 
+    @override
     async def asimilarity_search_with_score(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
@@ -140,52 +97,23 @@ class ContextGroundingVectorStore(VectorStore):
         Returns:
             list of tuples of (document, score)
         """
-        # Call the UiPath SDK to perform the search asynchronously
-        results = await self.sdk.context_grounding.search_async(
+        # Use the context grounding service to perform async search
+        results: list[
+            ContextGroundingQueryResponse
+        ] = await self.sdk.context_grounding.search_async(
             name=self.index_name,
             query=query,
             number_of_results=k,
             folder_path=self.folder_path,
         )
 
-        # Convert the results to Documents with scores
-        docs_with_scores = []
-        for result in results:
-            # Create metadata from result fields
-            metadata = {
-                "source": result.source,
-                "id": result.id,
-                "reference": result.reference,
-                "page_number": result.page_number,
-                "source_document_id": result.source_document_id,
-                "caption": result.caption,
-            }
-
-            # Add any operation metadata if available
-            if result.metadata:
-                metadata["operation_id"] = result.metadata.operation_id
-                metadata["strategy"] = result.metadata.strategy
-
-            # Create a Document with the content and metadata
-            doc = Document(
-                page_content=result.content,
-                metadata=metadata,
-            )
-
-            # Get the distance score as 1 - ecs_score
-            score = 1.0 - float(result.score)
-
-            docs_with_scores.append((doc, score))
-
-        return docs_with_scores
+        return self._convert_results_to_documents(results)
 
+    @override
     async def asimilarity_search_with_relevance_scores(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[tuple[Document, float]]:
-        """Asynchronously return documents along with their relevance scores on a scale from 0 to 1.
-
-        This directly uses the scores provided by the Context Grounding API,
-        which are already normalized between 0 and 1.
+        """Asynchronously return documents along with their relevance scores.
 
         Args:
             query: The query string
@@ -201,6 +129,7 @@ class ContextGroundingVectorStore(VectorStore):
             )
         ]
 
+    @override
     def similarity_search(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[Document]:
@@ -216,6 +145,7 @@ class ContextGroundingVectorStore(VectorStore):
         docs_and_scores = self.similarity_search_with_score(query, k, **kwargs)
         return [doc for doc, _ in docs_and_scores]
 
+    @override
     async def asimilarity_search(
         self, query: str, k: int = 4, **kwargs: Any
     ) -> list[Document]:
@@ -231,14 +161,64 @@ class ContextGroundingVectorStore(VectorStore):
         docs_and_scores = await self.asimilarity_search_with_score(query, k, **kwargs)
         return [doc for doc, _ in docs_and_scores]
 
+    def _convert_results_to_documents(
+        self, results: list[ContextGroundingQueryResponse]
+    ) -> list[tuple[Document, float]]:
+        """Convert API results to Document objects with scores.
+
+        Args:
+            results: List of ContextGroundingQueryResponse objects
+
+        Returns:
+            List of tuples containing (Document, score)
+        """
+        docs_with_scores = []
+
+        for result in results:
+            # Create metadata from result fields
+            metadata = {}
+
+            # Add string fields with proper defaults
+            if result.source:
+                metadata["source"] = str(result.source)
+            if result.reference:
+                metadata["reference"] = str(result.reference)
+            if result.page_number:
+                metadata["page_number"] = str(result.page_number)
+            if result.source_document_id:
+                metadata["source_document_id"] = str(result.source_document_id)
+            if result.caption:
+                metadata["caption"] = str(result.caption)
+
+            # Add any operation metadata if available
+            if result.metadata:
+                if result.metadata.operation_id:
+                    metadata["operation_id"] = str(result.metadata.operation_id)
+                if result.metadata.strategy:
+                    metadata["strategy"] = str(result.metadata.strategy)
+
+            # Create a Document with the content and metadata
+            doc = Document(
+                page_content=result.content or "",
+                metadata=metadata,
+            )
+
+            # Convert score to distance (1 - score)
+            score = 1.0 - float(result.score or 0.0)
+
+            docs_with_scores.append((doc, score))
+
+        return docs_with_scores
+
     @classmethod
+    @override
     def from_texts(
-        cls: type[VST],
+        cls,
         texts: list[str],
         embedding: Embeddings,
-        metadatas: Optional[list[dict[str, Any]]] = None,
+        metadatas: list[dict[str, Any]] | None = None,
         **kwargs: Any,
-    ) -> VST:
+    ) -> Self:
         """This method is required by the VectorStore abstract class, but is not supported
         by ContextGroundingVectorStore which is read-only.
 
@@ -246,15 +226,14 @@ class ContextGroundingVectorStore(VectorStore):
             NotImplementedError: This method is not supported by ContextGroundingVectorStore
         """
         raise NotImplementedError(
-            "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding. "
-            "Creating a vector store from texts is not supported."
+            "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding."
         )
 
-    # Other required methods with minimal implementation to satisfy the interface
+    @override
     def add_texts(
         self,
         texts: Iterable[str],
-        metadatas: Optional[list[dict[str, Any]]] = None,
+        metadatas: list[dict[str, Any]] | None = None,
         **kwargs: Any,
     ) -> list[str]:
         """Not implemented for ContextGroundingVectorStore as this is a read-only wrapper."""
@@ -262,7 +241,8 @@ class ContextGroundingVectorStore(VectorStore):
             "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding."
         )
 
-    def delete(self, ids: Optional[list[str]] = None, **kwargs: Any) -> Optional[bool]:
+    @override
+    def delete(self, ids: list[str] | None = None, **kwargs: Any) -> bool | None:
         """Not implemented for ContextGroundingVectorStore as this is a read-only wrapper."""
         raise NotImplementedError(
             "ContextGroundingVectorStore is a read-only wrapper for UiPath Context Grounding."

{uipath_langchain-0.0.146.dist-info → uipath_langchain-0.0.148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.146
+Version: 0.0.148
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -26,7 +26,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.110
+Requires-Dist: uipath<2.2.0,>=2.1.123
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.146.dist-info → uipath_langchain-0.0.148.dist-info}/RECORD

@@ -26,18 +26,18 @@ uipath_langchain/_tracing/__init__.py,sha256=C2dRvQ2ynxCmyICgE-rJHimWKEcFRME_o9g
 uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZHAzNjGwbLjQn7jdX5yAgA,4343
 uipath_langchain/_tracing/_utils.py,sha256=r_fiSk3HDDAcePY_UbbEYiSbNqzn5gFeMPYBDvGrFx0,902
 uipath_langchain/_utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
-uipath_langchain/_utils/_request_mixin.py,sha256=_drxHTRpfyVn3g3ppKgn466EBaUWH83qyeGKLY41CGY,20142
+uipath_langchain/_utils/_request_mixin.py,sha256=AqdXUuV8hHNJYUAmAoBA1sptK52H46-QcgutVPyUfao,20185
 uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
-uipath_langchain/agent/react/__init__.py,sha256=rfVB6PQWUhPHff3J1BnPMBKBMaHfgEkII1gXwjiqUMY,272
-uipath_langchain/agent/react/agent.py,sha256=cU9ZiXi7EfV1pMf9nZBO8LhjYUmRsncyBk9k1pEBRh8,2455
+uipath_langchain/agent/react/__init__.py,sha256=XXplWNiD9XCxMVVyE0RL8tOwJjkP9ZKU6mFR5Em0ONk,314
+uipath_langchain/agent/react/agent.py,sha256=QxgeKa0kQkm7OEsVinjYMk410VHnDUdE9YQgk5Y3kug,2553
 uipath_langchain/agent/react/constants.py,sha256=B2yqryh242DETslaRYacUPbVdpjvvApjsBira_qhQwk,61
 uipath_langchain/agent/react/exceptions.py,sha256=b3lDhrIIHFljlLK3zXPznT7fYzfMRjSd8JfF4247tbI,226
-uipath_langchain/agent/react/init_node.py,sha256=zfPKgxi_mWsX7nBcK6wpqcDjHx8Q61TSnXFcTPLUd28,389
-uipath_langchain/agent/react/llm_node.py,sha256=jkbfzPNn6rNubgncPlPDQRNuk-sJbj08r95JfWxxWL8,1491
-uipath_langchain/agent/react/router.py,sha256=Ttq5O1_8t-z7pQ9tGhiaMmd_Da7_TWULLcgOED7gw_A,3626
-uipath_langchain/agent/react/state.py,sha256=EnkGXFlmMtJUy7BTZrbYlGBvvAZ70_HwKPW8n6uwjz0,330
-uipath_langchain/agent/react/terminate_node.py,sha256=Uuc-0z4qcPjHB_qZlaEaM2mK1ymCuJJludS7LopyCZg,1898
+uipath_langchain/agent/react/init_node.py,sha256=QhJQSqiM_qlQVsdoZDn_HxV4pl3-rO0Lk9pMlHrqZlw,389
+uipath_langchain/agent/react/llm_node.py,sha256=KzawaVkIWMztf9-LXLyUO7ZaXyuxVQbMusu8NpIHzhI,1491
+uipath_langchain/agent/react/router.py,sha256=PKP0-cJ_xP0Q42zN2MZpIHu4WSletSmQkFJe6QooJpY,3626
+uipath_langchain/agent/react/terminate_node.py,sha256=Gz_-R2LxvesocTZ6x6rIfV5FXiycmT1Fv5oXc2LpW5g,1898
+uipath_langchain/agent/react/types.py,sha256=oPUHckNdGT5n7FhAp5hZ7aNkJKX9Yfzvfvi_h2nKSZw,529
 uipath_langchain/agent/react/utils.py,sha256=0kZoEkGzddtTZSlGQcqbaPHH5MVtZegq0kBI5_vreGA,1060
 uipath_langchain/agent/react/tools/__init__.py,sha256=LGfG8Dc32ffKdXQyMI2oYzhNnTs1wbzsddXz6eU-0MY,102
 uipath_langchain/agent/react/tools/tools.py,sha256=vFBGnFrGocX__sotKisMJr2lxRRVqA0-uThzzhPADIw,1443
@@ -53,12 +53,10 @@ uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR
 uipath_langchain/embeddings/embeddings.py,sha256=45gKyb6HVKigwE-0CXeZcAk33c0mteaEdPGa8hviqcw,4339
 uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
 uipath_langchain/retrievers/context_grounding_retriever.py,sha256=YLCIwy89LhLnNqcM0YJ5mZoeNyCs5UiKD3Wly8gnW1E,2239
-uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-uipath_langchain/tools/preconfigured.py,sha256=SyvrLrM1kezZxVVytgScVO8nBfVYfFGobWjY7erzsYU,7490
 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.146.dist-info/METADATA,sha256=7u2FwmZLCfShij8MzNjH3-B3pVxqerwV99nGRAwVGSM,4276
-uipath_langchain-0.0.146.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.146.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.146.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.146.dist-info/RECORD,,
+uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=E0iuDBMAOl50Bdhl3YxywR0CngH1I99mkmfMh3byMFY,8396
+uipath_langchain-0.0.148.dist-info/METADATA,sha256=ucOXQNU19PUpVFPtiK3VrjAkGtx-jgXC8RkLtZspgoA,4276
+uipath_langchain-0.0.148.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.148.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.148.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.148.dist-info/RECORD,,

uipath_langchain/tools/preconfigured.py

@@ -1,220 +0,0 @@
-import json
-import logging
-from typing import Any, Iterable, Optional, Type
-
-import httpx
-from jsonschema_pydantic import jsonschema_to_pydantic as create_model  # type: ignore
-from langchain_core.caches import BaseCache
-from langchain_core.runnables.utils import Output
-from langchain_core.tools import BaseTool, StructuredTool
-from langgraph.types import interrupt
-from pydantic import BaseModel
-from uipath import UiPath
-from uipath.agent.models.agent import (
-    AgentEscalationChannel,
-    AgentEscalationResourceConfig,
-    AgentIntegrationToolParameter,
-    AgentIntegrationToolResourceConfig,
-    AgentProcessToolResourceConfig,
-    AgentResourceConfig,
-    LowCodeAgentDefinition,
-)
-from uipath.models import CreateAction, InvokeProcess
-from uipath.models.connections import ConnectionTokenType
-
-logger = logging.getLogger(__name__)
-
-
-def create_process_tool(resource: AgentProcessToolResourceConfig) -> Iterable[BaseTool]:
-    async def process(**kwargs) -> BaseModel:
-        return interrupt(
-            InvokeProcess(
-                name=resource.name,
-                input_arguments=kwargs,
-                process_folder_path=resource.properties.folder_path,
-            )
-        )
-
-    input_schema = create_model(resource.input_schema)
-
-    class ProcessTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model(resource.output_schema)
-
-    yield ProcessTool(
-        name=resource.name,
-        args_schema=input_schema,
-        description=resource.description,
-        coroutine=process,
-    )
-
-
-def create_escalation_tool_from_channel(channel: AgentEscalationChannel) -> BaseTool:
-    async def escalate(**kwargs) -> BaseModel:
-        recipients = channel.recipients
-        if len(recipients) > 1:
-            logger.warning(
-                "Received more than one recipient. Defaulting to first recipient."
-            )
-        assignee = recipients[0].value if recipients else None
-        return interrupt(
-            CreateAction(
-                title=channel.description,
-                data=kwargs,
-                assignee=assignee,
-                app_name=channel.properties.app_name,
-                app_folder_path=None,  # Channels specify folder name but not folder path.
-                app_folder_key=channel.properties.resource_key,
-                app_key=channel.properties.resource_key,
-                app_version=channel.properties.app_version,
-            )
-        )
-
-    input_schema = create_model(channel.input_schema)
-
-    class EscalationTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model(channel.output_schema)
-
-    return EscalationTool(
-        name=channel.name,
-        args_schema=input_schema,
-        description=channel.description,
-        coroutine=escalate,
-    )
-
-
-def create_escalation_tool(
-    resource: AgentEscalationResourceConfig,
-) -> Iterable[BaseTool]:
-    for channel in resource.channels:
-        yield create_escalation_tool_from_channel(channel)
-
-
-METHOD_MAP = {"GETBYID": "GET"}
-
-
-def build_query_params(parameters: list[AgentIntegrationToolParameter]):
-    query_params = [
-        x for x in parameters if x.field_location == "query" and x.value is not None
-    ]
-    if query_params:
-        return "?" + "&".join(f"{q.name}={q.value}" for q in query_params)
-    return ""
-
-
-def filter_query_params(
-    kwargs: dict[str, Any], parameters: list[AgentIntegrationToolParameter]
-):
-    query_params = {x.name for x in parameters if x.field_location == "query"}
-    non_query_params = {x.name for x in parameters if x.field_location != "query"}
-    fields_to_ignore = query_params - non_query_params
-    return {k: v for k, v in kwargs.items() if k not in fields_to_ignore}
-
-
-def create_integration_tool(
-    resource: AgentIntegrationToolResourceConfig,
-) -> Iterable[BaseTool]:
-    async def integration(**kwargs) -> BaseModel:
-        uipath = UiPath()
-        remote_connection = await uipath.connections.retrieve_async(
-            resource.properties.connection.id
-        )
-        token = await uipath.connections.retrieve_token_async(
-            resource.properties.connection.id, ConnectionTokenType.BEARER
-        )
-        tool_url = f"{remote_connection.api_base_uri}/v3/element/instances/{remote_connection.element_instance_id}{resource.properties.tool_path}"
-        tool_url = f"{tool_url}{build_query_params(resource.properties.parameters)}"
-        tool_url = tool_url.format(**kwargs)
-
-        authorization = f"{token.token_type} {token.access_token}"
-        method = METHOD_MAP.get(resource.properties.method, resource.properties.method)
-        response = await httpx.AsyncClient().request(
-            method,
-            tool_url,
-            headers={"Authorization": authorization},
-            content=json.dumps(
-                filter_query_params(kwargs, resource.properties.parameters)
-            ),
-        )
-        return response.json()
-
-    input_schema = create_model(resource.input_schema)
-
-    class IntegrationTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model({})
-
-    yield IntegrationTool(
-        name=resource.name,
-        args_schema=input_schema,
-        description=resource.description,
-        coroutine=integration,
-    )
-
-
-def create_cached_wrapper_from_tool(
-    wrapped: BaseTool, cache: Optional[BaseCache]
-) -> BaseTool:
-    if cache is None:
-        return wrapped
-    else:
-
-        async def cached_invocation(**kwargs) -> BaseModel:
-            namespace = f"{wrapped.name}.tool_invoke"
-            key = str(kwargs)
-            cached = cache.lookup(namespace, key)
-            if cached:
-                return cached[0]
-            response = await wrapped.ainvoke(input=kwargs)
-            cache.update(namespace, key, [response])
-            return response
-
-        input_schema = wrapped.args_schema
-
-        class CachedTool(StructuredTool):
-            OutputType: Type[BaseModel] = wrapped.OutputType
-
-        return CachedTool(
-            name=wrapped.name,
-            args_schema=input_schema,
-            description=wrapped.description,
-            coroutine=cached_invocation,
-        )
-
-
-def create_cached_wrapper(
-    tools: Iterable[BaseTool], cache: Optional[BaseCache]
-) -> Iterable[BaseTool]:
-    for wrapped in tools:
-        yield create_cached_wrapper_from_tool(wrapped, cache)
-
-
-def create_resource_tool(
-    resource: AgentResourceConfig, cache: Optional[BaseCache] = None
-) -> Iterable[BaseTool]:
-    match resource:
-        case AgentProcessToolResourceConfig():
-            return create_cached_wrapper(create_process_tool(resource), cache)
-        case AgentIntegrationToolResourceConfig():
-            return create_cached_wrapper(create_integration_tool(resource), cache)
-        case AgentEscalationResourceConfig():
-            return create_cached_wrapper(create_escalation_tool(resource), cache)
-        case _:
-            raise NotImplementedError()
-
-
-def safe_extract_tools(
-    agent_definition: LowCodeAgentDefinition, cache: Optional[BaseCache] = None
-) -> list[BaseTool]:
-    tools = []
-    for resource in agent_definition.resources:
-        try:
-            for structured_tool in create_resource_tool(resource, cache):
-                tools.append(structured_tool)
-        except NotImplementedError:
-            logger.warning(f"Unable to convert {resource.name} into a tool.")
-    return tools