uipath-langchain 0.0.140__py3-none-any.whl → 0.0.142__py3-none-any.whl

uipath_langchain/_cli/cli_debug.py

@@ -0,0 +1,95 @@
+import asyncio
+import os
+from typing import Optional
+
+from openinference.instrumentation.langchain import (
+    LangChainInstrumentor,
+    get_current_span,
+)
+from uipath._cli._debug._bridge import UiPathDebugBridge, get_debug_bridge
+from uipath._cli._debug._runtime import UiPathDebugRuntime
+from uipath._cli._runtime._contracts import (
+    UiPathRuntimeFactory,
+)
+from uipath._cli.middlewares import MiddlewareResult
+
+from .._tracing import LangChainExporter, _instrument_traceable_attributes
+from ._runtime._exception import LangGraphRuntimeError
+from ._runtime._runtime import (  # type: ignore[attr-defined]
+    LangGraphRuntimeContext,
+    LangGraphScriptRuntime,
+)
+from ._utils._graph import LangGraphConfig
+
+
+def langgraph_debug_middleware(
+    entrypoint: Optional[str], input: Optional[str], resume: bool, **kwargs
+) -> MiddlewareResult:
+    """Middleware to handle LangGraph execution"""
+    config = LangGraphConfig()
+    if not config.exists:
+        return MiddlewareResult(
+            should_continue=True
+        )  # Continue with normal flow if no langgraph.json
+
+    try:
+
+        async def execute():
+            context = LangGraphRuntimeContext.with_defaults(**kwargs)
+            context.entrypoint = entrypoint
+            context.input = input
+            context.resume = resume
+            context.execution_id = context.job_id or "default"
+
+            _instrument_traceable_attributes()
+
+            def generate_runtime(
+                ctx: LangGraphRuntimeContext,
+            ) -> LangGraphScriptRuntime:
+                runtime = LangGraphScriptRuntime(ctx, ctx.entrypoint)
+                # If not resuming and no job id, delete the previous state file
+                if not ctx.resume and ctx.job_id is None:
+                    if os.path.exists(runtime.state_file_path):
+                        os.remove(runtime.state_file_path)
+                return runtime
+
+            runtime_factory = UiPathRuntimeFactory(
+                LangGraphScriptRuntime,
+                LangGraphRuntimeContext,
+                runtime_generator=generate_runtime,
+                context_generator=lambda: context,
+            )
+
+            if context.job_id:
+                runtime_factory.add_span_exporter(LangChainExporter())
+
+            runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
+
+            debug_bridge: UiPathDebugBridge = get_debug_bridge(context)
+
+            async with UiPathDebugRuntime.from_debug_context(
+                factory=runtime_factory,
+                context=context,
+                debug_bridge=debug_bridge,
+            ) as debug_runtime:
+                await debug_runtime.execute()
+
+        asyncio.run(execute())
+
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=None,
+        )
+
+    except LangGraphRuntimeError as e:
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=e.error_info.detail,
+            should_include_stacktrace=True,
+        )
+    except Exception as e:
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=f"Error: {str(e)}",
+            should_include_stacktrace=True,
+        )

uipath_langchain/_cli/cli_init.py

@@ -1,9 +1,14 @@
 import asyncio
+import importlib.resources
 import json
 import os
+import shutil
 import uuid
+from collections.abc import Generator
+from enum import Enum
 from typing import Any, Callable, Dict, overload
 
+import click
 from langgraph.graph.state import CompiledStateGraph
 from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
@@ -14,6 +19,14 @@ from ._utils._graph import LangGraphConfig
 console = ConsoleLogger()
 
 
+class FileOperationStatus(str, Enum):
+    """Status of a file operation."""
+
+    CREATED = "created"
+    UPDATED = "updated"
+    SKIPPED = "skipped"
+
+
 def resolve_refs(schema, root=None):
     """Recursively resolves $ref references in a JSON schema."""
     if root is None:
@@ -96,6 +109,120 @@ def generate_schema_from_graph(
     return schema
 
 
+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,
@@ -185,7 +312,9 @@ async def langgraph_init_middleware_async(
             try:
                 with open(mermaid_file_path, "w") as f:
                     f.write(mermaid_content)
-                console.success(f" Created '{mermaid_file_path}' file.")
+                console.success(
+                    f"Created {click.style(mermaid_file_path, fg='cyan')} file."
+                )
             except Exception as write_error:
                 console.error(
                     f"Error writing mermaid file for '{graph_name}': {str(write_error)}"
@@ -194,7 +323,10 @@ async def langgraph_init_middleware_async(
                     should_continue=False,
                     should_include_stacktrace=True,
                 )
-        console.success(f" Created '{config_path}' file.")
+        console.success(f"Created {click.style(config_path, fg='cyan')} file.")
+
+        generate_agents_md_files(options)
+
         return MiddlewareResult(should_continue=False)
 
     except Exception as e:

uipath_langchain/_cli/cli_run.py

@@ -6,10 +6,13 @@ from openinference.instrumentation.langchain import (
     LangChainInstrumentor,
     get_current_span,
 )
+from uipath._cli._debug._bridge import ConsoleDebugBridge, UiPathDebugBridge
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
+    UiPathRuntimeResult,
 )
 from uipath._cli.middlewares import MiddlewareResult
+from uipath._events._events import UiPathAgentStateEvent
 
 from .._tracing import LangChainExporter, _instrument_traceable_attributes
 from ._runtime._exception import LangGraphRuntimeError
@@ -31,34 +34,44 @@ def langgraph_run_middleware(
         )  # Continue with normal flow if no langgraph.json
 
     try:
-        context = LangGraphRuntimeContext.with_defaults(**kwargs)
-        context.entrypoint = entrypoint
-        context.input = input
-        context.resume = resume
 
-        _instrument_traceable_attributes()
+        async def execute():
+            context = LangGraphRuntimeContext.with_defaults(**kwargs)
+            context.entrypoint = entrypoint
+            context.input = input
+            context.resume = resume
+            context.execution_id = context.job_id or "default"
+            _instrument_traceable_attributes()
 
-        def generate_runtime(ctx: LangGraphRuntimeContext) -> LangGraphScriptRuntime:
-            runtime = LangGraphScriptRuntime(ctx, ctx.entrypoint)
-            # If not resuming and no job id, delete the previous state file
-            if not ctx.resume and ctx.job_id is None:
-                if os.path.exists(runtime.state_file_path):
-                    os.remove(runtime.state_file_path)
-            return runtime
+            def generate_runtime(
+                ctx: LangGraphRuntimeContext,
+            ) -> LangGraphScriptRuntime:
+                runtime = LangGraphScriptRuntime(ctx, ctx.entrypoint)
+                # If not resuming and no job id, delete the previous state file
+                if not ctx.resume and ctx.job_id is None:
+                    if os.path.exists(runtime.state_file_path):
+                        os.remove(runtime.state_file_path)
+                return runtime
 
-        async def execute():
             runtime_factory = UiPathRuntimeFactory(
                 LangGraphScriptRuntime,
                 LangGraphRuntimeContext,
                 runtime_generator=generate_runtime,
             )
 
-            if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
-
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 
-            await runtime_factory.execute(context)
+            if context.job_id:
+                runtime_factory.add_span_exporter(LangChainExporter())
+                await runtime_factory.execute(context)
+            else:
+                debug_bridge: UiPathDebugBridge = ConsoleDebugBridge()
+                await debug_bridge.emit_execution_started(context.execution_id)
+                async for event in runtime_factory.stream(context):
+                    if isinstance(event, UiPathRuntimeResult):
+                        await debug_bridge.emit_execution_completed(event)
+                    elif isinstance(event, UiPathAgentStateEvent):
+                        await debug_bridge.emit_state_update(event)
 
         asyncio.run(execute())
 

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/middlewares.py

@@ -1,5 +1,6 @@
 from uipath._cli.middlewares import Middlewares
 
+from ._cli.cli_debug import langgraph_debug_middleware
 from ._cli.cli_dev import langgraph_dev_middleware
 from ._cli.cli_eval import langgraph_eval_middleware
 from ._cli.cli_init import langgraph_init_middleware
@@ -14,3 +15,4 @@ def register_middleware():
     Middlewares.register("new", langgraph_new_middleware)
     Middlewares.register("dev", langgraph_dev_middleware)
     Middlewares.register("eval", langgraph_eval_middleware)
+    Middlewares.register("debug", langgraph_debug_middleware)

uipath_langchain/tools/preconfigured.py

@@ -11,13 +11,13 @@ from langgraph.types import interrupt
 from pydantic import BaseModel
 from uipath import UiPath
 from uipath.agent.models.agent import (
-    AgentDefinition,
     AgentEscalationChannel,
     AgentEscalationResourceConfig,
     AgentIntegrationToolParameter,
     AgentIntegrationToolResourceConfig,
     AgentProcessToolResourceConfig,
     AgentResourceConfig,
+    LowCodeAgentDefinition,
 )
 from uipath.models import CreateAction, InvokeProcess
 from uipath.models.connections import ConnectionTokenType
@@ -208,7 +208,7 @@ def create_resource_tool(
 
 
 def safe_extract_tools(
-    agent_definition: AgentDefinition, cache: Optional[BaseCache] = None
+    agent_definition: LowCodeAgentDefinition, cache: Optional[BaseCache] = None
 ) -> list[BaseTool]:
     tools = []
     for resource in agent_definition.resources:

{uipath_langchain-0.0.140.dist-info → uipath_langchain-0.0.142.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.140
+Version: 0.0.142
 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.76
+Requires-Dist: uipath<2.2.0,>=2.1.101
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.140.dist-info → uipath_langchain-0.0.142.dist-info}/RECORD

@@ -1,21 +1,25 @@
 uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
-uipath_langchain/middlewares.py,sha256=6ljfbtWekrYc5G9KWDLSaViJ1DVIaNM-4qeB1BfHywE,731
+uipath_langchain/middlewares.py,sha256=x3U_tmDIyMXPLzq6n-oNRAnpAF6pKa9wfkPYwE-oUfo,848
+uipath_langchain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
+uipath_langchain/_cli/cli_debug.py,sha256=RQqBVne3OdXYPvgl5f7kIrV5zztA8W8LMXWex7oOQeU,3221
 uipath_langchain/_cli/cli_dev.py,sha256=l3XFHrh-0OUFJq3zLMKuzedJAluGQBIZQTHP1KWOmpw,1725
 uipath_langchain/_cli/cli_eval.py,sha256=r8mGlKh-ymxfKrvrU4n0Hg3pQv36c_NhTNR_eokyQEM,3650
-uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwvHILs,8199
+uipath_langchain/_cli/cli_init.py,sha256=B-Ht1lz4HNlpYELZU7DLNhSrhGJbsaCdU9UMO2iHUgM,12654
 uipath_langchain/_cli/cli_new.py,sha256=KKLxCzz7cDQ__rRr_a496IHWlSQXhmrBNgmKHnXAnTY,2336
-uipath_langchain/_cli/cli_run.py,sha256=X_DI3VZ2RtID0aC5s-RiNy2_XD6qtJqxz6atX61oukM,2612
-uipath_langchain/_cli/_runtime/_context.py,sha256=UnELD9qmW6zEPIYJ3nXjP6EI88-DEJZ2_t1CRPvfypQ,623
+uipath_langchain/_cli/cli_run.py,sha256=-k7QsfHWRQUAvVB6l533SCC9Xcxm7NSWq_oR0iy6THY,3426
+uipath_langchain/_cli/_runtime/_context.py,sha256=mjmGEogKiO8tUV878BgV9rFIeA9MCmEH6hgs5W_dm4g,328
 uipath_langchain/_cli/_runtime/_conversation.py,sha256=ayghRqhyLeVUZg1WHnpeOYtPNhRwDOl4z8OSYiJkWSU,11529
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
 uipath_langchain/_cli/_runtime/_graph_resolver.py,sha256=5SmYr3KJ_Iy13QtN8XPOOmoSrdysDGlLsgfiebHDXfs,5296
-uipath_langchain/_cli/_runtime/_input.py,sha256=Zx-8ZEr5Z796gdd3NnrlNObMIuXJobAV9mZwOql67Lo,5658
-uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=HTLT9fDSZuAS1e0cAeFhBWxG1iJC0ISjGYgSOuCnfRM,9801
+uipath_langchain/_cli/_runtime/_input.py,sha256=MTupo0p4F1vCTQi_KPZYJ2Um1X3QCmm8GeqC32HZbks,5724
+uipath_langchain/_cli/_runtime/_output.py,sha256=DOIxc9BKYtESOr9sLaBeppskWfUPse8B2PUDOFin0oU,4829
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=ImDBluxga_WbIm9lnljjm7jGl1tZBPy5hUrXYOCcOIE,18262
 uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
 uipath_langchain/_cli/_templates/main.py.template,sha256=GpSblGH2hwS9ibqQmX2iB2nsmOA5zDfEEF4ChLiMxbQ,875
 uipath_langchain/_cli/_utils/_graph.py,sha256=nMJWy8FmaD9rqPUY2lHc5uVpUzbXD1RO12uJnhe0kdo,6803
+uipath_langchain/_resources/AGENTS.md,sha256=5VmIfaQ6H91VxInnxFmJklURXeWIIQpGQTYBEmvvoVA,1060
+uipath_langchain/_resources/REQUIRED_STRUCTURE.md,sha256=BRmWWFtM0qNXj5uumALVxq9h6pifJDGh5NzuyctuH1Q,2569
 uipath_langchain/_tracing/__init__.py,sha256=UqrLc_WimpzKY82M0LJsgJ-HFQUQFjOmOlD1XQ8V-R4,181
 uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZHAzNjGwbLjQn7jdX5yAgA,4343
 uipath_langchain/_tracing/_oteladapter.py,sha256=PD0gsC39ZNvrm0gsfnt1ti6DEy56sBA9sIoxaAbHFFM,8887
@@ -31,11 +35,11 @@ uipath_langchain/embeddings/embeddings.py,sha256=45gKyb6HVKigwE-0CXeZcAk33c0mtea
 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=xCP0hiQuFKIv45PTvMsoWlwsxJDs7goyZujKflYBngY,7476
+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.140.dist-info/METADATA,sha256=RD2Nx8F1T9nL3QEtgGWFRrtVgJN6rnVSdzMH1QtXYJ0,4275
-uipath_langchain-0.0.140.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.140.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.140.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.140.dist-info/RECORD,,
+uipath_langchain-0.0.142.dist-info/METADATA,sha256=tvJ8KYbN0xmVw3LNm-y7LfazY0wBVPTCswXlNkulGmw,4276
+uipath_langchain-0.0.142.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.142.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.142.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.142.dist-info/RECORD,,