more tools and added allowed

app.py

@@ -9,6 +9,12 @@ import time
 import random
 import json
 import google.generativeai as genai
+import tempfile
+import uuid
+import math
+import cmath
+import numpy as np
+from urllib.parse import urlparse
 from smolagents import FinalAnswerTool, Tool, tool, OpenAIServerModel, DuckDuckGoSearchTool, CodeAgent, VisitWebpageTool
 
 
@@ -127,6 +133,184 @@ class WikipediaSearchTool(Tool):
         
         return f"Wikipedia search unavailable for '{query}'. Use your knowledge to answer."
 
+# --- Mathematical Tools ---
+class MathTool(Tool):
+    name = "math_calculator"
+    description = "Perform mathematical calculations including basic operations, powers, roots"
+    inputs = {"expression": {"type": "string", "description": "Mathematical expression to evaluate"}}
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
+        
+    def forward(self, expression: str) -> str:
+        try:
+            # Safe evaluation of mathematical expressions
+            allowed_names = {
+                k: v for k, v in math.__dict__.items() if not k.startswith("__")
+            }
+            allowed_names.update({"abs": abs, "round": round, "pow": pow})
+            
+            result = eval(expression, {"__builtins__": {}}, allowed_names)
+            return f"Result: {result}"
+        except Exception as e:
+            return f"Math calculation error: {str(e)}"
+
+# --- File Processing Tools ---
+class FileProcessorTool(Tool):
+    name = "file_processor"
+    description = "Download files from URLs, save content to files, and analyze CSV/Excel files"
+    inputs = {
+        "action": {"type": "string", "description": "Action: 'download', 'save', 'analyze_csv', 'analyze_excel'"},
+        "data": {"type": "string", "description": "URL, content, or file path depending on action"}
+    }
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
+        
+    def forward(self, action: str, data: str) -> str:
+        try:
+            if action == "download":
+                return self._download_file(data)
+            elif action == "save":
+                return self._save_content(data)
+            elif action == "analyze_csv":
+                return self._analyze_csv(data)
+            elif action == "analyze_excel":
+                return self._analyze_excel(data)
+            else:
+                return f"Unknown action: {action}"
+        except Exception as e:
+            return f"File processing error: {str(e)}"
+    
+    def _download_file(self, url: str) -> str:
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            
+            filename = os.path.basename(urlparse(url).path) or f"download_{uuid.uuid4().hex[:8]}"
+            filepath = os.path.join(tempfile.gettempdir(), filename)
+            
+            with open(filepath, 'wb') as f:
+                f.write(response.content)
+            
+            return f"File downloaded to: {filepath}"
+        except Exception as e:
+            return f"Download failed: {str(e)}"
+    
+    def _save_content(self, content: str) -> str:
+        try:
+            filepath = os.path.join(tempfile.gettempdir(), f"content_{uuid.uuid4().hex[:8]}.txt")
+            with open(filepath, 'w') as f:
+                f.write(content)
+            return f"Content saved to: {filepath}"
+        except Exception as e:
+            return f"Save failed: {str(e)}"
+    
+    def _analyze_csv(self, filepath: str) -> str:
+        try:
+            df = pd.read_csv(filepath)
+            result = f"CSV Analysis:\n- Rows: {len(df)}\n- Columns: {len(df.columns)}\n"
+            result += f"- Column names: {', '.join(df.columns)}\n"
+            result += f"- Summary:\n{df.describe().to_string()}"
+            return result[:1000]
+        except Exception as e:
+            return f"CSV analysis failed: {str(e)}"
+    
+    def _analyze_excel(self, filepath: str) -> str:
+        try:
+            df = pd.read_excel(filepath)
+            result = f"Excel Analysis:\n- Rows: {len(df)}\n- Columns: {len(df.columns)}\n"
+            result += f"- Column names: {', '.join(df.columns)}\n"
+            result += f"- Summary:\n{df.describe().to_string()}"
+            return result[:1000]
+        except Exception as e:
+            return f"Excel analysis failed: {str(e)}"
+
+# --- Code Execution Tool ---
+class CodeExecutorTool(Tool):
+    name = "code_executor"
+    description = "Execute Python code safely and return results"
+    inputs = {"code": {"type": "string", "description": "Python code to execute"}}
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
+        
+    def forward(self, code: str) -> str:
+        try:
+            # Create a restricted execution environment
+            allowed_modules = {
+                'math': math, 'cmath': cmath, 'random': random,
+                'json': json, 'time': time, 'os': os,
+                'pandas': pd, 'numpy': np
+            }
+            
+            # Capture output
+            import io
+            import sys
+            from contextlib import redirect_stdout, redirect_stderr
+            
+            stdout_capture = io.StringIO()
+            stderr_capture = io.StringIO()
+            
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                exec(code, {"__builtins__": {}, **allowed_modules})
+            
+            stdout_result = stdout_capture.getvalue()
+            stderr_result = stderr_capture.getvalue()
+            
+            result = "Code executed successfully\n"
+            if stdout_result:
+                result += f"Output: {stdout_result}\n"
+            if stderr_result:
+                result += f"Errors: {stderr_result}\n"
+            
+            return result[:1000]
+            
+        except Exception as e:
+            return f"Code execution error: {str(e)}"
+
+# --- Web Scraping Tool ---
+class WebScrapeTool(Tool):
+    name = "web_scraper"
+    description = "Scrape content from web pages"
+    inputs = {"url": {"type": "string", "description": "URL to scrape"}}
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
+        
+    def forward(self, url: str) -> str:
+        try:
+            response = requests.get(url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
+            response.raise_for_status()
+            
+            # Simple text extraction (you could add BeautifulSoup for better parsing)
+            content = response.text
+            
+            # Extract title if possible
+            title_start = content.find('<title>')
+            title_end = content.find('</title>')
+            title = "Unknown"
+            if title_start != -1 and title_end != -1:
+                title = content[title_start+7:title_end]
+            
+            # Return basic info
+            result = f"Page Title: {title}\n"
+            result += f"Content Length: {len(content)} characters\n"
+            result += f"First 500 chars: {content[:500]}..."
+            
+            return result
+            
+        except Exception as e:
+            return f"Web scraping error: {str(e)}"
+
 # --- Gemini Model Wrapper ---
 class GeminiModel:
     def __init__(self, model_name="gemini-2.0-flash", temperature=0.0, max_tokens=500):
@@ -187,25 +371,25 @@ class SlpMultiAgent:
             )
             print("Using OpenAI model (Gemini not available)")
         
-        # Create only essential agents with Google Search as first option
+        # Create comprehensive agents with multiple tools
         research_agent = CodeAgent(
-            tools=[GoogleSearchTool(), KnowledgeBaseTool()],  # Google Search first
+            tools=[GoogleSearchTool(), WikipediaSearchTool(), WebScrapeTool(), KnowledgeBaseTool()],
             model=model if not isinstance(model, GeminiModel) else OpenAIServerModel(model_id="gpt-3.5-turbo", temperature=0.0, max_tokens=400),
-            additional_authorized_imports=["re", "datetime"],
-            max_steps=2,
+            additional_authorized_imports=["re", "datetime", "math", "json", "requests", "pandas", "numpy", "time", "os", "tempfile", "uuid"],
+            max_steps=3,
             name="ResearchAgent",
             verbosity_level=0,
-            description="Research agent with Google Search and knowledge lookup."
+            description="Research agent with Google Search, Wikipedia, web scraping, and knowledge lookup."
         )
         
         solver_agent = CodeAgent(
-            tools=[GoogleSearchTool()],  # Add Google Search to solver too
+            tools=[MathTool(), CodeExecutorTool(), FileProcessorTool(), GoogleSearchTool()],
             model=model if not isinstance(model, GeminiModel) else OpenAIServerModel(model_id="gpt-3.5-turbo", temperature=0.0, max_tokens=400),
-            additional_authorized_imports=["math", "re", "collections", "itertools"],
-            max_steps=2,
+            additional_authorized_imports=["math", "re", "collections", "itertools", "pandas", "numpy", "json", "time", "os", "tempfile", "uuid", "requests"],
+            max_steps=3,
             name="SolverAgent",
             verbosity_level=0,
-            description="Problem solving with Google Search capability."
+            description="Problem solving with math, code execution, file processing, and search capabilities."
         )
 
         manager_agent = CodeAgent(
@@ -214,14 +398,14 @@ class SlpMultiAgent:
                 temperature=0.0,
                 max_tokens=500
             ),
-            tools=[GoogleSearchTool(), KnowledgeBaseTool()],  # Google Search first
+            tools=[GoogleSearchTool(), MathTool(), FileProcessorTool(), KnowledgeBaseTool()],
             managed_agents=[research_agent, solver_agent],
             name="ManagerAgent",
-            description="Manager with Google Search and agent coordination.",
-            additional_authorized_imports=["re", "math"],
+            description="Manager with comprehensive tool access and agent coordination.",
+            additional_authorized_imports=["re", "math", "json", "pandas", "numpy", "requests", "time", "os", "tempfile", "uuid"],
             planning_interval=1,
             verbosity_level=0,
-            max_steps=3,
+            max_steps=4,
             final_answer_checks=[check_reasoning]
         )
         
@@ -237,11 +421,24 @@ class SlpMultiAgent:
                     lambda: manager_agent.run(f"""
                     Question: {short_question}
                     
-                    You have google_search() as your PRIMARY tool, plus knowledge_base() and two agents:
-                    - ResearchAgent: For factual questions (has Google Search)
-                    - SolverAgent: For calculations and logic (has Google Search)
+                    IMPORTANT: Use ONLY the available tool functions, do NOT try to call functions directly in code.
+                    
+                    Available tools (call these as functions):
+                    - google_search(query="your search"): Web search (PRIMARY for factual questions)
+                    - math_calculator(expression="your math"): Mathematical calculations  
+                    - file_processor(action="download/save/analyze_csv/analyze_excel", data="url/content/path"): File operations
+                    - knowledge_base(topic="your topic"): Structured knowledge lookup
+                    
+                    Managed agents (delegate to these):
+                    - ResearchAgent: For complex research tasks
+                    - SolverAgent: For complex problem solving
+                    
+                    Strategy:
+                    1. For factual questions: Call google_search() directly
+                    2. For calculations: Call math_calculator() directly
+                    3. For complex tasks: Delegate to appropriate agent
                     
-                    ALWAYS try google_search() FIRST for factual questions before using other tools.
+                    DO NOT write code that calls undefined functions like wikipedia_search().
                     
                     IMPORTANT: Always end with exactly this format:
                     <code>