Feature: Auto-approval for specific tools (#26)

* feat(console_ui.py): enhance tool approval prompt to include options for session and forever approval
feat(tool_manager.py): load persistent auto-approved tools from config to maintain user preferences across sessions
feat(config_management.py): add methods to manage auto-approval tools in global config for better user experience

* chore(tool_manager.py): remove commented-out code for loading auto-approved tools to clean up the codebase
chore(config_management.py): remove commented-out code for ensuring auto_approval_tools key to enhance code clarity

* chore(console_ui.py): remove commented-out code for clarity and maintainability
chore(tool_manager.py): remove commented-out explanation to streamline code readability

* refactor(tool_manager.py): move _load_persistent_auto_approved_tools method to the end of the class for better readability and organization

* fix(console_ui.py): update prompt text for tool approval options to improve clarity
fix(console_ui.py): simplify approved text messages for better readability
fix(config_management.py): return a default configuration structure with global settings when config file is missing or invalid

Author: lewistransts

AgentCrew/modules/chat/console_ui.py

@@ -451,7 +451,7 @@ def display_tool_confirmation_request(self, tool_info):
             # Use Rich to print the prompt but still need to use input() for user interaction
             self.console.print(
                 Text(
-                    "\nAllow this tool to run? [y]es/[n]o/[all] future calls: ",
+                    "\nAllow this tool to run? [y]es/[n]o/[a]ll in this session/[f]orever (this and future sessions): ",
                     style=RICH_STYLE_YELLOW,
                 ),
                 end="",
@@ -471,20 +471,31 @@ def display_tool_confirmation_request(self, tool_info):
                     confirmation_id, {"action": "deny"}
                 )
                 break
-            elif response in ["all", "a"]:
+            elif response in ["a", "all"]:
                 self.message_handler.resolve_tool_confirmation(
                     confirmation_id, {"action": "approve_all"}
                 )
                 approved_text = Text(
-                    "✓ Approved all future calls to '", style=RICH_STYLE_YELLOW
+                    f"✓ Approved all future calls to '{tool_use['name']}' for this session.", style=RICH_STYLE_YELLOW
                 )
-                approved_text.append(tool_use["name"])
-                approved_text.append("' for this session.")
                 self.console.print(approved_text)
                 break
+            elif response in ["f", "forever"]:
+                from AgentCrew.modules.config import ConfigManagement
+                config_manager = ConfigManagement()
+                config_manager.write_auto_approval_tools(tool_use["name"], add=True)
+
+                self.message_handler.resolve_tool_confirmation(
+                    confirmation_id, {"action": "approve_all"}
+                )
+                saved_text = Text(
+                    f"✓ Tool '{tool_use['name']}' will be auto-approved forever.", style=RICH_STYLE_YELLOW
+                )
+                self.console.print(saved_text)
+                break
             else:
                 self.console.print(
-                    Text("Please enter 'y', 'n', or 'all'.", style=RICH_STYLE_YELLOW)
+                    Text("Please enter 'y', 'n', 'a', or 'f'.", style=RICH_STYLE_YELLOW)
                 )
         self._start_input_thread()
 

AgentCrew/modules/chat/message/tool_manager.py

@@ -2,6 +2,7 @@
 import asyncio
 
 from AgentCrew.modules import logger
+from AgentCrew.modules.config import ConfigManagement
 from AgentCrew.modules.llm.message import MessageTransformer
 
 
@@ -13,11 +14,18 @@ def __init__(self, message_handler):
 
         if isinstance(message_handler, MessageHandler):
             self.message_handler = message_handler
-        self._auto_approved_tools = set()  # Track tools approved for all future calls
+
+        self._auto_approved_tools = self._load_persistent_auto_approved_tools()
+
         self._pending_confirmations = {}  # Store futures for confirmation requests
         self._next_confirmation_id = 0  # ID counter for confirmation requests
         self.yolo_mode = False  # Enable/disable auto-approval mode
 
+    def _load_persistent_auto_approved_tools(self):
+        """Load persistent auto-approved tools from config."""
+        config_manager = ConfigManagement()
+        return set(config_manager.get_auto_approval_tools())
+
     async def execute_tool(self, tool_use: Dict[str, Any]):
         """Execute a tool with proper confirmation flow."""
         tool_name = tool_use["name"]
@@ -62,7 +70,6 @@ async def execute_tool(self, tool_use: Dict[str, Any]):
                 )
             return
 
-        # For all other tools, check if confirmation is needed
         if not self.yolo_mode and tool_name not in self._auto_approved_tools:
             # Request confirmation from the user
             confirmation = await self._wait_for_tool_confirmation(tool_use)
@@ -242,4 +249,4 @@ def _post_tool_transfer(self, tool_use, tool_result):
 
     def reset_approved_tools(self):
         """Reset approved tools for a new conversation."""
-        self._auto_approved_tools = set()
+        self._auto_approved_tools = self._load_persistent_auto_approved_tools()

AgentCrew/modules/config/config_management.py

@@ -230,30 +230,33 @@ def _get_global_config_file_path(self) -> str:
     def read_global_config_data(self) -> Dict[str, Any]:
         """Reads data from the global config.json file."""
         config_path = self._get_global_config_file_path()
+        default_config = {"api_keys": {}, "auto_approval_tools": [], "global_settings": {"theme": "dark", "yolo_mode": False}}
         try:
             if not os.path.exists(config_path):
-                return {"api_keys": {}}  # Default structure if file doesn't exist
+                return default_config
             with open(config_path, "r", encoding="utf-8") as f:
                 data = json.load(f)
                 if not isinstance(data, dict):
                     logger.warning(
                         f"Warning: Global config file {config_path} does not contain a valid JSON object. Returning default."
                     )
-                    return {"api_keys": {}}
+                    return default_config
                 # Ensure api_keys key exists and is a dict
                 if "api_keys" not in data or not isinstance(data.get("api_keys"), dict):
                     data["api_keys"] = {}
+                if "auto_approval_tools" not in data or not isinstance(data.get("auto_approval_tools"), list):
+                    data["auto_approval_tools"] = []
                 return data
         except json.JSONDecodeError:
             logger.warning(
                 f"Warning: Error decoding global config file {config_path}. Returning default config."
             )
-            return {"api_keys": {}}
+            return default_config
         except Exception as e:
             logger.warning(
                 f"Warning: Could not read global config file {config_path}: {e}. Returning default config."
             )
-            return {"api_keys": {}}
+            return default_config
 
     def write_global_config_data(self, config_data: Dict[str, Any]) -> None:
         """Writes data to the global config.json file."""
@@ -561,3 +564,36 @@ def get_last_used_agent(self) -> Optional[str]:
         """
         last_used = self.get_last_used_settings()
         return last_used.get("agent")
+
+    def get_auto_approval_tools(self) -> List[str]:
+        """
+        Get the list of auto-approved tools from global config.
+
+        Returns:
+            List of tool names that are auto-approved.
+        """
+        global_config = self.read_global_config_data()
+        return global_config.get("auto_approval_tools", [])
+
+    def write_auto_approval_tools(self, tool_name: str, add: bool = True) -> None:
+        """
+        Add or remove a tool from the auto-approval list in global config.
+
+        Args:
+            tool_name: Name of the tool to add/remove from auto-approval list.
+            add: True to add the tool, False to remove it.
+        """
+        try:
+            global_config = self.read_global_config_data()
+            auto_approval_tools = global_config.get("auto_approval_tools", [])
+
+            if add and tool_name not in auto_approval_tools:
+                auto_approval_tools.append(tool_name)
+            elif not add and tool_name in auto_approval_tools:
+                auto_approval_tools.remove(tool_name)
+
+            global_config["auto_approval_tools"] = auto_approval_tools
+            self.write_global_config_data(global_config)
+        except Exception as e:
+            action = "add" if add else "remove"
+            logger.warning(f"Warning: Failed to {action} tool {tool_name} from auto-approval list: {e}")