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

uipath_langchain/_cli/_runtime/_context.py

@@ -1,17 +1,12 @@
 from typing import Any, Optional, Union
 
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from langgraph.graph import StateGraph
 from uipath._cli._runtime._contracts import UiPathRuntimeContext
 
-from .._utils._graph import LangGraphConfig
-
 
 class LangGraphRuntimeContext(UiPathRuntimeContext):
     """Context information passed throughout the runtime execution."""
 
-    langgraph_config: Optional[LangGraphConfig] = None
-    state_graph: Optional[StateGraph[Any, Any]] = None
     output: Optional[Any] = None
     state: Optional[Any] = (
         None  # TypedDict issue, the actual type is: Optional[langgraph.types.StateSnapshot]

uipath_langchain/_cli/_runtime/_conversation.py

@@ -173,6 +173,14 @@ def map_message(
                             content_part_sequence=idx,
                         ),
                     )
+        elif isinstance(message.content, str) and message.content:
+            msg_event.content_part = UiPathConversationContentPartEvent(
+                content_part_id=f"content-{message.id}",
+                chunk=UiPathConversationContentPartChunkEvent(
+                    data=message.content,
+                    content_part_sequence=0,
+                ),
+            )
 
         stop_reason = message.response_metadata.get("stop_reason")
         if not message.content and stop_reason in ("tool_use", "end_turn"):

uipath_langchain/_cli/_runtime/_graph_resolver.py

@@ -0,0 +1,143 @@
+import asyncio
+from typing import Any, Awaitable, Callable, Optional
+
+from langgraph.graph.state import CompiledStateGraph, StateGraph
+from uipath._cli._runtime._contracts import (
+    UiPathErrorCategory,
+)
+
+from .._utils._graph import GraphConfig, LangGraphConfig
+from ._exception import LangGraphRuntimeError
+
+
+class LangGraphJsonResolver:
+    def __init__(self, entrypoint: Optional[str] = None) -> None:
+        self.entrypoint = entrypoint
+        self.graph_config: Optional[GraphConfig] = None
+        self._lock = asyncio.Lock()
+        self._graph_cache: Optional[StateGraph[Any, Any, Any]] = None
+        self._resolving: bool = False
+
+    async def __call__(self) -> StateGraph[Any, Any, Any]:
+        # Fast path: if already resolved, return immediately without locking
+        if self._graph_cache is not None:
+            return self._graph_cache
+
+        # Slow path: acquire lock and resolve
+        async with self._lock:
+            # Double-check after acquiring lock (another coroutine may have resolved it)
+            if self._graph_cache is not None:
+                return self._graph_cache
+
+            self._graph_cache = await self._resolve(self.entrypoint)
+            return self._graph_cache
+
+    async def _resolve(self, entrypoint: Optional[str]) -> StateGraph[Any, Any, Any]:
+        config = LangGraphConfig()
+        if not config.exists:
+            raise LangGraphRuntimeError(
+                "CONFIG_MISSING",
+                "Invalid configuration",
+                "Failed to load configuration",
+                UiPathErrorCategory.DEPLOYMENT,
+            )
+
+        try:
+            config.load_config()
+        except Exception as e:
+            raise LangGraphRuntimeError(
+                "CONFIG_INVALID",
+                "Invalid configuration",
+                f"Failed to load configuration: {str(e)}",
+                UiPathErrorCategory.DEPLOYMENT,
+            ) from e
+
+        # Determine entrypoint if not provided
+        graphs = config.graphs
+        if not entrypoint and len(graphs) == 1:
+            entrypoint = graphs[0].name
+        elif not entrypoint:
+            graph_names = ", ".join(g.name for g in graphs)
+            raise LangGraphRuntimeError(
+                "ENTRYPOINT_MISSING",
+                "Entrypoint required",
+                f"Multiple graphs available. Please specify one of: {graph_names}.",
+                UiPathErrorCategory.DEPLOYMENT,
+            )
+
+        # Get the specified graph
+        self.graph_config = config.get_graph(entrypoint)
+        if not self.graph_config:
+            raise LangGraphRuntimeError(
+                "GRAPH_NOT_FOUND",
+                "Graph not found",
+                f"Graph '{entrypoint}' not found.",
+                UiPathErrorCategory.DEPLOYMENT,
+            )
+        try:
+            loaded_graph = await self.graph_config.load_graph()
+            return (
+                loaded_graph.builder
+                if isinstance(loaded_graph, CompiledStateGraph)
+                else loaded_graph
+            )
+        except ImportError as e:
+            raise LangGraphRuntimeError(
+                "GRAPH_IMPORT_ERROR",
+                "Graph import failed",
+                f"Failed to import graph '{entrypoint}': {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+        except TypeError as e:
+            raise LangGraphRuntimeError(
+                "GRAPH_TYPE_ERROR",
+                "Invalid graph type",
+                f"Graph '{entrypoint}' is not a valid StateGraph or CompiledStateGraph: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+        except ValueError as e:
+            raise LangGraphRuntimeError(
+                "GRAPH_VALUE_ERROR",
+                "Invalid graph value",
+                f"Invalid value in graph '{entrypoint}': {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+        except Exception as e:
+            raise LangGraphRuntimeError(
+                "GRAPH_LOAD_ERROR",
+                "Failed to load graph",
+                f"Unexpected error loading graph '{entrypoint}': {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+    async def cleanup(self):
+        """Clean up resources"""
+        async with self._lock:
+            if self.graph_config:
+                await self.graph_config.cleanup()
+                self.graph_config = None
+            self._graph_cache = None
+
+
+AsyncResolver = Callable[[], Awaitable[StateGraph[Any, Any, Any]]]
+
+
+class LangGraphJsonResolverContext:
+    """
+    Async context manager wrapping LangGraphJsonResolver.
+    Returns a callable that can be passed directly as AsyncResolver to LangGraphRuntime.
+    Thread-safe and reuses the same resolved graph across concurrent executions.
+    """
+
+    def __init__(self, entrypoint: Optional[str] = None) -> None:
+        self._resolver = LangGraphJsonResolver(entrypoint)
+
+    async def __aenter__(self) -> AsyncResolver:
+        # Return a callable that safely reuses the cached graph
+        async def resolver_callable() -> StateGraph[Any, Any, Any]:
+            return await self._resolver()
+
+        return resolver_callable
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self._resolver.cleanup()

uipath_langchain/_cli/_runtime/_runtime.py

@@ -1,24 +1,22 @@
-import json
 import logging
 import os
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, List, Optional, Sequence
 
 from langchain_core.callbacks.base import BaseCallbackHandler
 from langchain_core.messages import BaseMessage
 from langchain_core.runnables.config import RunnableConfig
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
-from langgraph.graph.state import CompiledStateGraph
 from uipath._cli._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
     UiPathRuntimeResult,
 )
 
-from .._utils._graph import LangGraphConfig
 from ._context import LangGraphRuntimeContext
 from ._conversation import map_message
 from ._exception import LangGraphRuntimeError
+from ._graph_resolver import AsyncResolver, LangGraphJsonResolver
 from ._input import LangGraphInputProcessor
 from ._output import LangGraphOutputProcessor
 
@@ -31,9 +29,10 @@ class LangGraphRuntime(UiPathBaseRuntime):
     This allows using the class with 'async with' statements.
     """
 
-    def __init__(self, context: LangGraphRuntimeContext):
+    def __init__(self, context: LangGraphRuntimeContext, graph_resolver: AsyncResolver):
         super().__init__(context)
         self.context: LangGraphRuntimeContext = context
+        self.graph_resolver: AsyncResolver = graph_resolver
 
     async def execute(self) -> Optional[UiPathRuntimeResult]:
         """
@@ -46,7 +45,8 @@ class LangGraphRuntime(UiPathBaseRuntime):
             LangGraphRuntimeError: If execution fails
         """
 
-        if self.context.state_graph is None:
+        graph = await self.graph_resolver()
+        if not graph:
             return None
 
         try:
@@ -56,9 +56,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 self.context.memory = memory
 
                 # Compile the graph with the checkpointer
-                graph = self.context.state_graph.compile(
-                    checkpointer=self.context.memory
-                )
+                compiled_graph = graph.compile(checkpointer=self.context.memory)
 
                 # Process input, handling resume if needed
                 input_processor = LangGraphInputProcessor(context=self.context)
@@ -86,48 +84,50 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 if max_concurrency is not None:
                     graph_config["max_concurrency"] = int(max_concurrency)
 
-                if self.context.chat_handler:
-                    async for stream_chunk in graph.astream(
+                if self.context.chat_handler or self.is_debug_run():
+                    final_chunk: Optional[dict[Any, Any]] = None
+                    async for stream_chunk in compiled_graph.astream(
                         processed_input,
                         graph_config,
-                        stream_mode="messages",
+                        stream_mode=["messages", "updates"],
                         subgraphs=True,
                     ):
-                        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
-                            continue
-
-                        _, (message, _) = stream_chunk
-                        event = map_message(
-                            message=message,
-                            conversation_id=self.context.execution_id,
-                            exchange_id=self.context.execution_id,
-                        )
-                        if event:
-                            self.context.chat_handler.on_event(event)
-
-                # Stream the output at debug time
-                elif self.is_debug_run():
-                    # Get final chunk while streaming
-                    final_chunk = None
-                    async for stream_chunk in graph.astream(
-                        processed_input,
-                        graph_config,
-                        stream_mode="updates",
-                        subgraphs=True,
-                    ):
-                        self._pretty_print(stream_chunk)
-                        final_chunk = stream_chunk
-
-                    self.context.output = self._extract_graph_result(final_chunk, graph)
+                        _, chunk_type, data = stream_chunk
+                        if chunk_type == "messages":
+                            if self.context.chat_handler:
+                                if isinstance(data, tuple):
+                                    message, _ = data
+                                    event = map_message(
+                                        message=message,
+                                        conversation_id=self.context.execution_id,
+                                        exchange_id=self.context.execution_id,
+                                    )
+                                    if event:
+                                        self.context.chat_handler.on_event(event)
+                        elif chunk_type == "updates":
+                            if isinstance(data, dict):
+                                # data is a dict, e.g. {'agent': {'messages': [...]}}
+                                for agent_data in data.values():
+                                    if isinstance(agent_data, dict):
+                                        messages = agent_data.get("messages", [])
+                                        if isinstance(messages, list):
+                                            for message in messages:
+                                                if isinstance(message, BaseMessage):
+                                                    message.pretty_print()
+                                final_chunk = data
+
+                    self.context.output = self._extract_graph_result(
+                        final_chunk, compiled_graph.output_channels
+                    )
                 else:
                     # Execute the graph normally at runtime or eval
-                    self.context.output = await graph.ainvoke(
+                    self.context.output = await compiled_graph.ainvoke(
                         processed_input, graph_config
                     )
 
                 # Get the state if available
                 try:
-                    self.context.state = await graph.aget_state(graph_config)
+                    self.context.state = await compiled_graph.aget_state(graph_config)
                 except Exception:
                     pass
 
@@ -177,95 +177,12 @@ class LangGraphRuntime(UiPathBaseRuntime):
             pass
 
     async def validate(self) -> None:
-        """Validate runtime inputs."""
-        """Load and validate the graph configuration ."""
-        if self.context.langgraph_config is None:
-            self.context.langgraph_config = LangGraphConfig()
-            if not self.context.langgraph_config.exists:
-                raise LangGraphRuntimeError(
-                    "CONFIG_MISSING",
-                    "Invalid configuration",
-                    "Failed to load configuration",
-                    UiPathErrorCategory.DEPLOYMENT,
-                )
-
-        try:
-            self.context.langgraph_config.load_config()
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "CONFIG_INVALID",
-                "Invalid configuration",
-                f"Failed to load configuration: {str(e)}",
-                UiPathErrorCategory.DEPLOYMENT,
-            ) from e
-
-        # Determine entrypoint if not provided
-        graphs = self.context.langgraph_config.graphs
-        if not self.context.entrypoint and len(graphs) == 1:
-            self.context.entrypoint = graphs[0].name
-        elif not self.context.entrypoint:
-            graph_names = ", ".join(g.name for g in graphs)
-            raise LangGraphRuntimeError(
-                "ENTRYPOINT_MISSING",
-                "Entrypoint required",
-                f"Multiple graphs available. Please specify one of: {graph_names}.",
-                UiPathErrorCategory.DEPLOYMENT,
-            )
-
-        # Get the specified graph
-        self.graph_config = self.context.langgraph_config.get_graph(
-            self.context.entrypoint
-        )
-        if not self.graph_config:
-            raise LangGraphRuntimeError(
-                "GRAPH_NOT_FOUND",
-                "Graph not found",
-                f"Graph '{self.context.entrypoint}' not found.",
-                UiPathErrorCategory.DEPLOYMENT,
-            )
-        try:
-            loaded_graph = await self.graph_config.load_graph()
-            self.context.state_graph = (
-                loaded_graph.builder
-                if isinstance(loaded_graph, CompiledStateGraph)
-                else loaded_graph
-            )
-        except ImportError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_IMPORT_ERROR",
-                "Graph import failed",
-                f"Failed to import graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except TypeError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_TYPE_ERROR",
-                "Invalid graph type",
-                f"Graph '{self.context.entrypoint}' is not a valid StateGraph or CompiledStateGraph: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except ValueError as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_VALUE_ERROR",
-                "Invalid graph value",
-                f"Invalid value in graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-        except Exception as e:
-            raise LangGraphRuntimeError(
-                "GRAPH_LOAD_ERROR",
-                "Failed to load graph",
-                f"Unexpected error loading graph '{self.context.entrypoint}': {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
+        pass
 
     async def cleanup(self):
-        if hasattr(self, "graph_config") and self.graph_config:
-            await self.graph_config.cleanup()
+        pass
 
-    def _extract_graph_result(
-        self, final_chunk, graph: CompiledStateGraph[Any, Any, Any]
-    ):
+    def _extract_graph_result(self, final_chunk, output_channels: str | Sequence[str]):
         """
         Extract the result from a LangGraph output chunk according to the graph's output channels.
 
@@ -283,11 +200,9 @@ class LangGraphRuntime(UiPathBaseRuntime):
             ]  # Extract data part from (namespace, data) tuple
 
         # If the result isn't a dict or graph doesn't define output channels, return as is
-        if not isinstance(final_chunk, dict) or not hasattr(graph, "output_channels"):
+        if not isinstance(final_chunk, dict):
             return final_chunk
 
-        output_channels = graph.output_channels
-
         # Case 1: Single output channel as string
         if isinstance(output_channels, str):
             if output_channels in final_chunk:
@@ -323,57 +238,18 @@ class LangGraphRuntime(UiPathBaseRuntime):
         # Fallback for any other case
         return final_chunk
 
-    def _pretty_print(self, stream_chunk: Union[Tuple[Any, Any], Dict[str, Any], Any]):
-        """
-        Pretty print a chunk from a LangGraph stream with stream_mode="updates" and subgraphs=True.
 
-        Args:
-            stream_chunk: A tuple of (namespace, updates) from graph.astream()
-        """
-        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
-            return
-
-        node_namespace = ""
-        chunk_namespace = stream_chunk[0]
-        node_updates = stream_chunk[1]
-
-        # Extract namespace if available
-        if chunk_namespace and len(chunk_namespace) > 0:
-            node_namespace = chunk_namespace[0]
-
-        if not isinstance(node_updates, dict):
-            logger.info("Raw update: %s", node_updates)
-            return
-
-        # Process each node's updates
-        for node_name, node_result in node_updates.items():
-            # Log node identifier with appropriate namespace context
-            if node_namespace:
-                logger.info("[%s][%s]", node_namespace, node_name)
-            else:
-                logger.info("[%s]", node_name)
-
-            # Handle non-dict results
-            if not isinstance(node_result, dict):
-                logger.info("%s", node_result)
-                continue
-
-            # Process messages specially
-            messages = node_result.get("messages", [])
-            if isinstance(messages, list):
-                for message in messages:
-                    if isinstance(message, BaseMessage):
-                        message.pretty_print()
-
-            # Exclude "messages" from node_result and pretty-print the rest
-            metadata = {k: v for k, v in node_result.items() if k != "messages"}
-            if metadata:
-                try:
-                    formatted_metadata = json.dumps(
-                        metadata,
-                        indent=2,
-                        ensure_ascii=False,
-                    )
-                    logger.info("%s", formatted_metadata)
-                except (TypeError, ValueError):
-                    pass
+class LangGraphScriptRuntime(LangGraphRuntime):
+    """
+    Resolves the graph from langgraph.json config file and passes it to the base runtime.
+    """
+
+    def __init__(
+        self, context: LangGraphRuntimeContext, entrypoint: Optional[str] = None
+    ):
+        self.resolver = LangGraphJsonResolver(entrypoint=entrypoint)
+        super().__init__(context, self.resolver)
+
+    async def cleanup(self):
+        await super().cleanup()
+        await self.resolver.cleanup()

uipath_langchain/_cli/cli_dev.py

@@ -12,7 +12,7 @@ from uipath._cli.middlewares import MiddlewareResult
 
 from .._tracing import _instrument_traceable_attributes
 from ._runtime._context import LangGraphRuntimeContext
-from ._runtime._runtime import LangGraphRuntime
+from ._runtime._runtime import LangGraphScriptRuntime
 
 console = ConsoleLogger()
 
@@ -22,8 +22,14 @@ def langgraph_dev_middleware(interface: Optional[str]) -> MiddlewareResult:
 
     try:
         if interface == "terminal":
+
+            def generate_runtime(
+                ctx: LangGraphRuntimeContext,
+            ) -> LangGraphScriptRuntime:
+                return LangGraphScriptRuntime(ctx, ctx.entrypoint)
+
             runtime_factory = UiPathRuntimeFactory(
-                LangGraphRuntime, LangGraphRuntimeContext
+                LangGraphScriptRuntime, LangGraphRuntimeContext, generate_runtime
             )
 
             _instrument_traceable_attributes()

uipath_langchain/_cli/cli_eval.py

@@ -17,7 +17,7 @@ from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
 
 from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
-from uipath_langchain._cli._runtime._runtime import LangGraphRuntime
+from uipath_langchain._cli._runtime._runtime import LangGraphScriptRuntime
 from uipath_langchain._cli._utils._graph import LangGraphConfig
 from uipath_langchain._tracing import (
     LangChainExporter,
@@ -48,10 +48,9 @@ def langgraph_eval_middleware(
         asyncio.run(console_reporter.subscribe_to_eval_runtime_events(event_bus))
 
         def generate_runtime_context(
-            context_entrypoint: str, langgraph_config: LangGraphConfig, **context_kwargs
+            context_entrypoint: str, **context_kwargs
         ) -> LangGraphRuntimeContext:
             context = LangGraphRuntimeContext.with_defaults(**context_kwargs)
-            context.langgraph_config = langgraph_config
             context.entrypoint = context_entrypoint
             return context
 
@@ -63,14 +62,17 @@ def langgraph_eval_middleware(
         eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
         eval_context.eval_ids = eval_ids
 
+        def generate_runtime(ctx: LangGraphRuntimeContext) -> LangGraphScriptRuntime:
+            return LangGraphScriptRuntime(ctx, ctx.entrypoint)
+
         runtime_factory = UiPathRuntimeFactory(
-            LangGraphRuntime,
+            LangGraphScriptRuntime,
             LangGraphRuntimeContext,
             context_generator=lambda **context_kwargs: generate_runtime_context(
                 context_entrypoint=runtime_entrypoint,
-                langgraph_config=config,
                 **context_kwargs,
             ),
+            runtime_generator=generate_runtime,
         )
 
         if eval_context.job_id:

uipath_langchain/_cli/cli_run.py

@@ -14,8 +14,8 @@ 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]
-    LangGraphRuntime,
     LangGraphRuntimeContext,
+    LangGraphScriptRuntime,
 )
 from ._utils._graph import LangGraphConfig
 
@@ -32,15 +32,14 @@ def langgraph_run_middleware(
 
     try:
         context = LangGraphRuntimeContext.with_defaults(**kwargs)
-        context.langgraph_config = config
         context.entrypoint = entrypoint
         context.input = input
         context.resume = resume
 
         _instrument_traceable_attributes()
 
-        def generate_runtime(ctx: LangGraphRuntimeContext) -> LangGraphRuntime:
-            runtime = LangGraphRuntime(ctx)
+        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):
@@ -49,7 +48,7 @@ def langgraph_run_middleware(
 
         async def execute():
             runtime_factory = UiPathRuntimeFactory(
-                LangGraphRuntime,
+                LangGraphScriptRuntime,
                 LangGraphRuntimeContext,
                 runtime_generator=generate_runtime,
             )

uipath_langchain/_utils/_request_mixin.py

@@ -9,7 +9,7 @@ import httpx
 import openai
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models.chat_models import _cleanup_llm_representation
-from pydantic import BaseModel, ConfigDict, Field, SecretStr
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, ValidationError
 from tenacity import (
     AsyncRetrying,
     Retrying,
@@ -17,7 +17,7 @@ from tenacity import (
     stop_after_attempt,
     wait_exponential_jitter,
 )
-from uipath._cli._runtime._contracts import UiPathErrorCategory
+from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 
 from uipath_langchain._cli._runtime._exception import LangGraphRuntimeError
@@ -36,6 +36,33 @@ def get_from_uipath_url():
     return None
 
 
+def _get_access_token(data):
+    """Get access token from settings, environment variables, or UiPath client factory."""
+    token = (
+        getattr(data["settings"], "access_token", None)
+        or os.getenv("UIPATH_ACCESS_TOKEN")
+        or os.getenv("UIPATH_SERVICE_TOKEN")
+    )
+
+    if token:
+        return token
+
+    try:
+        settings = UiPathClientFactorySettings(
+            UIPATH_BASE_URL=data["base_url"],
+            UIPATH_CLIENT_ID=data["client_id"],
+            UIPATH_CLIENT_SECRET=data["client_secret"],
+        )
+        return get_uipath_token_header(settings)
+    except ValidationError:
+        raise UiPathRuntimeError(
+            code="AUTHENTICATION_REQUIRED",
+            title="Authorization required",
+            detail="Authorization required. Please run uipath auth",
+            category=UiPathErrorCategory.USER,
+        ) from None
+
+
 class UiPathRequestMixin(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -62,19 +89,9 @@ class UiPathRequestMixin(BaseModel):
         alias="azure_endpoint",
     )
     access_token: Optional[str] = Field(
-        default_factory=lambda data: (
-            getattr(data["settings"], "access_token", None)
-            or os.getenv("UIPATH_ACCESS_TOKEN")  # Environment variable
-            or os.getenv("UIPATH_SERVICE_TOKEN")  # Environment variable
-            or get_uipath_token_header(
-                UiPathClientFactorySettings(
-                    UIPATH_BASE_URL=data["base_url"],
-                    UIPATH_CLIENT_ID=data["client_id"],
-                    UIPATH_CLIENT_SECRET=data["client_secret"],
-                )
-            )  # Get service token from UiPath
-        )
+        default_factory=lambda data: _get_access_token(data)
     )
+
     org_id: Any = Field(
         default_factory=lambda data: getattr(data["settings"], "org_id", None)
         or os.getenv("UIPATH_ORGANIZATION_ID", "")

uipath_langchain/chat/models.py

@@ -1,15 +1,15 @@
 import json
 import logging
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, AsyncIterator, Dict, Iterator, List, Literal, Optional, Union
 
 from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
 from langchain_core.language_models import LanguageModelInput
-from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage
 from langchain_core.messages.ai import UsageMetadata
-from langchain_core.outputs import ChatGeneration, ChatResult
+from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.runnables import Runnable
 from langchain_openai.chat_models import AzureChatOpenAI
 from pydantic import BaseModel
@@ -49,6 +49,54 @@ class UiPathAzureChatOpenAI(UiPathRequestMixin, AzureChatOpenAI):
         response = await self._acall(self.url, payload, self.auth_headers)
         return self._create_chat_result(response)
 
+    def _stream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[ChatGenerationChunk]:
+        if "tools" in kwargs and not kwargs["tools"]:
+            del kwargs["tools"]
+        payload = self._get_request_payload(messages, stop=stop, **kwargs)
+        response = self._call(self.url, payload, self.auth_headers)
+
+        # For non-streaming response, yield single chunk
+        chat_result = self._create_chat_result(response)
+        chunk = ChatGenerationChunk(
+            message=AIMessageChunk(
+                content=chat_result.generations[0].message.content,
+                additional_kwargs=chat_result.generations[0].message.additional_kwargs,
+                response_metadata=chat_result.generations[0].message.response_metadata,
+                usage_metadata=chat_result.generations[0].message.usage_metadata,  # type: ignore
+            )
+        )
+        yield chunk
+
+    async def _astream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        if "tools" in kwargs and not kwargs["tools"]:
+            del kwargs["tools"]
+        payload = self._get_request_payload(messages, stop=stop, **kwargs)
+        response = await self._acall(self.url, payload, self.auth_headers)
+
+        # For non-streaming response, yield single chunk
+        chat_result = self._create_chat_result(response)
+        chunk = ChatGenerationChunk(
+            message=AIMessageChunk(
+                content=chat_result.generations[0].message.content,
+                additional_kwargs=chat_result.generations[0].message.additional_kwargs,
+                response_metadata=chat_result.generations[0].message.response_metadata,
+                usage_metadata=chat_result.generations[0].message.usage_metadata,  # type: ignore
+            )
+        )
+        yield chunk
+
     def with_structured_output(
         self,
         schema: Optional[Any] = None,
@@ -217,6 +265,92 @@ class UiPathChat(UiPathRequestMixin, AzureChatOpenAI):
         response = await self._acall(self.url, payload, self.auth_headers)
         return self._create_chat_result(response)
 
+    def _stream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[ChatGenerationChunk]:
+        """Stream the LLM on a given prompt.
+
+        Args:
+            messages: the prompt composed of a list of messages.
+            stop: a list of strings on which the model should stop generating.
+            run_manager: A run manager with callbacks for the LLM.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            An iterator of ChatGenerationChunk objects.
+        """
+        if kwargs.get("tools"):
+            kwargs["tools"] = [tool["function"] for tool in kwargs["tools"]]
+        if "tool_choice" in kwargs and kwargs["tool_choice"]["type"] == "function":
+            kwargs["tool_choice"] = {
+                "type": "tool",
+                "name": kwargs["tool_choice"]["function"]["name"],
+            }
+        payload = self._get_request_payload(messages, stop=stop, **kwargs)
+        response = self._call(self.url, payload, self.auth_headers)
+
+        # For non-streaming response, yield single chunk
+        chat_result = self._create_chat_result(response)
+        chunk = ChatGenerationChunk(
+            message=AIMessageChunk(
+                content=chat_result.generations[0].message.content,
+                additional_kwargs=chat_result.generations[0].message.additional_kwargs,
+                response_metadata=chat_result.generations[0].message.response_metadata,
+                usage_metadata=chat_result.generations[0].message.usage_metadata,  # type: ignore
+                tool_calls=getattr(
+                    chat_result.generations[0].message, "tool_calls", None
+                ),
+            )
+        )
+        yield chunk
+
+    async def _astream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        """Async stream the LLM on a given prompt.
+
+        Args:
+            messages: the prompt composed of a list of messages.
+            stop: a list of strings on which the model should stop generating.
+            run_manager: A run manager with callbacks for the LLM.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            An async iterator of ChatGenerationChunk objects.
+        """
+        if kwargs.get("tools"):
+            kwargs["tools"] = [tool["function"] for tool in kwargs["tools"]]
+        if "tool_choice" in kwargs and kwargs["tool_choice"]["type"] == "function":
+            kwargs["tool_choice"] = {
+                "type": "tool",
+                "name": kwargs["tool_choice"]["function"]["name"],
+            }
+        payload = self._get_request_payload(messages, stop=stop, **kwargs)
+        response = await self._acall(self.url, payload, self.auth_headers)
+
+        # For non-streaming response, yield single chunk
+        chat_result = self._create_chat_result(response)
+        chunk = ChatGenerationChunk(
+            message=AIMessageChunk(
+                content=chat_result.generations[0].message.content,
+                additional_kwargs=chat_result.generations[0].message.additional_kwargs,
+                response_metadata=chat_result.generations[0].message.response_metadata,
+                usage_metadata=chat_result.generations[0].message.usage_metadata,  # type: ignore
+                tool_calls=getattr(
+                    chat_result.generations[0].message, "tool_calls", None
+                ),
+            )
+        )
+        yield chunk
+
     def with_structured_output(
         self,
         schema: Optional[Any] = None,

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

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

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

@@ -1,17 +1,18 @@
 uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
 uipath_langchain/middlewares.py,sha256=6ljfbtWekrYc5G9KWDLSaViJ1DVIaNM-4qeB1BfHywE,731
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
-uipath_langchain/_cli/cli_dev.py,sha256=3e9RldNGirIk9184NdLK6kDuGeeqZjekTxbSZRtXjBE,1505
-uipath_langchain/_cli/cli_eval.py,sha256=rsa13I3bPxAsc0Gf5KFyvf5AMT8WdhgY7kT7ZAyXrJM,3572
+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_new.py,sha256=KKLxCzz7cDQ__rRr_a496IHWlSQXhmrBNgmKHnXAnTY,2336
-uipath_langchain/_cli/cli_run.py,sha256=hRcoXJgOIFceCswzTfZKyzqVee3j-oSh-13EfuQmmE8,2614
-uipath_langchain/_cli/_runtime/_context.py,sha256=yyzYJDmk2fkH4T5gm4cLGRyXtjLESrpzHBT9euqluTA,817
-uipath_langchain/_cli/_runtime/_conversation.py,sha256=S1KTx_q-La7ikPRT3nBcIp8t-J9CF0QB0DCduQIIB28,11149
+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/_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=cVt0TlsEBmKv6EcFTtCOT9ITsguzLDqFGMdhPOiBPRc,14318
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=HTLT9fDSZuAS1e0cAeFhBWxG1iJC0ISjGYgSOuCnfRM,9801
 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
@@ -20,12 +21,11 @@ uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZ
 uipath_langchain/_tracing/_oteladapter.py,sha256=PD0gsC39ZNvrm0gsfnt1ti6DEy56sBA9sIoxaAbHFFM,8887
 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=ddKFs_0mjoFCmvPTiOTPJh1IIqYUo5CUka-B7zAZphE,19695
+uipath_langchain/_utils/_request_mixin.py,sha256=sYvvn3_fUJxtF893xFpVGwJx2YoEbw1m5gp_U_lWjR8,20092
 uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
-uipath_langchain/builder/agent_config.py,sha256=b9WODKPjvufj41Ow_dQn5CnaTAjAZyQoNhuAl8vfiso,5809
 uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
-uipath_langchain/chat/models.py,sha256=m5PRAFXzUamt6-1K9uSlWUvZg_NfVyYHkgoQDJ-1rGs,10527
+uipath_langchain/chat/models.py,sha256=PifcbDURqfttqVYKSnzdbOdbSiLiwHfQ6lWgVAtoLj8,16407
 uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
 uipath_langchain/embeddings/embeddings.py,sha256=45gKyb6HVKigwE-0CXeZcAk33c0mteaEdPGa8hviqcw,4339
 uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
@@ -34,8 +34,8 @@ uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 uipath_langchain/tools/preconfigured.py,sha256=xCP0hiQuFKIv45PTvMsoWlwsxJDs7goyZujKflYBngY,7476
 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.138.dist-info/METADATA,sha256=aM1VS1o-g7Fc7KBltSpLGugqNLi3b3qAbzHE2cy_xs8,4275
-uipath_langchain-0.0.138.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.138.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.138.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.138.dist-info/RECORD,,
+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/builder/agent_config.py

@@ -1,191 +0,0 @@
-from enum import Enum
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class AgentMessageRole(str, Enum):
-    """Enum for message roles"""
-
-    SYSTEM = "System"
-    USER = "User"
-
-
-class AgentMessage(BaseModel):
-    """Message model for agent conversations"""
-
-    role: AgentMessageRole
-    content: str
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentSettings(BaseModel):
-    """Settings for agent configuration"""
-
-    engine: str = Field(..., description="Engine type, e.g., 'basic-v1'")
-    model: str = Field(..., description="LLM model identifier")
-    max_tokens: int = Field(
-        ..., alias="maxTokens", description="Maximum number of tokens"
-    )
-    temperature: float = Field(..., description="Temperature for response generation")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentResourceType(str, Enum):
-    """Enum for resource types"""
-
-    TOOL = "tool"
-    CONTEXT = "context"
-    ESCALATION = "escalation"
-
-
-class AgentBaseResourceConfig(BaseModel):
-    """Base resource model with common properties"""
-
-    name: str
-    description: str
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentUnknownResourceConfig(AgentBaseResourceConfig):
-    """Fallback for unknown or future resource types"""
-
-    resource_type: str = Field(alias="$resourceType")
-
-    model_config = ConfigDict(extra="allow")
-
-
-class AgentToolSettings(BaseModel):
-    """Settings for tool configuration"""
-
-    max_attempts: int = Field(0, alias="maxAttempts")
-    retry_delay: int = Field(0, alias="retryDelay")
-    timeout: int = Field(0)
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentToolProperties(BaseModel):
-    """Properties specific to tool configuration"""
-
-    folder_path: Optional[str] = Field(None, alias="folderPath")
-    process_name: Optional[str] = Field(None, alias="processName")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentToolResourceConfig(AgentBaseResourceConfig):
-    """Tool resource with tool-specific properties"""
-
-    resource_type: Literal[AgentResourceType.TOOL] = Field(alias="$resourceType")
-    type: str = Field(..., description="Tool type")
-    arguments: Dict[str, Any] = Field(
-        default_factory=dict, description="Tool arguments"
-    )
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="Input schema for the tool"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="Output schema for the tool"
-    )
-    properties: AgentToolProperties = Field(..., description="Tool-specific properties")
-    settings: AgentToolSettings = Field(
-        default_factory=AgentToolSettings, description="Tool settings"
-    )
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentContextSettings(BaseModel):
-    """Settings for context configuration"""
-
-    result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured"] = Field(alias="retrievalMode")
-    threshold: float = Field(default=0)
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentContextResourceConfig(AgentBaseResourceConfig):
-    """Context resource with context-specific properties"""
-
-    resource_type: Literal[AgentResourceType.CONTEXT] = Field(alias="$resourceType")
-    folder_path: str = Field(alias="folderPath")
-    index_name: str = Field(alias="indexName")
-    settings: AgentContextSettings = Field(..., description="Context settings")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentEscalationResourceConfig(AgentBaseResourceConfig):
-    """Escalation resource with escalation-specific properties"""
-
-    resource_type: Literal[AgentResourceType.ESCALATION] = Field(alias="$resourceType")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-# Discriminated union for known types
-KnownAgentResourceConfig = Annotated[
-    Union[
-        AgentToolResourceConfig,
-        AgentContextResourceConfig,
-        AgentEscalationResourceConfig,
-    ],
-    Field(discriminator="resource_type"),
-]
-
-# Final union includes unknowns as a catch-all
-AgentResourceConfig = Union[
-    KnownAgentResourceConfig,
-    AgentUnknownResourceConfig,
-]
-
-
-class AgentConfig(BaseModel):
-    """Main agent model"""
-
-    id: str = Field(..., description="Agent id or project name")
-    name: str = Field(..., description="Agent name or project name")
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="JSON schema for input arguments"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="JSON schema for output arguments"
-    )
-    messages: List[AgentMessage] = Field(
-        ..., description="List of system and user messages"
-    )
-    features: List[Any] = Field(
-        default_factory=list, description="Currently empty feature list"
-    )
-    version: str = Field("1.0.0", description="Agent version")
-    settings: AgentSettings = Field(..., description="Agent settings configuration")
-    resources: List[AgentResourceConfig] = Field(
-        ..., description="List of tools, context, and escalation resources"
-    )
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )