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

uipath_langchain/_cli/_templates/main.py.template

@@ -1,29 +1,28 @@
-from langchain_anthropic import ChatAnthropic
 from langchain_core.messages import HumanMessage, SystemMessage
-from langchain_openai import ChatOpenAI
 from langgraph.graph import START, StateGraph, END
+from uipath_langchain.chat import UiPathChat
 from pydantic import BaseModel
-import os
 
-class GraphInput(BaseModel):
+llm = UiPathChat(model="gpt-4o-mini-2024-07-18")
+
+
+class GraphState(BaseModel):
     topic: str
 
+
 class GraphOutput(BaseModel):
     report: str
 
-async def generate_report(state: GraphInput) -> GraphOutput:
-    if os.getenv("ANTHROPIC_API_KEY"):
-        llm_model = ChatAnthropic(model="claude-3-5-sonnet-latest")
-    elif os.getenv("OPENAI_API_KEY"):
-        llm_model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
-    else:
-        raise Exception("Missing API Key. Please define either ANTHROPIC_API_KEY or OPENAI_API_KEY.")
 
+async def generate_report(state: GraphState) -> GraphOutput:
     system_prompt = "You are a report generator. Please provide a brief report based on the given topic."
-    output = await llm_model.ainvoke([SystemMessage(system_prompt), HumanMessage(state.topic)])
+    output = await llm.ainvoke(
+        [SystemMessage(system_prompt), HumanMessage(state.topic)]
+    )
     return GraphOutput(report=output.content)
 
-builder = StateGraph(input=GraphInput, output=GraphOutput)
+
+builder = StateGraph(GraphState, output=GraphOutput)
 
 builder.add_node("generate_report", generate_report)
 

uipath_langchain/_cli/cli_init.py

@@ -1,101 +1,148 @@
 import asyncio
-import json
+import importlib.resources
 import os
-import uuid
-from typing import Any, Dict
+import shutil
+from collections.abc import Generator
+from enum import Enum
+from typing import Any
 
-from langgraph.graph.state import CompiledStateGraph
+import click
 from uipath._cli._utils._console import ConsoleLogger
-from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
 from uipath._cli.middlewares import MiddlewareResult
 
-from ._utils._graph import LangGraphConfig
+from uipath_langchain.runtime.config import LangGraphConfig
 
 console = ConsoleLogger()
 
 
-def resolve_refs(schema, root=None):
-    """Recursively resolves $ref references in a JSON schema."""
-    if root is None:
-        root = schema  # Store the root schema to resolve $refs
-
-    if isinstance(schema, dict):
-        if "$ref" in schema:
-            ref_path = schema["$ref"].lstrip("#/").split("/")
-            ref_schema = root
-            for part in ref_path:
-                ref_schema = ref_schema.get(part, {})
-            return resolve_refs(ref_schema, root)
-
-        return {k: resolve_refs(v, root) for k, v in schema.items()}
-
-    elif isinstance(schema, list):
-        return [resolve_refs(item, root) for item in schema]
-
-    return schema
-
+class FileOperationStatus(str, Enum):
+    """Status of a file operation."""
+
+    CREATED = "created"
+    UPDATED = "updated"
+    SKIPPED = "skipped"
+
+
+def generate_agent_md_file(
+    target_directory: str,
+    file_name: str,
+    resource_name: str,
+    no_agents_md_override: bool,
+) -> tuple[str, FileOperationStatus] | None:
+    """Generate an agent-specific file from the packaged resource.
+
+    Args:
+        target_directory: The directory where the file should be created.
+        file_name: The name of the file should be created.
+        resource_name: The name of the resource folder where should be the file.
+        no_agents_md_override: Whether to override existing files.
+
+    Returns:
+        A tuple of (file_name, status) where status is a FileOperationStatus:
+        - CREATED: File was created
+        - UPDATED: File was overwritten
+        - SKIPPED: File exists and no_agents_md_override is True
+        Returns None if an error occurred.
+    """
+    target_path = os.path.join(target_directory, file_name)
+    will_override = os.path.exists(target_path)
+
+    if will_override and no_agents_md_override:
+        return file_name, FileOperationStatus.SKIPPED
+    try:
+        source_path = importlib.resources.files(resource_name).joinpath(file_name)
 
-def process_nullable_types(
-    schema: Dict[str, Any] | list[Any] | Any,
-) -> Dict[str, Any] | list[Any]:
-    """Process the schema to handle nullable types by removing anyOf with null and keeping the base type."""
-    if isinstance(schema, dict):
-        if "anyOf" in schema and len(schema["anyOf"]) == 2:
-            types = [t.get("type") for t in schema["anyOf"]]
-            if "null" in types:
-                non_null_type = next(
-                    t for t in schema["anyOf"] if t.get("type") != "null"
-                )
-                return non_null_type
+        with importlib.resources.as_file(source_path) as s_path:
+            shutil.copy(s_path, target_path)
 
-        return {k: process_nullable_types(v) for k, v in schema.items()}
-    elif isinstance(schema, list):
-        return [process_nullable_types(item) for item in schema]
-    return schema
+        return (
+            file_name,
+            FileOperationStatus.UPDATED
+            if will_override
+            else FileOperationStatus.CREATED,
+        )
 
+    except Exception as e:
+        console.warning(f"Could not create {file_name}: {e}")
+        return None
+
+
+def generate_specific_agents_md_files(
+    target_directory: str, no_agents_md_override: bool
+) -> Generator[tuple[str, FileOperationStatus], None, None]:
+    """Generate agent-specific files from the packaged resource.
+
+    Args:
+        target_directory: The directory where the files should be created.
+        no_agents_md_override: Whether to override existing files.
+
+    Yields:
+        Tuple of (file_name, status) for each file operation, where status is a FileOperationStatus:
+        - CREATED: File was created
+        - UPDATED: File was overwritten
+        - SKIPPED: File exists and was not overwritten
+    """
+    agent_dir = os.path.join(target_directory, ".agent")
+    os.makedirs(agent_dir, exist_ok=True)
+
+    file_configs = [
+        (target_directory, "CLAUDE.md", "uipath._resources"),
+        (agent_dir, "CLI_REFERENCE.md", "uipath._resources"),
+        (agent_dir, "SDK_REFERENCE.md", "uipath._resources"),
+        (target_directory, "AGENTS.md", "uipath_langchain._resources"),
+        (agent_dir, "REQUIRED_STRUCTURE.md", "uipath_langchain._resources"),
+    ]
+
+    for directory, file_name, resource_name in file_configs:
+        result = generate_agent_md_file(
+            directory, file_name, resource_name, no_agents_md_override
+        )
+        if result:
+            yield result
 
-def generate_schema_from_graph(graph: CompiledStateGraph) -> Dict[str, Any]:
-    """Extract input/output schema from a LangGraph graph"""
-    schema = {
-        "input": {"type": "object", "properties": {}, "required": []},
-        "output": {"type": "object", "properties": {}, "required": []},
-    }
 
-    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)
+def generate_agents_md_files(options: dict[str, Any]) -> None:
+    """Generate agent MD files and log categorized summary.
 
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
+    Args:
+        options: Options dictionary
+    """
+    current_directory = os.getcwd()
+    no_agents_md_override = options.get("no_agents_md_override", False)
 
-            schema["input"]["properties"] = processed_properties
-            schema["input"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
+    created_files = []
+    updated_files = []
+    skipped_files = []
 
-    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)
+    for file_name, status in generate_specific_agents_md_files(
+        current_directory, no_agents_md_override
+    ):
+        if status == FileOperationStatus.CREATED:
+            created_files.append(file_name)
+        elif status == FileOperationStatus.UPDATED:
+            updated_files.append(file_name)
+        elif status == FileOperationStatus.SKIPPED:
+            skipped_files.append(file_name)
 
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
+    if created_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in created_files)
+        console.success(f"Created: {files_str}")
 
-            schema["output"]["properties"] = processed_properties
-            schema["output"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
+    if updated_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in updated_files)
+        console.success(f"Updated: {files_str}")
 
-    return schema
+    if skipped_files:
+        files_str = ", ".join(click.style(f, fg="yellow") for f in skipped_files)
+        console.info(f"Skipped (already exist): {files_str}")
 
 
-async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
+async def langgraph_init_middleware_async(
+    options: dict[str, Any] | None = None,
+) -> MiddlewareResult:
     """Middleware to check for langgraph.json and create uipath.json with schemas"""
+    options = options or {}
+
     config = LangGraphConfig()
     if not config.exists:
         return MiddlewareResult(
@@ -103,86 +150,8 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
         )  # Continue with normal flow if no langgraph.json
 
     try:
-        config.load_config()
-        entrypoints = []
-        all_bindings = {"version": "2.0", "resources": []}
-        mermaids = {}
-
-        for graph in config.graphs:
-            if entrypoint and graph.name != entrypoint:
-                continue
-
-            try:
-                loaded_graph = await graph.load_graph()
-                state_graph = (
-                    loaded_graph.builder
-                    if isinstance(loaded_graph, CompiledStateGraph)
-                    else loaded_graph
-                )
-                compiled_graph = state_graph.compile()
-                graph_schema = generate_schema_from_graph(compiled_graph)
-
-                mermaids[graph.name] = compiled_graph.get_graph(xray=1).draw_mermaid()
-
-                try:
-                    # Make sure the file path exists
-                    if os.path.exists(graph.file_path):
-                        file_bindings = generate_bindings_json(graph.file_path)
-
-                        # Merge bindings
-                        if "resources" in file_bindings:
-                            all_bindings["resources"] = file_bindings["resources"]
-                except Exception as e:
-                    console.warning(
-                        f"Warning: Could not generate bindings for {graph.file_path}: {str(e)}"
-                    )
-
-                new_entrypoint: dict[str, Any] = {
-                    "filePath": graph.name,
-                    "uniqueId": str(uuid.uuid4()),
-                    "type": "agent",
-                    "input": graph_schema["input"],
-                    "output": graph_schema["output"],
-                }
-                entrypoints.append(new_entrypoint)
-
-            except Exception as e:
-                console.error(f"Error during graph load: {e}")
-                return MiddlewareResult(
-                    should_continue=False,
-                    should_include_stacktrace=True,
-                )
-            finally:
-                await graph.cleanup()
-
-        if entrypoint and not entrypoints:
-            console.error(f"Error: No graph found with name '{entrypoint}'")
-            return MiddlewareResult(
-                should_continue=False,
-            )
-
-        uipath_config = {"entryPoints": entrypoints, "bindings": all_bindings}
-
-        # Save the uipath.json file
-        config_path = "uipath.json"
-        with open(config_path, "w") as f:
-            json.dump(uipath_config, f, indent=2)
-
-        for graph_name, mermaid_content in mermaids.items():
-            mermaid_file_path = f"{graph_name}.mermaid"
-            try:
-                with open(mermaid_file_path, "w") as f:
-                    f.write(mermaid_content)
-                console.success(f" Created '{mermaid_file_path}' file.")
-            except Exception as write_error:
-                console.error(
-                    f"Error writing mermaid file for '{graph_name}': {str(write_error)}"
-                )
-                return MiddlewareResult(
-                    should_continue=False,
-                    should_include_stacktrace=True,
-                )
-        console.success(f" Created '{config_path}' file.")
+        generate_agents_md_files(options)
+
         return MiddlewareResult(should_continue=False)
 
     except Exception as e:
@@ -193,6 +162,8 @@ async def langgraph_init_middleware_async(entrypoint: str) -> MiddlewareResult:
         )
 
 
-def langgraph_init_middleware(entrypoint: str) -> MiddlewareResult:
+def langgraph_init_middleware(
+    options: dict[str, Any] | None = None,
+) -> MiddlewareResult:
     """Middleware to check for langgraph.json and create uipath.json with schemas"""
-    return asyncio.run(langgraph_init_middleware_async(entrypoint))
+    return asyncio.run(langgraph_init_middleware_async(options))

uipath_langchain/_cli/cli_new.py

@@ -31,10 +31,9 @@ version = "0.0.1"
 description = "{project_name}"
 authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
 dependencies = [
-    "uipath-langchain>=0.0.106",
-    "langchain-anthropic>=0.3.8",
+    "uipath-langchain>=0.1.0",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 """
 
     with open(project_toml_path, "w") as f:
@@ -54,9 +53,6 @@ def langgraph_new_middleware(name: str) -> MiddlewareResult:
             console.success("Created 'langgraph.json' file.")
             generate_pyproject(directory, name)
             console.success("Created 'pyproject.toml' file.")
-            console.config(
-                f""" Please ensure to define either {click.style("ANTHROPIC_API_KEY", fg="bright_yellow")} or {click.style("OPENAI_API_KEY", fg="bright_yellow")} in your .env file. """
-            )
             init_command = """uipath init"""
             run_command = """uipath run agent '{"topic": "UiPath"}'"""
             console.hint(

uipath_langchain/_resources/AGENTS.md

@@ -0,0 +1,21 @@
+# Agent Code Patterns Reference
+
+This document provides practical code patterns for building UiPath coded agents using LangGraph and the UiPath Python SDK.
+
+---
+
+## Documentation Structure
+
+This documentation is split into multiple files for efficient context loading. Load only the files you need:
+
+1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
+   - **When to load:** Creating a new agent or understanding required patterns
+   - **Contains:** Required Pydantic models (Input, State, Output), LLM initialization patterns, standard agent template
+
+2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
+   - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
+   - **Contains:** All SDK services and methods with full signatures and type annotations
+
+3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
+   - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
+   - **Contains:** Command syntax, options, usage examples, and workflows

uipath_langchain/_resources/REQUIRED_STRUCTURE.md

@@ -0,0 +1,92 @@
+## Required Agent Structure
+
+**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.
+
+### Required Components
+
+Every agent implementation MUST include these three Pydantic models:
+
+```python
+from pydantic import BaseModel
+
+class Input(BaseModel):
+    """Define input fields that the agent accepts"""
+    # Add your input fields here
+    pass
+
+class State(BaseModel):
+    """Define the agent's internal state that flows between nodes"""
+    # Add your state fields here
+    pass
+
+class Output(BaseModel):
+    """Define output fields that the agent returns"""
+    # Add your output fields here
+    pass
+```
+
+### Required LLM Initialization
+
+Unless the user explicitly requests a different LLM provider, always use `UiPathChat`:
+
+```python
+from uipath_langchain.chat import UiPathChat
+
+llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
+```
+
+**Alternative LLMs** (only use if explicitly requested):
+- `ChatOpenAI` from `langchain_openai`
+- `ChatAnthropic` from `langchain_anthropic`
+- Other LangChain-compatible LLMs
+
+### Standard Agent Template
+
+Every agent should follow this basic structure:
+
+```python
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.graph import START, StateGraph, END
+from uipath_langchain.chat import UiPathChat
+from pydantic import BaseModel
+
+# 1. Define Input, State, and Output models
+class Input(BaseModel):
+    field: str
+
+class State(BaseModel):
+    field: str
+    result: str = ""
+
+class Output(BaseModel):
+    result: str
+
+# 2. Initialize UiPathChat LLM
+llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
+
+# 3. Define agent nodes (async functions)
+async def process_node(state: State) -> State:
+    response = await llm.ainvoke([HumanMessage(state.field)])
+    return State(field=state.field, result=response.content)
+
+async def output_node(state: State) -> Output:
+    return Output(result=state.result)
+
+# 4. Build the graph
+builder = StateGraph(State, input=Input, output=Output)
+builder.add_node("process", process_node)
+builder.add_node("output", output_node)
+builder.add_edge(START, "process")
+builder.add_edge("process", "output")
+builder.add_edge("output", END)
+
+# 5. Compile the graph
+graph = builder.compile()
+```
+
+**Key Rules**:
+1. Always use async/await for all node functions
+2. All nodes (except output) must accept and return `State`
+3. The final output node must return `Output`
+4. Use `StateGraph(State, input=Input, output=Output)` for initialization
+5. Always compile with `graph = builder.compile()`

uipath_langchain/{tracers → _tracing}/__init__.py

@@ -1,7 +1,5 @@
 from ._instrument_traceable import _instrument_traceable_attributes
-from .AsyncUiPathTracer import AsyncUiPathTracer
 
 __all__ = [
-    "AsyncUiPathTracer",
     "_instrument_traceable_attributes",
 ]

uipath_langchain/_tracing/_instrument_traceable.py

@@ -0,0 +1,134 @@
+import importlib
+import logging
+import sys
+from typing import Any, Callable
+
+from uipath.tracing import traced
+
+# Original module and traceable function references
+original_langsmith: Any = None
+original_traceable: Any = None
+
+logger = logging.getLogger(__name__)
+
+
+def _map_traceable_to_traced_args(
+    run_type: str | None = None,
+    name: str | None = None,
+    tags: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    """
+    Map LangSmith @traceable arguments to UiPath @traced() arguments.
+
+    Args:
+        run_type: Function type (tool, chain, llm, retriever, etc.)
+        name: Custom name for the traced function
+        tags: List of tags for categorization
+        metadata: Additional metadata dictionary
+        **kwargs: Additional arguments (ignored)
+
+    Returns:
+        Dict containing mapped arguments for @traced()
+    """
+    traced_args = {}
+
+    # Direct mappings
+    if name is not None:
+        traced_args["name"] = name
+
+    # Pass through run_type directly to UiPath @traced()
+    if run_type:
+        traced_args["run_type"] = run_type
+
+    # For span_type, we can derive from run_type or use a default
+    if run_type:
+        # Map run_type to appropriate span_type for OpenTelemetry
+        span_type_mapping = {
+            "tool": "tool_call",
+            "chain": "chain_execution",
+            "llm": "llm_call",
+            "retriever": "retrieval",
+            "embedding": "embedding",
+            "prompt": "prompt_template",
+            "parser": "output_parser",
+        }
+        traced_args["span_type"] = span_type_mapping.get(run_type, run_type)
+
+    # Note: UiPath @traced() doesn't support custom attributes directly
+    # Tags and metadata information is lost in the current mapping
+    # This could be enhanced in future versions
+
+    return traced_args
+
+
+def otel_traceable_adapter(
+    func: Callable[..., Any] | None = None,
+    *,
+    run_type: str | None = None,
+    name: str | None = None,
+    tags: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
+    **kwargs: Any,
+):
+    """
+    OTEL-based adapter that converts LangSmith @traceable decorator calls to UiPath @traced().
+
+    This function maintains the same interface as LangSmith's @traceable but uses
+    UiPath's OpenTelemetry-based tracing system underneath.
+
+    Args:
+        func: Function to be decorated (when used without parentheses)
+        run_type: Type of function (tool, chain, llm, etc.)
+        name: Custom name for tracing
+        tags: List of tags for categorization
+        metadata: Additional metadata dictionary
+        **kwargs: Additional arguments (for future compatibility)
+
+    Returns:
+        Decorated function or decorator function
+    """
+
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        # Map arguments to @traced() format
+        traced_args = _map_traceable_to_traced_args(
+            run_type=run_type, name=name, tags=tags, metadata=metadata, **kwargs
+        )
+
+        # Apply UiPath @traced() decorator
+        return traced(**traced_args)(f)
+
+    # Handle both @traceable and @traceable(...) usage patterns
+    if func is None:
+        # Called as @traceable(...) - return decorator
+        return decorator
+    else:
+        # Called as @traceable - apply decorator directly
+        return decorator(func)
+
+
+def _instrument_traceable_attributes():
+    """Apply the patch to langsmith module at import time."""
+    global original_langsmith, original_traceable
+
+    # Import the original module if not already done
+    if original_langsmith is None:
+        # Temporarily remove our custom module from sys.modules
+        if "langsmith" in sys.modules:
+            original_langsmith = sys.modules["langsmith"]
+            del sys.modules["langsmith"]
+
+        # Import the original module
+        original_langsmith = importlib.import_module("langsmith")
+
+        # Store the original traceable
+        original_traceable = original_langsmith.traceable
+
+        # Replace the traceable function with our patched version
+        original_langsmith.traceable = otel_traceable_adapter
+
+        # Put our modified module back
+        sys.modules["langsmith"] = original_langsmith
+
+    return original_langsmith

uipath_langchain/_utils/__init__.py

@@ -1,4 +1,3 @@
-from ..tracers._instrument_traceable import _instrument_traceable_attributes
 from ._request_mixin import UiPathRequestMixin
 
-__all__ = ["UiPathRequestMixin", "_instrument_traceable_attributes"]
+__all__ = ["UiPathRequestMixin"]