fix: resolve reviewer issues - timeout blocking, BaseTool import, boolean conversion

- Fix ThreadPoolExecutor timeout blocking by using non-blocking shutdown
- Replace BaseTool import error with safe tool instantiation pattern
- Fix case-sensitive boolean conversion for handoff_detect_cycles
- Consolidate duplicate tool loading code in ToolResolver
- Improve per-file error isolation in directory tool loading

Co-authored-by: Mervin Praison <MervinPraison@users.noreply.github.com>

Author: praisonai-triage-agent[bot]

src/praisonai/praisonai/agents_generator.py

@@ -358,7 +358,7 @@ def _merge_cli_config(self, config, cli_config):
             if 'handoff_max_concurrent' in cli_config:
                 handoff_config['max_concurrent'] = cli_config['handoff_max_concurrent']
             if 'handoff_detect_cycles' in cli_config:
-                handoff_config['detect_cycles'] = cli_config['handoff_detect_cycles'] == 'true'
+                handoff_config['detect_cycles'] = cli_config['handoff_detect_cycles'].lower() == 'true'
 
             if handoff_config:
                 agent_overrides['handoff'] = handoff_config
@@ -608,12 +608,17 @@ def generate_crew_and_kickoff(self):
             except Exception as e:
                 self.logger.warning(f"Error collecting YAML tool references: {e}")
 
-            # Add tools from class names
+            # Add tools from class names - use tool_resolver to check tool validity
             for tool_class in self.tools:
-                if isinstance(tool_class, type) and BaseTool and issubclass(tool_class, BaseTool):
-                    tool_name = tool_class.__name__
-                    tools_dict[tool_name] = tool_class()
-                    self.logger.debug(f"Added tool: {tool_name}")
+                if isinstance(tool_class, type):
+                    try:
+                        # Try to instantiate the tool to validate it
+                        tool_instance = tool_class()
+                        tool_name = tool_class.__name__
+                        tools_dict[tool_name] = tool_instance
+                        self.logger.debug(f"Added tool: {tool_name}")
+                    except Exception as e:
+                        self.logger.warning(f"Failed to instantiate tool class {tool_class.__name__}: {e}")
 
         root_directory = os.getcwd()
         tools_py_path = os.path.join(root_directory, 'tools.py')

src/praisonai/praisonai/scheduler/agent_scheduler.py

@@ -247,14 +247,14 @@ def _execute_with_retry(self, max_retries: int):
                 # Execute with timeout if specified
                 if self.timeout:
                     executor = ThreadPoolExecutor(max_workers=1)
+                    future = executor.submit(self._executor.execute, self.task)
                     try:
-                        future = executor.submit(self._executor.execute, self.task)
-                        try:
-                            result = future.result(timeout=self.timeout)
-                        except FuturesTimeout:
-                            future.cancel()
-                            raise TimeoutError(f"Execution exceeded {self.timeout}s timeout")
-                    finally:
+                        result = future.result(timeout=self.timeout)
+                    except FuturesTimeout as e:
+                        future.cancel()
+                        executor.shutdown(wait=False, cancel_futures=True)
+                        raise TimeoutError(f"Execution exceeded {self.timeout}s timeout") from e
+                    else:
                         executor.shutdown(wait=False, cancel_futures=True)
                 else:
                     result = self._executor.execute(self.task)

src/praisonai/praisonai/tool_resolver.py

@@ -454,34 +454,7 @@ def get_local_tool_classes(self) -> Dict[str, Any]:
             module = load_user_module(self._tools_py_path, name="tools_module")
             if module is None:
                 return {}
-            
-            # Import the necessary classes (matching agents_generator.py logic)
-            BaseTool = None
-            PRAISONAI_TOOLS_AVAILABLE = False
-            try:
-                from praisonai_tools import BaseTool
-                PRAISONAI_TOOLS_AVAILABLE = True
-            except ImportError:
-                try:
-                    from praisonai.tools import BaseTool
-                    PRAISONAI_TOOLS_AVAILABLE = True
-                except ImportError:
-                    pass
-            
-            result = {}
-            for name, obj in inspect.getmembers(module, 
-                lambda x: inspect.isclass(x) and (
-                    x.__module__.startswith('langchain_community.tools') or 
-                    (PRAISONAI_TOOLS_AVAILABLE and BaseTool and issubclass(x, BaseTool))
-                ) and x is not BaseTool):
-                try:
-                    result[name] = obj()
-                    logger.debug(f"Loaded local tool class: {name}")
-                except Exception as e:
-                    logger.warning(f"Error instantiating tool class {name}: {e}")
-                    continue
-            
-            return result
+            return self._extract_tool_classes(module)
         except Exception as e:
             logger.warning(f"Error loading tool classes from {self._tools_py_path}: {e}")
             return {}
@@ -499,15 +472,15 @@ def get_local_tool_classes_from_dir(self, tools_dir: "os.PathLike|str") -> Dict[
         from ._safe_loader import load_user_module
 
         classes: Dict[str, Any] = {}
-        try:
-            for py_file in Path(tools_dir).glob("*.py"):
-                if py_file.name.startswith("__"):
-                    continue
+        for py_file in Path(tools_dir).glob("*.py"):
+            if py_file.name.startswith("__"):
+                continue
+            try:
                 module = load_user_module(py_file, name=f"tools_{py_file.stem}")
                 if module is not None:
-                    classes.update(self._extract_tool_classes(module))   # reuse resolver's own predicate
-        except Exception as e:
-            logger.warning(f"Error loading tool classes from directory {tools_dir}: {e}")
+                    classes.update(self._extract_tool_classes(module))
+            except Exception as e:
+                logger.warning(f"Error loading tool classes from file {py_file}: {e}")
         return classes
 
     def _extract_tool_classes(self, module):