uipath-langchain 0.0.137__tar.gz → 0.0.139__tar.gz

{uipath_langchain-0.0.137 → uipath_langchain-0.0.139}/PKG-INFO

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

{uipath_langchain-0.0.137 → uipath_langchain-0.0.139}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.137"
+version = "0.0.139"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.65, <2.2.0",
+    "uipath>=2.1.76, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",

{uipath_langchain-0.0.137 → uipath_langchain-0.0.139}/src/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-0.0.137 → uipath_langchain-0.0.139}/src/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-0.0.139/src/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-0.0.139/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -0,0 +1,255 @@
+import logging
+import os
+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 uipath._cli._runtime._contracts import (
+    UiPathBaseRuntime,
+    UiPathErrorCategory,
+    UiPathRuntimeResult,
+)
+
+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
+
+logger = logging.getLogger(__name__)
+
+
+class LangGraphRuntime(UiPathBaseRuntime):
+    """
+    A runtime class implementing the async context manager protocol.
+    This allows using the class with 'async with' statements.
+    """
+
+    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]:
+        """
+        Execute the graph with the provided input and configuration.
+
+        Returns:
+            Dictionary with execution results
+
+        Raises:
+            LangGraphRuntimeError: If execution fails
+        """
+
+        graph = await self.graph_resolver()
+        if not graph:
+            return None
+
+        try:
+            async with AsyncSqliteSaver.from_conn_string(
+                self.state_file_path
+            ) as memory:
+                self.context.memory = memory
+
+                # Compile the graph with the checkpointer
+                compiled_graph = graph.compile(checkpointer=self.context.memory)
+
+                # Process input, handling resume if needed
+                input_processor = LangGraphInputProcessor(context=self.context)
+
+                processed_input = await input_processor.process()
+
+                callbacks: List[BaseCallbackHandler] = []
+
+                graph_config: RunnableConfig = {
+                    "configurable": {
+                        "thread_id": (
+                            self.context.execution_id
+                            or self.context.job_id
+                            or "default"
+                        )
+                    },
+                    "callbacks": callbacks,
+                }
+
+                recursion_limit = os.environ.get("LANGCHAIN_RECURSION_LIMIT", None)
+                max_concurrency = os.environ.get("LANGCHAIN_MAX_CONCURRENCY", None)
+
+                if recursion_limit is not None:
+                    graph_config["recursion_limit"] = int(recursion_limit)
+                if max_concurrency is not None:
+                    graph_config["max_concurrency"] = int(max_concurrency)
+
+                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", "updates"],
+                        subgraphs=True,
+                    ):
+                        _, 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 compiled_graph.ainvoke(
+                        processed_input, graph_config
+                    )
+
+                # Get the state if available
+                try:
+                    self.context.state = await compiled_graph.aget_state(graph_config)
+                except Exception:
+                    pass
+
+                output_processor = await LangGraphOutputProcessor.create(self.context)
+
+                self.context.result = await output_processor.process()
+
+                return self.context.result
+
+        except Exception as e:
+            if isinstance(e, LangGraphRuntimeError):
+                raise
+
+            detail = f"Error: {str(e)}"
+
+            if isinstance(e, GraphRecursionError):
+                raise LangGraphRuntimeError(
+                    "GRAPH_RECURSION_ERROR",
+                    "Graph recursion limit exceeded",
+                    detail,
+                    UiPathErrorCategory.USER,
+                ) from e
+
+            if isinstance(e, InvalidUpdateError):
+                raise LangGraphRuntimeError(
+                    "GRAPH_INVALID_UPDATE",
+                    str(e),
+                    detail,
+                    UiPathErrorCategory.USER,
+                ) from e
+
+            if isinstance(e, EmptyInputError):
+                raise LangGraphRuntimeError(
+                    "GRAPH_EMPTY_INPUT",
+                    "The input data is empty",
+                    detail,
+                    UiPathErrorCategory.USER,
+                ) from e
+
+            raise LangGraphRuntimeError(
+                "EXECUTION_ERROR",
+                "Graph execution failed",
+                detail,
+                UiPathErrorCategory.USER,
+            ) from e
+        finally:
+            pass
+
+    async def validate(self) -> None:
+        pass
+
+    async def cleanup(self):
+        pass
+
+    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.
+
+        Args:
+            final_chunk: The final chunk from graph.astream()
+            graph: The LangGraph instance
+
+        Returns:
+            The extracted result according to the graph's output_channels configuration
+        """
+        # Unwrap from subgraph tuple format if needed
+        if isinstance(final_chunk, tuple) and len(final_chunk) == 2:
+            final_chunk = final_chunk[
+                1
+            ]  # 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):
+            return final_chunk
+
+        # Case 1: Single output channel as string
+        if isinstance(output_channels, str):
+            if output_channels in final_chunk:
+                return final_chunk[output_channels]
+            else:
+                return final_chunk
+
+        # Case 2: Multiple output channels as sequence
+        elif hasattr(output_channels, "__iter__") and not isinstance(
+            output_channels, str
+        ):
+            # Check which channels are present
+            available_channels = [ch for ch in output_channels if ch in final_chunk]
+
+            # if no available channels, output may contain the last_node name as key
+            unwrapped_final_chunk = {}
+            if not available_channels:
+                if len(final_chunk) == 1 and isinstance(
+                    unwrapped_final_chunk := next(iter(final_chunk.values())), dict
+                ):
+                    available_channels = [
+                        ch for ch in output_channels if ch in unwrapped_final_chunk
+                    ]
+
+            if available_channels:
+                # Create a dict with the available channels
+                return {
+                    channel: final_chunk.get(channel, None)
+                    or unwrapped_final_chunk[channel]
+                    for channel in available_channels
+                }
+
+        # Fallback for any other case
+        return final_chunk
+
+
+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-0.0.137 → uipath_langchain-0.0.139}/src/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-0.0.137 → uipath_langchain-0.0.139}/src/uipath_langchain/_cli/cli_eval.py

@@ -1,11 +1,11 @@
 import asyncio
-import uuid
 from typing import List, Optional
 
 from openinference.instrumentation.langchain import (
     LangChainInstrumentor,
     get_current_span,
 )
+from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
 from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
 from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
 from uipath._cli._runtime._contracts import (
@@ -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,
@@ -39,36 +39,40 @@ def langgraph_eval_middleware(
 
         event_bus = EventBus()
 
-        if not kwargs.get("no_report", False):
+        if kwargs.get("register_progress_reporter", False):
             progress_reporter = StudioWebProgressReporter(
                 spans_exporter=LangChainExporter()
             )
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
+        console_reporter = ConsoleProgressReporter()
+        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
 
         runtime_entrypoint = entrypoint or auto_discover_entrypoint()
 
         eval_context = UiPathEvalContext.with_defaults(
-            entrypoint=runtime_entrypoint, execution_id=str(uuid.uuid4()), **kwargs
+            entrypoint=runtime_entrypoint, **kwargs
         )
         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-0.0.137 → uipath_langchain-0.0.139}/src/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-0.0.137 → uipath_langchain-0.0.139}/src/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", "")