uipath-langchain 0.0.138__tar.gz → 0.0.140__tar.gz

{uipath_langchain-0.0.138 → uipath_langchain-0.0.140}/.github/workflows/integration_tests.yml

@@ -19,16 +19,16 @@ jobs:
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
-    
+
     - name: Discover testcases
       id: discover
       run: |
         # Find all testcase folders (excluding common folders like README, etc.)
         testcase_dirs=$(find testcases -maxdepth 1 -type d -name "*-*" | sed 's|testcases/||' | sort)
-        
+
         echo "Found testcase directories:"
         echo "$testcase_dirs"
-        
+
         # Convert to JSON array for matrix
         testcases_json=$(echo "$testcase_dirs" | jq -R -s -c 'split("\n")[:-1]')
         echo "testcases=$testcases_json" >> $GITHUB_OUTPUT
@@ -36,46 +36,39 @@ jobs:
   integration-tests:
     needs: [discover-testcases]
     runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/astral-sh/uv:python3.12-bookworm
+      env:
+        UIPATH_JOB_KEY: "3a03d5cb-fa21-4021-894d-a8e2eda0afe0"
     strategy:
       fail-fast: false
       matrix:
         testcase: ${{ fromJson(needs.discover-testcases.outputs.testcases) }}
-        environment: [alpha, cloud]
+        environment: [alpha, staging] # temporary disable [cloud]
         use_azure_chat: [true, false]
-    
+
     name: "${{ matrix.testcase }} / ${{ matrix.environment }} / ${{ matrix.use_azure_chat && 'UiPathAzureChatOpenAI' || 'UiPathChat' }}"
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
 
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-
-    - name: Build Docker image
-      run: |
-        echo "Building Docker image for ${{ matrix.testcase }} at $(date)"
-        docker build -f testcases/Dockerfile \
-          -t uipath-langchain-testbase:latest \
-          .
-        echo "Docker image built at $(date)"
+    - name: Install Dependencies
+      run: uv sync
 
     - name: Run testcase
       env:
-        CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || secrets.CLOUD_TEST_CLIENT_ID }}
-        CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || secrets.CLOUD_TEST_CLIENT_SECRET }}
-        BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || secrets.CLOUD_BASE_URL }}
+        CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_ID || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_ID }}
+        CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_SECRET || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_SECRET }}
+        BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || matrix.environment == 'staging' && secrets.STAGING_BASE_URL || matrix.environment == 'cloud' && secrets.CLOUD_BASE_URL }}
         USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}
+      working-directory: testcases/${{ matrix.testcase }}
       run: |
         echo "Running testcase: ${{ matrix.testcase }}"
         echo "Environment: ${{ matrix.environment }}"
         echo "LLM: ${{ matrix.use_azure_chat && 'UiPathAzureChatOpenAI' || 'UiPathChat' }}"
         echo "USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}"
-        
-        docker run --rm \
-          -e CLIENT_ID="$CLIENT_ID" \
-          -e CLIENT_SECRET="$CLIENT_SECRET" \
-          -e BASE_URL="$BASE_URL" \
-          -e USE_AZURE_CHAT="$USE_AZURE_CHAT" \
-          uipath-langchain-testbase:latest \
-          bash /app/testcases/${{ matrix.testcase }}/run.sh
+
+        # Execute the testcase run script directly
+        bash run.sh
+        bash ../common/validate_output.sh

{uipath_langchain-0.0.138 → uipath_langchain-0.0.140}/.gitignore

@@ -165,7 +165,7 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/
 
 # Ruff stuff:
 .ruff_cache/
@@ -178,4 +178,4 @@ cython_debug/
 **/.uipath
 **/**.nupkg
 **/__uipath/
-**/.langgraph_api
+**/.langgraph_api

{uipath_langchain-0.0.138 → uipath_langchain-0.0.140}/PKG-INFO

@@ -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 → uipath_langchain-0.0.140}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.138"
+version = "0.0.140"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath_langchain-0.0.138 → uipath_langchain-0.0.140}/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.138 → uipath_langchain-0.0.140}/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.140/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.140/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.138 → uipath_langchain-0.0.140}/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.138 → uipath_langchain-0.0.140}/src/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-0.0.138 → uipath_langchain-0.0.140}/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,
             )