fix: isolate concurrent file tool calls

Author: kriptoburak

src/backend/base/langflow/initial_setup/starter_projects/Financial Report Parser.json

@@ -1,6 +1,9 @@
+import asyncio
 import json
 import subprocess
 import tempfile
+import threading
+from concurrent.futures import ThreadPoolExecutor
 from unittest.mock import MagicMock, patch
 
 import pandas as pd
@@ -644,6 +647,38 @@ async def test_tool_execution_reads_supplied_file_path(self, component_class, tm
         assert result == "Content from the tool path."
         assert component.file_path_str == previous_file_path
 
+    @pytest.mark.asyncio
+    async def test_concurrent_tool_calls_isolate_file_paths(self, component_class, tmp_path):
+        """Keep concurrent tool paths isolated on independent component copies."""
+        component = component_class()
+        component._attributes["path"] = []
+        tools = await component._get_tools()
+        tool = tools[0]
+        first_path = str(tmp_path / "first.txt")
+        second_path = str(tmp_path / "second.txt")
+        entered_loader = threading.Barrier(2, timeout=5)
+        captured_path = threading.Barrier(2, timeout=5)
+
+        def load_files_message(invocation):
+            entered_loader.wait()
+            result = Data(text=invocation.file_path_str)
+            captured_path.wait()
+            return result
+
+        def invoke_tool(file_path: str) -> str:
+            return asyncio.run(tool.coroutine(file_path_str=file_path))
+
+        with (
+            patch.object(component_class, "load_files_message", load_files_message),
+            ThreadPoolExecutor(max_workers=2) as executor,
+        ):
+            first = executor.submit(invoke_tool, first_path)
+            second = executor.submit(invoke_tool, second_path)
+            results = {first.result(timeout=10), second.result(timeout=10)}
+
+        assert results == {first_path, second_path}
+        assert component.file_path_str == ""
+
     @pytest.mark.asyncio
     async def test_advanced_tool_execution_restores_markdown_mode(self, component_class):
         """Restore the configured output mode after an advanced tool call."""
@@ -672,8 +707,7 @@ async def test_tool_execution_confines_supplied_file_path_when_restricted(self,
         settings_service.settings.restrict_local_file_access = True
         settings_service.settings.config_dir = config_dir
         settings_service.settings.database_url = ""
-        component = component_class()
-        component._user_id = "user-1"
+        component = component_class(_user_id="user-1")
         previous_file_path = component.file_path_str
 
         tools = await component._get_tools()

src/backend/base/langflow/initial_setup/starter_projects/Hybrid Search RAG.json

@@ -338,29 +338,29 @@ class ReadFilesSchema(BaseModel):
 
         async def read_files_tool(file_path_str: str | None = None) -> str:
             """Read a supplied path or the files uploaded through the UI."""
-            previous_file_path = getattr(self, "file_path_str", None)
-            previous_markdown = getattr(self, "markdown", False)
-            self.file_path_str = file_path_str
+            invocation = deepcopy(self)
+            invocation.advanced_mode = getattr(self, "advanced_mode", False)
+            vertex = self.get_vertex()
+            if vertex is not None:
+                invocation.set_vertex(vertex)
+            invocation.file_path_str = file_path_str
             try:
-                if getattr(self, "advanced_mode", False):
+                if getattr(invocation, "advanced_mode", False):
                     # In advanced mode, use the markdown output path so that the
                     # tool shares the same Docling processing as the advanced
                     # outputs rather than triggering a second subprocess via
                     # load_files_message.
-                    self.markdown = True
-                    result = self.load_files_markdown()
+                    invocation.markdown = True
+                    result = invocation.load_files_markdown()
                 else:
-                    result = self.load_files_message()
+                    result = invocation.load_files_message()
                 if hasattr(result, "get_text"):
                     return result.get_text()
                 if hasattr(result, "text"):
                     return result.text
                 return str(result)
             except (FileNotFoundError, ValueError, OSError, RuntimeError) as e:
                 return f"Error reading files: {e}"
-            finally:
-                self.file_path_str = previous_file_path
-                self.markdown = previous_markdown
 
         description = self.get_tool_description()