uipath-langchain 0.0.145__tar.gz → 0.0.147__tar.gz

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.145
+Version: 0.0.147
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.145"
+version = "0.0.147"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -490,14 +490,14 @@ class LangGraphScriptRuntime(LangGraphRuntime):
         """Get entrypoint for this LangGraph runtime."""
         graph = await self.resolver()
         compiled_graph = graph.compile()
-        schema = generate_schema_from_graph(compiled_graph)
+        schema_details = generate_schema_from_graph(compiled_graph)
 
         return Entrypoint(
             file_path=self.context.entrypoint,  # type: ignore[call-arg]
             unique_id=str(uuid4()),
             type="agent",
-            input=schema["input"],
-            output=schema["output"],
+            input=schema_details.schema["input"],
+            output=schema_details.schema["output"],
         )
 
     async def cleanup(self) -> None:

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/src/uipath_langchain/_cli/_utils/_schema.py

@@ -1,27 +1,73 @@
+from dataclasses import dataclass
 from typing import Any, Dict
 
 from langgraph.graph.state import CompiledStateGraph
 
 
-def resolve_refs(schema, root=None):
-    """Recursively resolves $ref references in a JSON schema."""
+@dataclass
+class SchemaDetails:
+    schema: dict[str, Any]
+    has_input_circular_dependency: bool
+    has_output_circular_dependency: bool
+
+
+def resolve_refs(schema, root=None, visited=None):
+    """Recursively resolves $ref references in a JSON schema, handling circular references.
+
+    Returns:
+        tuple: (resolved_schema, has_circular_dependency)
+    """
     if root is None:
-        root = schema  # Store the root schema to resolve $refs
+        root = schema
+
+    if visited is None:
+        visited = set()
+
+    has_circular = False
 
     if isinstance(schema, dict):
         if "$ref" in schema:
-            ref_path = schema["$ref"].lstrip("#/").split("/")
+            ref_path = schema["$ref"]
+
+            if ref_path in visited:
+                # Circular dependency detected
+                return {
+                    "type": "object",
+                    "description": f"Circular reference to {ref_path}",
+                }, True
+
+            visited.add(ref_path)
+
+            # Resolve the reference
+            ref_parts = ref_path.lstrip("#/").split("/")
             ref_schema = root
-            for part in ref_path:
+            for part in ref_parts:
                 ref_schema = ref_schema.get(part, {})
-            return resolve_refs(ref_schema, root)
 
-        return {k: resolve_refs(v, root) for k, v in schema.items()}
+            result, circular = resolve_refs(ref_schema, root, visited)
+            has_circular = has_circular or circular
+
+            # Remove from visited after resolution (allows the same ref in different branches)
+            visited.discard(ref_path)
+
+            return result, has_circular
+
+        resolved_dict = {}
+        for k, v in schema.items():
+            resolved_value, circular = resolve_refs(v, root, visited)
+            resolved_dict[k] = resolved_value
+            has_circular = has_circular or circular
+        return resolved_dict, has_circular
 
     elif isinstance(schema, list):
-        return [resolve_refs(item, root) for item in schema]
+        resolved_list = []
+        for item in schema:
+            resolved_item, circular = resolve_refs(item, root, visited)
+            resolved_list.append(resolved_item)
+            has_circular = has_circular or circular
+        return resolved_list, has_circular
 
-    return schema
+    return schema, False
 
 
 def process_nullable_types(
@@ -45,8 +91,10 @@ def process_nullable_types(
 
 def generate_schema_from_graph(
     graph: CompiledStateGraph[Any, Any, Any],
-) -> Dict[str, Any]:
+) -> SchemaDetails:
     """Extract input/output schema from a LangGraph graph"""
+    input_circular_dependency = False
+    output_circular_dependency = False
     schema = {
         "input": {"type": "object", "properties": {}, "required": []},
         "output": {"type": "object", "properties": {}, "required": []},
@@ -55,7 +103,9 @@ def generate_schema_from_graph(
     if hasattr(graph, "input_schema"):
         if hasattr(graph.input_schema, "model_json_schema"):
             input_schema = graph.input_schema.model_json_schema()
-            unpacked_ref_def_properties = resolve_refs(input_schema)
+            unpacked_ref_def_properties, input_circular_dependency = resolve_refs(
+                input_schema
+            )
 
             # Process the schema to handle nullable types
             processed_properties = process_nullable_types(
@@ -70,7 +120,9 @@ def generate_schema_from_graph(
     if hasattr(graph, "output_schema"):
         if hasattr(graph.output_schema, "model_json_schema"):
             output_schema = graph.output_schema.model_json_schema()
-            unpacked_ref_def_properties = resolve_refs(output_schema)
+            unpacked_ref_def_properties, output_circular_dependency = resolve_refs(
+                output_schema
+            )
 
             # Process the schema to handle nullable types
             processed_properties = process_nullable_types(
@@ -82,4 +134,4 @@ def generate_schema_from_graph(
                 "required", []
             )
 
-    return schema
+    return SchemaDetails(schema, input_circular_dependency, output_circular_dependency)

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/src/uipath_langchain/_cli/cli_init.py

@@ -175,7 +175,7 @@ async def langgraph_init_middleware_async(
                     else loaded_graph
                 )
                 compiled_graph = state_graph.compile()
-                graph_schema = generate_schema_from_graph(compiled_graph)
+                schema_details = generate_schema_from_graph(compiled_graph)
 
                 mermaids[graph.name] = compiled_graph.get_graph(xray=1).draw_mermaid()
 
@@ -197,11 +197,17 @@ async def langgraph_init_middleware_async(
                     "filePath": graph.name,
                     "uniqueId": str(uuid.uuid4()),
                     "type": "agent",
-                    "input": graph_schema["input"],
-                    "output": graph_schema["output"],
+                    "input": schema_details.schema["input"],
+                    "output": schema_details.schema["output"],
                 }
                 entrypoints.append(new_entrypoint)
 
+                warning_circular_deps = f" schema of graph '{graph.name}' contains circular dependencies. Some types might not be correctly inferred."
+                if schema_details.has_input_circular_dependency:
+                    console.warning("Input" + warning_circular_deps)
+                if schema_details.has_output_circular_dependency:
+                    console.warning("Output" + warning_circular_deps)
+
             except Exception as e:
                 console.error(f"Error during graph load: {e}")
                 return MiddlewareResult(
@@ -243,6 +249,7 @@ async def langgraph_init_middleware_async(
                     should_continue=False,
                     should_include_stacktrace=True,
                 )
+
         console.success(f"Created {click.style(config_path, fg='cyan')} file.")
 
         generate_agents_md_files(options)

{uipath_langchain-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145 → uipath_langchain-0.0.147}/src/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-0.0.145/src/uipath_langchain/agent/react/state.py → uipath_langchain-0.0.147/src/uipath_langchain/agent/react/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-0.0.145 → uipath_langchain-0.0.147}/src/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."