clap-agents 0.1.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

clap/tool_pattern/tool_agent.py

@@ -1,46 +1,59 @@
-# --- START OF ASYNC MODIFIED tool_agent.py (Init Fix) ---
 
 import json
 import asyncio
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Union # Added Union
 
 from colorama import Fore
 from dotenv import load_dotenv
-from groq import AsyncGroq
 
 from clap.tool_pattern.tool import Tool
 from clap.mcp_client.client import MCPClientManager
-from clap.utils.completions import build_prompt_structure
-from clap.utils.completions import ChatHistory
-from clap.utils.completions import completions_create
-from clap.utils.completions import update_chat_history
-from mcp import types as mcp_types
+from clap.utils.completions import build_prompt_structure, ChatHistory, update_chat_history
+from clap.llm_services.base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
+from clap.vector_stores.base import VectorStoreInterface, QueryResult
+
+from clap.multiagent_pattern.agent import VECTOR_QUERY_TOOL_SCHEMA
+
+
+
+try:
+    from mcp import types as mcp_types
+except ImportError:
+    mcp_types = None
 
 load_dotenv()
 
 NATIVE_TOOL_SYSTEM_PROMPT = """
-You are a helpful assistant. Use the available tools (local or remote) if necessary to answer the user's request.
+You are a helpful assistant. Use the available tools (local functions, remote MCP tools, or vector_query for document retrieval) if necessary to answer the user's request.
 If you use a tool, you will be given the results, and then you should provide the final response to the user based on those results.
 If no tool is needed, answer directly.
+When using vector_query, the 'query' argument should be the user's main question.
 """
 
 class ToolAgent:
     """
-    A simple agent that uses native tool calling asynchronously to answer user queries.
-    Supports both local Python tools and remote MCP tools via an MCPClientManager.
-    It makes one attempt to call tools if needed, processes the results,
+    A simple agent that uses LLM native tool calling asynchronously.
+    Supports local, remote MCP tools, and RAG via vector_query tool, using an LLMServiceInterface.
+    Makes one attempt to call tools if needed, processes results,
     and then generates a final response.
     """
 
     def __init__(
         self,
-        tools: Optional[Tool | List[Tool]] = None,
+        llm_service: LLMServiceInterface,
+        model: str,
+        tools: Optional[Union[Tool, List[Tool]]] = None,
         mcp_manager: Optional[MCPClientManager] = None,
         mcp_server_names: Optional[List[str]] = None,
-        model: str = "llama-3.3-70b-versatile",
+        vector_store: Optional[VectorStoreInterface] = None, 
         system_prompt: str = NATIVE_TOOL_SYSTEM_PROMPT,
     ) -> None:
-        self.client = AsyncGroq()
+        if not isinstance(llm_service, LLMServiceInterface):
+            raise TypeError("llm_service must be an instance of LLMServiceInterface.")
+        if not model or not isinstance(model, str):
+            raise ValueError("A valid model name (string) is required.")
+
+        self.llm_service = llm_service
         self.model = model
         self.system_prompt = system_prompt
 
@@ -48,7 +61,7 @@ class ToolAgent:
             self.local_tools = []
         elif isinstance(tools, list):
             self.local_tools = tools
-        else:
+        else: 
             self.local_tools = [tools]
 
         self.local_tools_dict = {tool.name: tool for tool in self.local_tools}
@@ -56,186 +69,173 @@ class ToolAgent:
 
         self.mcp_manager = mcp_manager
         self.mcp_server_names = mcp_server_names or []
-        self.remote_tools_dict: Dict[str, mcp_types.Tool] = {}
+        self.remote_tools_dict: Dict[str, Any] = {}
         self.remote_tool_server_map: Dict[str, str] = {}
 
+        self.vector_store = vector_store 
 
     async def _get_combined_tool_schemas(self) -> List[Dict[str, Any]]:
-        """Fetches remote tools and combines their schemas with local ones."""
-        all_schemas = list(self.local_tool_schemas) # Start with local schemas
-        self.remote_tools_dict = {} # Reset remote tools for this run
+        all_schemas = list(self.local_tool_schemas)
+        
+        self.remote_tools_dict = {}
         self.remote_tool_server_map = {}
-
-        if self.mcp_manager and self.mcp_server_names:
-            fetch_tasks = [
-                self.mcp_manager.list_remote_tools(name)
-                for name in self.mcp_server_names
-            ]
+        if self.mcp_manager and self.mcp_server_names and mcp_types:
+            fetch_tasks = [self.mcp_manager.list_remote_tools(name) for name in self.mcp_server_names]
             results = await asyncio.gather(*fetch_tasks, return_exceptions=True)
-
             for server_name, result in zip(self.mcp_server_names, results):
-                if isinstance(result, Exception):
-                    print(f"{Fore.RED}Error listing tools from MCP server '{server_name}': {result}{Fore.RESET}")
-                    continue
-
+                if isinstance(result, Exception): print(f"{Fore.RED}ToolAgent: Error listing MCP tools '{server_name}': {result}{Fore.RESET}"); continue
                 if isinstance(result, list):
-                    for tool in result:
-                        if isinstance(tool, mcp_types.Tool):
-                           if tool.name in self.local_tools_dict:
-                               print(f"{Fore.YELLOW}Warning: Remote tool '{tool.name}' from server '{server_name}' conflicts with local tool. Local tool will be used.{Fore.RESET}")
-                               continue
-                           if tool.name in self.remote_tools_dict:
-                               print(f"{Fore.YELLOW}Warning: Remote tool '{tool.name}' from server '{server_name}' conflicts with another remote tool from server '{self.remote_tool_server_map[tool.name]}'. Skipping duplicate.{Fore.RESET}")
-                               continue
-
-                           self.remote_tools_dict[tool.name] = tool
-                           self.remote_tool_server_map[tool.name] = server_name
-
-                           translated_schema = {
-                               "type": "function",
-                               "function": {
-                                   "name": tool.name,
-                                   "description": tool.description or "",
-                                   "parameters": tool.inputSchema
-                               }
-                           }
+                    for tool_obj in result: 
+                        if isinstance(tool_obj, mcp_types.Tool):
+                           if tool_obj.name in self.local_tools_dict: print(f"{Fore.YELLOW}ToolAgent Warning: MCP tool '{tool_obj.name}' conflicts with local. Skipping.{Fore.RESET}"); continue
+                           
+                           if self.vector_store and tool_obj.name == VECTOR_QUERY_TOOL_SCHEMA["function"]["name"]:
+                               print(f"{Fore.YELLOW}ToolAgent Warning: MCP tool '{tool_obj.name}' conflicts with built-in vector_query tool. Skipping MCP version.{Fore.RESET}"); continue
+                           if tool_obj.name in self.remote_tools_dict: print(f"{Fore.YELLOW}ToolAgent Warning: MCP tool '{tool_obj.name}' conflicts with another remote. Skipping.{Fore.RESET}"); continue
+                           self.remote_tools_dict[tool_obj.name] = tool_obj
+                           self.remote_tool_server_map[tool_obj.name] = server_name
+                           translated_schema = {"type": "function", "function": {"name": tool_obj.name, "description": tool_obj.description or "", "parameters": tool_obj.inputSchema or {"type": "object", "properties": {}}}}
                            all_schemas.append(translated_schema)
-                        else:
-                             print(f"{Fore.YELLOW}Warning: Received non-Tool object from {server_name}: {type(tool)}{Fore.RESET}")
-
-        print(f"{Fore.BLUE}Total tools available to LLM: {len(all_schemas)}{Fore.RESET}")
+                        else: print(f"{Fore.YELLOW}ToolAgent Warning: Non-Tool object from {server_name}: {type(tool_obj)}{Fore.RESET}")
+
+        
+        if self.vector_store:
+            
+            if not any(schema["function"]["name"] == VECTOR_QUERY_TOOL_SCHEMA["function"]["name"] for schema in all_schemas):
+                all_schemas.append(VECTOR_QUERY_TOOL_SCHEMA)
+                print(f"{Fore.BLUE}ToolAgent: Vector query tool is available.{Fore.RESET}")
+        
+        print(f"{Fore.BLUE}ToolAgent: Total tools available to LLM: {len(all_schemas)}{Fore.RESET}")
         return all_schemas
 
-    async def process_tool_calls(self, tool_calls: List[Any]) -> List[Dict[str, Any]]:
-        """
-        Processes tool calls requested by the LLM asynchronously, dispatches execution
-        to local or remote tools, and collects results formatted as 'tool' role messages.
-        """
-        observation_messages = []
-        if not isinstance(tool_calls, list):
-             print(f"{Fore.RED}Error: Expected a list of tool_calls, got {type(tool_calls)}{Fore.RESET}")
-             return observation_messages
-
-        tasks = [self._execute_single_tool_call(tc) for tc in tool_calls]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        for result in results:
-             if isinstance(result, dict):
-                  if len(result) == 1:
-                      tool_call_id, result_str = list(result.items())[0]
-                      observation_messages.append(
-                           build_prompt_structure(role="tool", content=result_str, tool_call_id=tool_call_id)
-                      )
-                  else:
-                       print(f"{Fore.RED}Error: Unexpected result format from tool execution: {result}{Fore.RESET}")
-             elif isinstance(result, Exception):
-                  print(f"{Fore.RED}Error during concurrent tool execution: {result}{Fore.RESET}")
-             else:
-                  print(f"{Fore.RED}Error: Unexpected item in tool execution results: {result}{Fore.RESET}")
-
-        return observation_messages
-
-    async def _execute_single_tool_call(self, tool_call: Any) -> Dict[str, Any]:
-        """Helper to execute a single tool call (local or remote)."""
-        tool_call_id = getattr(tool_call, 'id', 'error_no_id')
-        function_call = getattr(tool_call, 'function', None)
-        tool_name = getattr(function_call, 'name', 'error_unknown_name')
-        result_str = f"Error: Processing failed for tool call '{tool_name}' (id: {tool_call_id})."
-
+    async def _execute_single_tool_call(self, tool_call: LLMToolCall) -> Dict[str, Any]:
+        tool_call_id = tool_call.id
+        tool_name = tool_call.function_name
+        result_str = f"Error: Processing tool call '{tool_name}' (id: {tool_call_id})."
         try:
-            if not function_call:
-                 raise ValueError("Invalid tool_call object structure: missing 'function'.")
-
-            arguments_str = getattr(function_call, 'arguments', '{}')
-            arguments = json.loads(arguments_str)
-
-            if tool_name in self.local_tools_dict:
-                tool = self.local_tools_dict[tool_name]
-                print(f"{Fore.GREEN}\nExecuting Local Tool: {tool_name}{Fore.RESET}")
-                print(f"Tool call ID: {tool_call_id}")
-                print(f"Arguments: {arguments}")
-                result = await tool.run(**arguments)
+            arguments = json.loads(tool_call.function_arguments_json_str)
+
+            
+            if self.vector_store and tool_name == VECTOR_QUERY_TOOL_SCHEMA["function"]["name"]:
+                print(f"{Fore.CYAN}\nToolAgent: Executing Vector Store Query Tool: {tool_name} (ID: {tool_call_id}) Args: {arguments}{Fore.RESET}")
+                query_text = arguments.get("query")
+                
+                top_k_value_from_llm = arguments.get("top_k")
+                default_top_k_from_schema = VECTOR_QUERY_TOOL_SCHEMA["function"]["parameters"]["properties"]["top_k"].get("default", 3)
+                top_k = default_top_k_from_schema
+                if top_k_value_from_llm is not None:
+                    try: top_k = int(top_k_value_from_llm)
+                    except (ValueError, TypeError):
+                        print(f"{Fore.YELLOW}ToolAgent Warning: LLM provided top_k '{top_k_value_from_llm}' is invalid. Using default: {default_top_k_from_schema}.{Fore.RESET}")
+
+                if not query_text:
+                    result_str = "Error: 'query' argument required for vector_query tool."
+                else:
+                    query_results: QueryResult = await self.vector_store.aquery(
+                        query_texts=[query_text], n_results=top_k,
+                        include=["documents", "metadatas", "distances"]
+                    )
+                    
+                    formatted_chunks_for_llm = []
+                    current_length = 0
+                    max_obs_len = 4000 
+                    retrieved_docs = query_results.get("documents")
+                    retrieved_ids = query_results.get("ids")
+                    if retrieved_docs and isinstance(retrieved_docs, list) and len(retrieved_docs) > 0 and \
+                       retrieved_ids and isinstance(retrieved_ids, list) and len(retrieved_ids) > 0:
+                        docs_for_query, ids_for_query = retrieved_docs[0], retrieved_ids[0]
+                        metas_list, distances_list = query_results.get("metadatas"), query_results.get("distances")
+                        metas_for_query = metas_list[0] if metas_list and len(metas_list) > 0 else [None] * len(docs_for_query)
+                        distances_for_query = distances_list[0] if distances_list and len(distances_list) > 0 else [None] * len(docs_for_query)
+                        for i, doc_content_item in enumerate(docs_for_query):
+                            current_meta = metas_for_query[i] if i < len(metas_for_query) else None
+                            current_id = str(ids_for_query[i]) if i < len(ids_for_query) else "N/A"
+                            current_distance = distances_for_query[i] if i < len(distances_for_query) and distances_for_query[i] is not None else float('nan')
+                            meta_str = json.dumps(current_meta, ensure_ascii=False) if current_meta else "{}"
+                            current_chunk_formatted = (
+                                f"--- Retrieved Chunk {str(i+1)} (ID: {current_id}, Distance: {current_distance:.4f}) ---\n"
+                                f"Metadata: {meta_str}\nContent: {str(doc_content_item)}\n\n")
+                            chunk_len = len(current_chunk_formatted)
+                            if current_length + chunk_len <= max_obs_len:
+                                formatted_chunks_for_llm.append(current_chunk_formatted)
+                                current_length += chunk_len
+                            else:
+                                print(f"{Fore.YELLOW}ToolAgent: Obs limit ({max_obs_len}) reached. Included {len(formatted_chunks_for_llm)} chunks.{Fore.RESET}"); break
+                        if formatted_chunks_for_llm:
+                            header = f"Retrieved {len(formatted_chunks_for_llm)} relevant document chunks (out of {len(docs_for_query)} found):\n\n"
+                            result_str = header + "".join(formatted_chunks_for_llm).strip()
+                        else: result_str = "No relevant documents found (or chunks too long for limit)."
+                    else: result_str = "No relevant documents found in vector store for query."
+           
+
+            elif tool_name in self.local_tools_dict:
+                tool_instance = self.local_tools_dict[tool_name]
+                result = await tool_instance.run(**arguments)
+                if not isinstance(result, str): result_str = json.dumps(result, ensure_ascii=False)
+                else: result_str = result
             elif tool_name in self.remote_tool_server_map and self.mcp_manager:
                 server_name = self.remote_tool_server_map[tool_name]
-                print(f"{Fore.CYAN}\nExecuting Remote MCP Tool: {tool_name} on {server_name}{Fore.RESET}")
-                print(f"Tool call ID: {tool_call_id}")
-                print(f"Arguments: {arguments}")
-                result = await self.mcp_manager.call_remote_tool(server_name, tool_name, arguments)
+                result_str = await self.mcp_manager.call_remote_tool(server_name, tool_name, arguments)
             else:
-                print(f"{Fore.RED}Error: Tool '{tool_name}' not found locally or in known remote servers.{Fore.RESET}")
-                result_str = f"Error: Tool '{tool_name}' is not available."
+                result_str = f"Error: Tool '{tool_name}' not available."
+                print(f"{Fore.RED}ToolAgent: {result_str}{Fore.RESET}")
                 return {tool_call_id: result_str}
-
-            if not isinstance(result, (str, int, float, bool, list, dict, type(None))):
-                result_str = str(result)
-            else:
-                try: result_str = json.dumps(result)
-                except TypeError: result_str = str(result)
-            print(f"{Fore.GREEN}Tool '{tool_name}' result: {result_str[:100]}...{Fore.RESET}")
-
+            
+            print(f"{Fore.GREEN}ToolAgent: Tool '{tool_name}' observation: {result_str[:150]}...{Fore.RESET}")
         except json.JSONDecodeError:
-            print(f"{Fore.RED}Error: Could not decode arguments for tool {tool_name}: {arguments_str}{Fore.RESET}")
-            result_str = f"Error: Invalid arguments JSON provided for {tool_name}"
+            result_str = f"Error: Invalid arguments JSON for {tool_name}."
+            print(f"{Fore.RED}ToolAgent: {result_str} Data: {tool_call.function_arguments_json_str}{Fore.RESET}")
         except Exception as e:
-             print(f"{Fore.RED}Error processing or running tool {tool_name} (id: {tool_call_id}): {e}{Fore.RESET}")
-             result_str = f"Error executing tool {tool_name}: {e}"
-
+            result_str = f"Error executing tool {tool_name}: {e}"
+            print(f"{Fore.RED}ToolAgent: Error for tool {tool_name} (ID: {tool_call_id}): {e}{Fore.RESET}")
         return {tool_call_id: result_str}
 
-    async def run(
-        self,
-        user_msg: str,
-    ) -> str:
-        """
-        Handles the asynchronous interaction: user message -> LLM (tool decision) ->
-        execute tools (local or remote) -> LLM (final response).
-        """
-        combined_tool_schemas = await self._get_combined_tool_schemas()
+    
+    async def process_tool_calls(self, tool_calls: List[LLMToolCall]) -> List[Dict[str, Any]]:
+        observation_messages = []
+        if not isinstance(tool_calls, list): return observation_messages
+        tasks = [self._execute_single_tool_call(tc) for tc in tool_calls]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        for result in results:
+             if isinstance(result, dict) and len(result) == 1:
+                  tool_call_id, result_str = list(result.items())[0]
+                  observation_messages.append(build_prompt_structure(role="tool", content=result_str, tool_call_id=tool_call_id))
+             elif isinstance(result, Exception): print(f"{Fore.RED}ToolAgent: Error in concurrent tool execution: {result}{Fore.RESET}")
+             else: print(f"{Fore.RED}ToolAgent: Unexpected item in tool results: {result}{Fore.RESET}")
+        return observation_messages
 
+    async def run(self, user_msg: str) -> str:
+        combined_tool_schemas = await self._get_combined_tool_schemas()
         initial_user_message = build_prompt_structure(role="user", content=user_msg)
         chat_history = ChatHistory(
-            [
-                build_prompt_structure(role="system", content=self.system_prompt),
-                initial_user_message,
-            ]
+            [build_prompt_structure(role="system", content=self.system_prompt), initial_user_message]
         )
-
-        print(f"{Fore.CYAN}\n--- Calling LLM for Tool Decision ---{Fore.RESET}")
-        assistant_message_1 = await completions_create(
-            self.client,
-            messages=list(chat_history),
-            model=self.model,
-            tools=combined_tool_schemas,
-            tool_choice="auto"
+        llm_response_1: StandardizedLLMResponse = await self.llm_service.get_llm_response(
+            model=self.model, messages=list(chat_history),
+            tools=combined_tool_schemas if combined_tool_schemas else None,
+            tool_choice="auto" if combined_tool_schemas else "none"
         )
-
-        update_chat_history(chat_history, assistant_message_1)
-
-        final_response = "Agent encountered an issue."
-
-        if hasattr(assistant_message_1, 'tool_calls') and assistant_message_1.tool_calls:
-            print(f"{Fore.YELLOW}\nAssistant requests tool calls:{Fore.RESET}")
-            observation_messages = await self.process_tool_calls(assistant_message_1.tool_calls)
-            print(f"{Fore.BLUE}\nObservations prepared for LLM: {observation_messages}{Fore.RESET}")
-
-            for obs_msg in observation_messages:
-                update_chat_history(chat_history, obs_msg)
-
-            print(f"{Fore.CYAN}\n--- Calling LLM for Final Response ---{Fore.RESET}")
-            assistant_message_2 = await completions_create(
-                self.client,
-                messages=list(chat_history),
-                model=self.model,
+        assistant_msg_1_dict: Dict[str, Any] = {"role": "assistant"}
+        if llm_response_1.text_content: assistant_msg_1_dict["content"] = llm_response_1.text_content
+        if llm_response_1.tool_calls:
+            assistant_msg_1_dict["tool_calls"] = [
+                {"id": tc.id, "type": "function", "function": {"name": tc.function_name, "arguments": tc.function_arguments_json_str}}
+                for tc in llm_response_1.tool_calls
+            ]
+        if "content" in assistant_msg_1_dict or "tool_calls" in assistant_msg_1_dict:
+            update_chat_history(chat_history, assistant_msg_1_dict)
+
+        final_response = "ToolAgent encountered an issue."
+        if llm_response_1.tool_calls:
+            observation_messages = await self.process_tool_calls(llm_response_1.tool_calls)
+            for obs_msg in observation_messages: update_chat_history(chat_history, obs_msg)
+            llm_response_2: StandardizedLLMResponse = await self.llm_service.get_llm_response(
+                model=self.model, messages=list(chat_history)
             )
-            final_response = str(assistant_message_2.content) if assistant_message_2.content else "Agent did not provide a final response after using tools."
-
-        elif assistant_message_1.content is not None:
-            print(f"{Fore.CYAN}\nAssistant provided direct response (no tools used):{Fore.RESET}")
-            final_response = assistant_message_1.content
+            final_response = llm_response_2.text_content if llm_response_2.text_content else "Agent provided no final response after using tools."
+        elif llm_response_1.text_content is not None:
+            final_response = llm_response_1.text_content
         else:
-            print(f"{Fore.RED}Error: Assistant message has neither content nor tool calls.{Fore.RESET}")
-            final_response = "Error: Received an unexpected empty response from the assistant."
-
-        print(f"{Fore.GREEN}\nFinal Response:\n{final_response}{Fore.RESET}")
+            print(f"{Fore.RED}ToolAgent Error: LLM message has neither content nor tool_calls.{Fore.RESET}")
+            final_response = "Error: ToolAgent received an unexpected empty response from the LLM."
         return final_response
-

clap/tools/__init__.py

@@ -1,6 +1,6 @@
 
 from .web_search import duckduckgo_search
-from .web_crawler import scrape_url, extract_text_by_query # Removed smart_extract
+from .web_crawler import scrape_url, extract_text_by_query 
 from .email_tools import send_email, fetch_recent_emails
 
 __all__ = [

clap/tools/email_tools.py

@@ -1,10 +1,9 @@
-# --- START OF agentic_patterns/tools/email_tools.py ---
 
 import os
 import smtplib
 import imaplib
 import email
-import json # For potential result formatting
+import json 
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 from email.mime.base import MIMEBase
@@ -44,25 +43,25 @@ def _send_email_sync(recipient: str, subject: str, body: str, attachment_path: O
             encoders.encode_base64(part)
             part.add_header("Content-Disposition", f"attachment; filename={os.path.basename(attachment_path)}")
             msg.attach(part)
-        # Use context manager for SMTP connection
+        
         with smtplib.SMTP(SMTP_HOST, SMTP_PORT) as server:
             server.starttls()
             server.login(SMTP_USERNAME, SMTP_PASSWORD)
             server.sendmail(SMTP_USERNAME, recipient, msg.as_string())
-        # Clean up downloaded attachment if it was temporary
+        
         if attachment_path and attachment_path.startswith("temp_attachments"):
             try: os.remove(attachment_path)
-            except OSError: pass # Ignore if deletion fails
+            except OSError: pass 
         return "Email sent successfully."
     except Exception as e:
         return f"Failed to send email: {e}"
 
 def _download_attachment_sync(attachment_url: str, attachment_filename: str) -> str:
     """Synchronous helper to download an attachment."""
-    temp_dir = "temp_attachments" # Consider using tempfile module for more robustness
+    temp_dir = "temp_attachments" 
     os.makedirs(temp_dir, exist_ok=True)
     file_path = os.path.join(temp_dir, attachment_filename)
-    # Use streaming for potentially large files
+    
     with requests.get(attachment_url, stream=True) as r:
         r.raise_for_status()
         with open(file_path, "wb") as f:
@@ -72,7 +71,7 @@ def _download_attachment_sync(attachment_url: str, attachment_filename: str) ->
 
 def _get_pre_staged_attachment_sync(attachment_name: str) -> Optional[str]:
     """Synchronous helper to get a pre-staged attachment."""
-    attachment_dir = "available_attachments" # User needs to create this folder
+    attachment_dir = "available_attachments" 
     file_path = os.path.join(attachment_dir, attachment_name)
     return file_path if os.path.exists(file_path) else None
 
@@ -95,7 +94,7 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
             return f"No emails found in folder '{folder}'."
 
         email_ids = data[0].split()
-        # Fetch in reverse order up to the limit
+        
         ids_to_fetch = email_ids[-(limit):]
 
         for email_id_bytes in reversed(ids_to_fetch):
@@ -109,7 +108,7 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
                             subject = subject.decode(encoding or "utf-8")
                         from_ = msg.get("From", "")
                         date_ = msg.get("Date", "")
-                        # Basic snippet extraction (first text part)
+                        
                         snippet = ""
                         if msg.is_multipart():
                             for part in msg.walk():
@@ -119,8 +118,8 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
                                     try:
                                         body = part.get_payload(decode=True)
                                         snippet = body.decode(part.get_content_charset() or 'utf-8')
-                                        snippet = " ".join(snippet.splitlines()) # Remove newlines
-                                        snippet = snippet[:150] + "..." # Truncate
+                                        snippet = " ".join(snippet.splitlines()) 
+                                        snippet = snippet[:150] + "..." 
                                         break
                                     except Exception:
                                         snippet = "[Could not decode body]"
@@ -141,7 +140,7 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
                             "date": date_,
                             "snippet": snippet
                         })
-            if len(emails_data) >= limit: # Should not exceed limit due to slicing, but safety check
+            if len(emails_data) >= limit: 
                  break
 
         mail.logout()
@@ -149,7 +148,7 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
         if not emails_data:
             return f"No emails found in folder '{folder}'."
 
-        # Format result (maybe JSON is better for agents?)
+        
         result_text = f"Recent emails from {folder} (up to {limit}):\n\n"
         for i, email_data in enumerate(emails_data, 1):
             result_text += f"{i}. From: {email_data['from']}\n"
@@ -161,7 +160,7 @@ def _fetch_emails_sync(folder: str, limit: int) -> str:
     except Exception as e:
         return f"Failed to fetch emails: {e}"
 
-# --- Asynchronous Tool Wrappers ---
+
 
 @tool
 async def send_email(recipient: str, subject: str, body: str,
@@ -195,7 +194,7 @@ async def send_email(recipient: str, subject: str, body: str,
             return f"Failed to download attachment from URL: {e}"
     elif attachment_name:
         try:
-            # Run synchronous file check in thread
+            
             print(f"[Email Tool] Checking for pre-staged attachment: {attachment_name}...")
             final_attachment_path = await anyio.to_thread.run_sync(
                 _get_pre_staged_attachment_sync, attachment_name
@@ -206,7 +205,7 @@ async def send_email(recipient: str, subject: str, body: str,
         except Exception as e:
              return f"Error accessing pre-staged attachment: {e}"
 
-    # Run synchronous email sending in thread
+    
     print(f"[Email Tool] Sending email to {recipient}...")
     return await anyio.to_thread.run_sync(
         _send_email_sync, recipient, subject, body, final_attachment_path
@@ -224,7 +223,5 @@ async def fetch_recent_emails(folder: str = "INBOX", limit: int = 5) -> str:
     Returns:
         A formatted string containing details of the recent emails or an error message.
     """
-    # Run synchronous IMAP fetching in thread
     print(f"[Email Tool] Fetching up to {limit} emails from folder '{folder}'...")
     return await anyio.to_thread.run_sync(_fetch_emails_sync, folder, limit)
-