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

uipath_langchain/_cli/cli_init.py

@@ -1,105 +1,144 @@
 import asyncio
-import json
+import importlib.resources
 import os
-import uuid
-from typing import Any, Callable, Dict, overload
+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
-
-
-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
-
-        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
-
-
-def generate_schema_from_graph(
-    graph: CompiledStateGraph[Any, Any, Any],
-) -> 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)
-
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
-
-            schema["input"]["properties"] = processed_properties
-            schema["input"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
-
-    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)
-
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
-
-            schema["output"]["properties"] = processed_properties
-            schema["output"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
-
-    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)
+
+        with importlib.resources.as_file(source_path) as s_path:
+            shutil.copy(s_path, target_path)
+
+        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_agents_md_files(options: dict[str, Any]) -> None:
+    """Generate agent MD files and log categorized summary.
+
+    Args:
+        options: Options dictionary
+    """
+    current_directory = os.getcwd()
+    no_agents_md_override = options.get("no_agents_md_override", False)
+
+    created_files = []
+    updated_files = []
+    skipped_files = []
+
+    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)
+
+    if created_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in created_files)
+        console.success(f"Created: {files_str}")
+
+    if updated_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in updated_files)
+        console.success(f"Updated: {files_str}")
+
+    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,
     options: dict[str, Any] | None = None,
-    write_config: Callable[[Any], str] | None = None,
 ) -> MiddlewareResult:
     """Middleware to check for langgraph.json and create uipath.json with schemas"""
     options = options or {}
@@ -111,90 +150,8 @@ async def langgraph_init_middleware_async(
         )  # 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:
-                    should_infer_bindings = options.get("infer_bindings", True)
-                    # Make sure the file path exists
-                    if os.path.exists(graph.file_path) and should_infer_bindings:
-                        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}
-
-        if write_config:
-            config_path = write_config(uipath_config)
-        else:
-            # Save the uipath.json file
-            config_path = "uipath.json"
-            with open(config_path, "w") as f:
-                json.dump(uipath_config, f, indent=4)
-
-        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:
@@ -205,26 +162,8 @@ async def langgraph_init_middleware_async(
         )
 
 
-@overload
-def langgraph_init_middleware(
-    entrypoint: str,
-) -> MiddlewareResult: ...
-
-
-@overload
-def langgraph_init_middleware(
-    entrypoint: str,
-    options: dict[str, Any],
-    write_config: Callable[[Any], str],
-) -> MiddlewareResult: ...
-
-
 def langgraph_init_middleware(
-    entrypoint: str,
     options: dict[str, Any] | None = None,
-    write_config: Callable[[Any], str] | None = None,
 ) -> MiddlewareResult:
     """Middleware to check for langgraph.json and create uipath.json with schemas"""
-    return asyncio.run(
-        langgraph_init_middleware_async(entrypoint, options, write_config)
-    )
+    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:

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/_tracing/__init__.py

@@ -1,4 +1,5 @@
 from ._instrument_traceable import _instrument_traceable_attributes
-from ._oteladapter import LangChainExporter
 
-__all__ = ["LangChainExporter", "_instrument_traceable_attributes"]
+__all__ = [
+    "_instrument_traceable_attributes",
+]

uipath_langchain/_tracing/_instrument_traceable.py

@@ -1,7 +1,7 @@
 import importlib
 import logging
 import sys
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable
 
 from uipath.tracing import traced
 
@@ -12,14 +12,13 @@ original_traceable: Any = None
 logger = logging.getLogger(__name__)
 
 
-# Apply the patch
 def _map_traceable_to_traced_args(
-    run_type: Optional[str] = None,
-    name: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    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]:
+) -> dict[str, Any]:
     """
     Map LangSmith @traceable arguments to UiPath @traced() arguments.
 
@@ -65,12 +64,12 @@ def _map_traceable_to_traced_args(
 
 
 def otel_traceable_adapter(
-    func: Optional[Callable[..., Any]] = None,
+    func: Callable[..., Any] | None = None,
     *,
-    run_type: Optional[str] = None,
-    name: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    run_type: str | None = None,
+    name: str | None = None,
+    tags: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
     **kwargs: Any,
 ):
     """