alita-sdk 0.3.486__py3-none-any.whl → 0.3.497__py3-none-any.whl

alita_sdk/runtime/toolkits/mcp.py

@@ -17,7 +17,7 @@ from ..tools.mcp_remote_tool import McpRemoteTool
 from ..tools.mcp_inspect_tool import McpInspectTool
 from ...tools.utils import TOOLKIT_SPLITTER, clean_string
 from ..models.mcp_models import McpConnectionConfig
-from ..utils.mcp_sse_client import McpSseClient
+from ..utils.mcp_client import McpClient
 from ..utils.mcp_oauth import (
     McpAuthorizationRequired,
     canonical_resource,
@@ -426,11 +426,6 @@ class McpToolkit(BaseToolkit):
         except Exception as e:
             logger.error(f"Direct discovery failed for MCP toolkit '{toolkit_name}': {e}", exc_info=True)
             logger.error(f"Discovery error details - URL: {connection_config.url}, Timeout: {timeout}s")
-
-            # Check if the exception wraps McpAuthorizationRequired (can happen with asyncio)
-            if hasattr(e, '__cause__') and isinstance(e.__cause__, McpAuthorizationRequired):
-                logger.info(f"Found wrapped McpAuthorizationRequired, re-raising")
-                raise e.__cause__
             
             # For new MCP toolkits (no client), don't silently return empty - surface the error
             # This helps users understand why tool discovery failed
@@ -464,37 +459,36 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Discover tools and prompts from MCP server using SSE client.
-        Returns list of tool/prompt dictionaries with name, description, and inputSchema.
-        Prompts are converted to tools that can be invoked.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id) - session_id may be server-provided
         """
-        session_id = connection_config.session_id
+        initial_session_id = connection_config.session_id
         
-        if not session_id:
-            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - server may require it")
-            logger.warning(f"[MCP Session] Frontend should generate a UUID and include it with mcp_tokens")
+        if not initial_session_id:
+            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - will generate one")
         
         # Run async discovery in sync context
         try:
-            all_tools = asyncio.run(
+            all_tools, server_session_id = asyncio.run(
                 cls._discover_tools_async(
                     toolkit_name=toolkit_name,
                     connection_config=connection_config,
                     timeout=timeout
                 )
             )
-            return all_tools, session_id
+            # Return tools and the session_id (server-provided or generated)
+            logger.info(f"[MCP Session] Final session_id for '{toolkit_name}': {server_session_id}")
+            return all_tools, server_session_id
         except McpAuthorizationRequired:
             # Re-raise auth required exceptions directly
             logger.info(f"[MCP SSE] Authorization required for '{toolkit_name}'")
             raise
         except Exception as e:
             logger.error(f"[MCP SSE] Discovery failed for '{toolkit_name}': {e}")
-            # Check if the exception wraps McpAuthorizationRequired
-            if hasattr(e, '__cause__') and isinstance(e.__cause__, McpAuthorizationRequired):
-                raise e.__cause__
             raise
     
     @classmethod
@@ -503,9 +497,12 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Async implementation of tool discovery using SSE client.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id)
         """
         all_tools = []
         session_id = connection_config.session_id
@@ -517,65 +514,74 @@ class McpToolkit(BaseToolkit):
             session_id = str(uuid.uuid4())
             logger.info(f"[MCP SSE] Generated temporary session_id for OAuth: {session_id}")
         
-        logger.info(f"[MCP SSE] Discovering from {connection_config.url} with session {session_id}")
+        logger.info(f"[MCP] Discovering from {connection_config.url} with session {session_id}")
         
         # Prepare headers
         headers = {}
         if connection_config.headers:
             headers.update(connection_config.headers)
         
-        # Create SSE client
-        client = McpSseClient(
+        # Create unified MCP client (auto-detects SSE vs Streamable HTTP)
+        client = McpClient(
             url=connection_config.url,
             session_id=session_id,
             headers=headers,
             timeout=timeout
         )
         
-        # Initialize MCP session
-        await client.initialize()
-        logger.info(f"[MCP SSE] Session initialized for '{toolkit_name}'")
-        
-        # Discover tools
-        tools = await client.list_tools()
-        all_tools.extend(tools)
-        logger.info(f"[MCP SSE] Discovered {len(tools)} tools from '{toolkit_name}'")
-        
-        # Discover prompts
-        try:
-            prompts = await client.list_prompts()
-            # Convert prompts to tool format
-            for prompt in prompts:
-                prompt_tool = {
-                    "name": f"prompt_{prompt.get('name', 'unnamed')}",
-                    "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "arguments": {
-                                "type": "object",
-                                "description": "Arguments for the prompt template",
-                                "properties": {
-                                    arg.get("name"): {
-                                        "type": "string",
-                                        "description": arg.get("description", ""),
-                                        "required": arg.get("required", False)
+        server_session_id = None
+        async with client:
+            # Initialize MCP session
+            await client.initialize()
+            logger.info(f"[MCP] Session initialized for '{toolkit_name}' (transport={client.detected_transport})")
+            
+            # Capture server-provided session_id (from mcp-session-id header)
+            server_session_id = client.server_session_id
+            if server_session_id:
+                logger.info(f"[MCP] Server provided session_id: {server_session_id}")
+            
+            # Discover tools
+            tools = await client.list_tools()
+            all_tools.extend(tools)
+            logger.info(f"[MCP] Discovered {len(tools)} tools from '{toolkit_name}'")
+            
+            # Discover prompts
+            try:
+                prompts = await client.list_prompts()
+                # Convert prompts to tool format
+                for prompt in prompts:
+                    prompt_tool = {
+                        "name": f"prompt_{prompt.get('name', 'unnamed')}",
+                        "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "arguments": {
+                                    "type": "object",
+                                    "description": "Arguments for the prompt template",
+                                    "properties": {
+                                        arg.get("name"): {
+                                            "type": "string",
+                                            "description": arg.get("description", ""),
+                                            "required": arg.get("required", False)
+                                        }
+                                        for arg in prompt.get("arguments", [])
                                     }
-                                    for arg in prompt.get("arguments", [])
                                 }
                             }
-                        }
-                    },
-                    "_mcp_type": "prompt",
-                    "_mcp_prompt_name": prompt.get('name')
-                }
-                all_tools.append(prompt_tool)
-            logger.info(f"[MCP SSE] Discovered {len(prompts)} prompts from '{toolkit_name}'")
-        except Exception as e:
-            logger.warning(f"[MCP SSE] Failed to discover prompts: {e}")
+                        },
+                        "_mcp_type": "prompt",
+                        "_mcp_prompt_name": prompt.get('name')
+                    }
+                    all_tools.append(prompt_tool)
+                logger.info(f"[MCP] Discovered {len(prompts)} prompts from '{toolkit_name}'")
+            except Exception as e:
+                logger.warning(f"[MCP] Failed to discover prompts: {e}")
         
-        logger.info(f"[MCP SSE] Total discovered {len(all_tools)} items from '{toolkit_name}'")
-        return all_tools
+        logger.info(f"[MCP] Total discovered {len(all_tools)} items from '{toolkit_name}'")
+        # Return tools and server-provided session_id (use server's if available, else the one we sent)
+        final_session_id = server_session_id or session_id
+        return all_tools, final_session_id
 
     @classmethod
     def _create_tool_from_dict(

alita_sdk/runtime/toolkits/planning.py

@@ -94,7 +94,9 @@ class PlanningToolkit(BaseToolkit):
                         "label": "Planning",
                         "description": "Tools for managing multi-step execution plans with progress tracking. Uses PostgreSQL when configured, filesystem otherwise.",
                         "icon_url": None,
-                        "max_length": PlanningToolkit._toolkit_max_length
+                        "max_length": PlanningToolkit._toolkit_max_length,
+                        "categories": ["planning", "internal_tool"],
+                        "extra_categories": ["task management", "todo", "progress tracking"]
                     }
                 }
             )

alita_sdk/runtime/toolkits/tools.py

@@ -94,6 +94,11 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     else:
                         logger.warning("Image generation internal tool requested "
                                        "but no image generation model configured")
+                elif tool['name'] == 'planner':
+                    tools += PlanningToolkit.get_toolkit(
+                        pgvector_configuration=tool.get('settings', {}).get('pgvector_configuration'),
+                        conversation_id=conversation_id,
+                    ).get_tools()
             elif tool['type'] == 'artifact':
                 toolkit_tools = ArtifactToolkit.get_toolkit(
                     client=alita_client,
@@ -118,22 +123,42 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     **tool['settings']).get_tools())
             elif tool['type'] == 'planning':
                 # Planning toolkit for multi-step task tracking
-                # Try to fetch pgvector_project_connstr from project secrets
-                pgvector_connstr = None
-                if alita_client:
-                    try:
-                        pgvector_connstr = alita_client.unsecret('pgvector_project_connstr')
-                        if pgvector_connstr:
-                            logger.info("Using pgvector_project_connstr for planning toolkit")
-                    except Exception as e:
-                        logger.debug(f"pgvector_project_connstr not available: {e}")
+                settings = tool.get('settings', {})
+                
+                # Check if local mode is enabled (uses filesystem storage, ignores pgvector)
+                use_local = settings.get('local', False)
+                
+                if use_local:
+                    # Local mode - use filesystem storage
+                    logger.info("Planning toolkit using local filesystem storage (local=true)")
+                    pgvector_config = {}
+                else:
+                    # Check if explicit connection_string is provided in pgvector_configuration
+                    explicit_pgvector_config = settings.get('pgvector_configuration', {})
+                    explicit_connstr = explicit_pgvector_config.get('connection_string') if explicit_pgvector_config else None
+                    
+                    if explicit_connstr:
+                        # Use explicitly provided connection string (overrides project secrets)
+                        logger.info("Using explicit connection_string for planning toolkit")
+                        pgvector_config = explicit_pgvector_config
+                    else:
+                        # Try to fetch pgvector_project_connstr from project secrets
+                        pgvector_connstr = None
+                        if alita_client:
+                            try:
+                                pgvector_connstr = alita_client.unsecret('pgvector_project_connstr')
+                                if pgvector_connstr:
+                                    logger.info("Using pgvector_project_connstr for planning toolkit")
+                            except Exception as e:
+                                logger.debug(f"pgvector_project_connstr not available: {e}")
+                        
+                        pgvector_config = {'connection_string': pgvector_connstr} if pgvector_connstr else {}
                 
-                pgvector_config = {'connection_string': pgvector_connstr} if pgvector_connstr else {}
                 tools.extend(PlanningToolkit.get_toolkit(
                     toolkit_name=tool.get('toolkit_name', ''),
-                    selected_tools=tool['settings'].get('selected_tools', []),
+                    selected_tools=settings.get('selected_tools', []),
                     pgvector_configuration=pgvector_config,
-                    conversation_id=conversation_id or tool['settings'].get('conversation_id'),
+                    conversation_id=conversation_id or settings.get('conversation_id'),
                 ).get_tools())
             elif tool['type'] == 'mcp':
                 # remote mcp tool initialization with token injection
@@ -183,12 +208,6 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
             # Re-raise auth required exceptions directly
             raise
         except Exception as e:
-            # Check for wrapped McpAuthorizationRequired
-            if hasattr(e, '__cause__') and isinstance(e.__cause__, McpAuthorizationRequired):
-                raise e.__cause__
-            # Check exception class name as fallback
-            if e.__class__.__name__ == 'McpAuthorizationRequired':
-                raise
             logger.error(f"Error initializing toolkit for tool '{tool.get('name', 'unknown')}': {e}", exc_info=True)
             if debug_mode:
                 logger.info("Skipping tool initialization error due to debug mode.")

alita_sdk/runtime/tools/artifact.py

@@ -34,28 +34,57 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return self.artifact.list(bucket_name, return_as_string)
 
     def create_file(self, filename: str, filedata: str, bucket_name = None):
-        if filename.endswith(".xlsx"):
+        # Sanitize filename to prevent regex errors during indexing
+        sanitized_filename, was_modified = self._sanitize_filename(filename)
+        if was_modified:
+            logging.warning(f"Filename sanitized: '{filename}' -> '{sanitized_filename}'")
+        
+        if sanitized_filename.endswith(".xlsx"):
             data = json.loads(filedata)
             filedata = self.create_xlsx_filedata(data)
 
-        result = self.artifact.create(filename, filedata, bucket_name)
+        result = self.artifact.create(sanitized_filename, filedata, bucket_name)
         
         # Dispatch custom event for file creation
-        self._log_tool_event(
-            tool_name="file_modified",
-            message="""
-            {
-                "message": f"File '{filename}' created successfully",
-                "filename": filename,
-                "tool_name": "createFile",
-                "toolkit": "artifact",
-                "operation_type": "create",
-                "meta": {
-                    "bucket": bucket_name or self.bucket
-                }
-            }""")
+        dispatch_custom_event("file_modified", {
+            "message": f"File '{filename}' created successfully",
+            "filename": filename,
+            "tool_name": "createFile",
+            "toolkit": "artifact",
+            "operation_type": "create",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
 
         return result
+    
+    @staticmethod
+    def _sanitize_filename(filename: str) -> tuple:
+        """Sanitize filename for safe storage and regex pattern matching."""
+        from pathlib import Path
+        
+        if not filename or not filename.strip():
+            return "unnamed_file", True
+        
+        original = filename
+        path_obj = Path(filename)
+        name = path_obj.stem
+        extension = path_obj.suffix
+        
+        # Whitelist: alphanumeric, underscore, hyphen, space, Unicode letters/digits
+        sanitized_name = re.sub(r'[^\w\s-]', '', name, flags=re.UNICODE)
+        sanitized_name = re.sub(r'[-\s]+', '-', sanitized_name)
+        sanitized_name = sanitized_name.strip('-').strip()
+        
+        if not sanitized_name:
+            sanitized_name = "file"
+        
+        if extension:
+            extension = re.sub(r'[^\w.-]', '', extension, flags=re.UNICODE)
+        
+        sanitized = sanitized_name + extension
+        return sanitized, (sanitized != original)
 
     def create_xlsx_filedata(self, data: dict[str, list[list]]) -> bytes:
         try:
@@ -173,13 +202,13 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
             file_name = file['name']
 
             # Check if file should be skipped based on skip_extensions
-            if any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                    for pattern in skip_extensions):
                 continue
 
             # Check if file should be included based on include_extensions
             # If include_extensions is empty, process all files (that weren't skipped)
-            if include_extensions and not (any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if include_extensions and not (any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                                                for pattern in include_extensions)):
                 continue
 

alita_sdk/runtime/tools/function.py

@@ -107,7 +107,8 @@ class FunctionTool(BaseTool):
 
         # special handler for PyodideSandboxTool
         if self._is_pyodide_tool():
-            code = func_args['code']
+            # replace new lines in strings in code block
+            code = func_args['code'].replace('\\n', '\\\\n')
             func_args['code'] = f"{self._prepare_pyodide_input(state)}\n{code}"
         try:
             tool_result = self.tool.invoke(func_args, config, **kwargs)

alita_sdk/runtime/tools/llm.py

@@ -34,6 +34,7 @@ class LLMNode(BaseTool):
     available_tools: Optional[List[BaseTool]] = Field(default=None, description='Available tools for binding')
     tool_names: Optional[List[str]] = Field(default=None, description='Specific tool names to filter')
     steps_limit: Optional[int] = Field(default=25, description='Maximum steps for tool execution')
+    tool_execution_timeout: Optional[int] = Field(default=900, description='Timeout (seconds) for tool execution. Default is 15 minutes.')
 
     def get_filtered_tools(self) -> List[BaseTool]:
         """
@@ -129,7 +130,9 @@ class LLMNode(BaseTool):
         # or standalone LLM node for chat (with messages only)
         if 'system' in func_args.keys():
             # Flow for LLM node with prompt/task from pipeline
-            if not func_args.get('system') or not func_args.get('task'):
+            if func_args.get('system') is None or func_args.get('task') is None:
+                raise ToolException(f"LLMNode requires 'system' and 'task' parameters in input mapping. "
+                                    f"Actual params: {func_args}")
                 raise ToolException(f"LLMNode requires 'system' and 'task' parameters in input mapping. "
                                     f"Actual params: {func_args}")
             # cast to str in case user passes variable different from str
@@ -243,40 +246,146 @@ class LLMNode(BaseTool):
         
         For MCP tools with persistent sessions, we reuse the same event loop
         that was used to create the MCP client and sessions (set by CLI).
+
+        When called from within a running event loop (e.g., nested LLM nodes),
+        we need to handle this carefully to avoid "event loop already running" errors.
+
+        This method handles three scenarios:
+        1. Called from async context (event loop running) - creates new thread with new loop
+        2. Called from sync context with persistent loop - reuses persistent loop
+        3. Called from sync context without loop - creates new persistent loop
         """
+        import threading
+
+        # Check if there's a running loop
         try:
-            loop = asyncio.get_running_loop()
-            # Already in async context - run in thread with new loop
-            import threading
-            
+            running_loop = asyncio.get_running_loop()
+            loop_is_running = True
+            logger.debug(f"Detected running event loop (id: {id(running_loop)}), executing tool calls in separate thread")
+        except RuntimeError:
+            loop_is_running = False
+
+        # Scenario 1: Loop is currently running - MUST use thread
+        if loop_is_running:
             result_container = []
-            
+            exception_container = []
+
+            # Try to capture Streamlit context from current thread for propagation
+            streamlit_ctx = None
+            try:
+                from streamlit.runtime.scriptrunner import get_script_run_ctx, add_script_run_ctx
+                streamlit_ctx = get_script_run_ctx()
+                if streamlit_ctx:
+                    logger.debug("Captured Streamlit context for propagation to worker thread")
+            except (ImportError, Exception) as e:
+                logger.debug(f"Streamlit context not available or failed to capture: {e}")
+
             def run_in_thread():
+                """Run coroutine in a new thread with its own event loop."""
                 new_loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(new_loop)
                 try:
-                    result_container.append(new_loop.run_until_complete(coro))
+                    result = new_loop.run_until_complete(coro)
+                    result_container.append(result)
+                except Exception as e:
+                    logger.debug(f"Exception in async thread: {e}")
+                    exception_container.append(e)
                 finally:
                     new_loop.close()
-            
-            thread = threading.Thread(target=run_in_thread)
+                    asyncio.set_event_loop(None)
+
+            thread = threading.Thread(target=run_in_thread, daemon=False)
+
+            # Propagate Streamlit context to the worker thread if available
+            if streamlit_ctx is not None:
+                try:
+                    add_script_run_ctx(thread, streamlit_ctx)
+                    logger.debug("Successfully propagated Streamlit context to worker thread")
+                except Exception as e:
+                    logger.warning(f"Failed to propagate Streamlit context to worker thread: {e}")
+
             thread.start()
-            thread.join()
+            thread.join(timeout=self.tool_execution_timeout)  # 15 minute timeout for safety
+
+            if thread.is_alive():
+                logger.error("Async operation timed out after 5 minutes")
+                raise TimeoutError("Async operation in thread timed out")
+
+            # Re-raise exception if one occurred
+            if exception_container:
+                raise exception_container[0]
+
             return result_container[0] if result_container else None
-            
-        except RuntimeError:
-            # No event loop running - use/create persistent loop
-            # This loop is shared with MCP session creation for stateful tools
+
+        # Scenario 2 & 3: No loop running - use or create persistent loop
+        else:
+            # Get or create persistent loop
             if not hasattr(self.__class__, '_persistent_loop') or \
                self.__class__._persistent_loop is None or \
                self.__class__._persistent_loop.is_closed():
                 self.__class__._persistent_loop = asyncio.new_event_loop()
                 logger.debug("Created persistent event loop for async tools")
-            
+
             loop = self.__class__._persistent_loop
-            asyncio.set_event_loop(loop)
-            return loop.run_until_complete(coro)
-    
+
+            # Double-check the loop is not running (safety check)
+            if loop.is_running():
+                logger.debug("Persistent loop is unexpectedly running, using thread execution")
+
+                result_container = []
+                exception_container = []
+
+                # Try to capture Streamlit context from current thread for propagation
+                streamlit_ctx = None
+                try:
+                    from streamlit.runtime.scriptrunner import get_script_run_ctx, add_script_run_ctx
+                    streamlit_ctx = get_script_run_ctx()
+                    if streamlit_ctx:
+                        logger.debug("Captured Streamlit context for propagation to worker thread")
+                except (ImportError, Exception) as e:
+                    logger.debug(f"Streamlit context not available or failed to capture: {e}")
+
+                def run_in_thread():
+                    """Run coroutine in a new thread with its own event loop."""
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    try:
+                        result = new_loop.run_until_complete(coro)
+                        result_container.append(result)
+                    except Exception as ex:
+                        logger.debug(f"Exception in async thread: {ex}")
+                        exception_container.append(ex)
+                    finally:
+                        new_loop.close()
+                        asyncio.set_event_loop(None)
+
+                thread = threading.Thread(target=run_in_thread, daemon=False)
+
+                # Propagate Streamlit context to the worker thread if available
+                if streamlit_ctx is not None:
+                    try:
+                        add_script_run_ctx(thread, streamlit_ctx)
+                        logger.debug("Successfully propagated Streamlit context to worker thread")
+                    except Exception as e:
+                        logger.warning(f"Failed to propagate Streamlit context to worker thread: {e}")
+
+                thread.start()
+                thread.join(timeout=self.tool_execution_timeout)
+
+                if thread.is_alive():
+                    logger.error("Async operation timed out after 15 minutes")
+                    raise TimeoutError("Async operation in thread timed out")
+
+                if exception_container:
+                    raise exception_container[0]
+
+                return result_container[0] if result_container else None
+            else:
+                # Loop exists but not running - safe to use run_until_complete
+                logger.debug(f"Using persistent loop (id: {id(loop)}) with run_until_complete")
+                asyncio.set_event_loop(loop)
+                return loop.run_until_complete(coro)
+
     async def _arun(self, *args, **kwargs):
         # Legacy async support
         return self.invoke(kwargs, **kwargs)
@@ -324,12 +433,14 @@ class LLMNode(BaseTool):
                         
                         # Try async invoke first (for MCP tools), fallback to sync
                         tool_result = None
-                        try:
-                            # Try async invocation first
-                            tool_result = await tool_to_execute.ainvoke(tool_args, config=config)
-                        except NotImplementedError:
-                            # Tool doesn't support async, use sync invoke
-                            logger.debug(f"Tool '{tool_name}' doesn't support async, using sync invoke")
+                        if hasattr(tool_to_execute, 'ainvoke'):
+                            try:
+                                tool_result = await tool_to_execute.ainvoke(tool_args, config=config)
+                            except (NotImplementedError, AttributeError):
+                                logger.debug(f"Tool '{tool_name}' ainvoke failed, falling back to sync invoke")
+                                tool_result = tool_to_execute.invoke(tool_args, config=config)
+                        else:
+                            # Sync-only tool
                             tool_result = tool_to_execute.invoke(tool_args, config=config)
 
                         # Create tool message with result - preserve structured content