New try

app.py

@@ -14,6 +14,7 @@ load_dotenv()
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+
 class ToolUsingAgent:
     def __init__(self):
         self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
@@ -25,47 +26,46 @@ class ToolUsingAgent:
         self.file_reader = read_file_tool
 
     def answer(self, question: str, task_id: str = None) -> str:
-        question_lower = question.lower()
-
         try:
-            tool_result = None
-            if "file" in question_lower or "attached" in question_lower:
-                if task_id:
-                    tool_result = self.file_reader.run(task_id)
-                else:
-                    return "[Error: task_id missing for file handling]"
-
-            elif any(k in question_lower for k in ["calculate", "math", "sum", "total", "add", "subtract", "divide", "multiply"]):
-                tool_result = self.calculator.run(question)
-
-            elif any(k in question_lower for k in ["search", "find", "lookup", "look up", "google", "wikipedia", "ioc"]):
-                tool_result = self.web_search.run(question)
-
-            if tool_result:
-                prompt = f"""
-You are an intelligent agent answering questions based on external tools or reasoning. Follow these strict guidelines:
-1. If the question mentions web sources (e.g., Wikipedia, IOC, search), always use the web search tool to find the answer.
-2. If the question refers to a file or attachment, always use the file reading tool to extract data.
-3. If the question is a logic puzzle (e.g., reverse words, decode), reason internally—no tools required.
-4. If the question asks for a specific format (e.g., a single name, city, number, or IOC code), return only that value—no extra text, no explanations.
-5. If you cannot find the answer, say: 'No answer found.'
-6. Do not guess or assume. Always verify using tools if available.
-
-Tool Output: {tool_result}
+            # Step 1: Collect tool results if applicable
+            file_result = None
+            if task_id:
+                file_result = self.file_reader.run(task_id)
+
+            web_result = None
+            if any(kw in question.lower() for kw in ["wikipedia", "search", "google", "find", "ioc", "lookup"]):
+                web_result = self.web_search.run(question)
+
+            calc_result = None
+            if any(kw in question.lower() for kw in ["calculate", "math", "sum", "total", "add", "subtract", "multiply", "divide"]):
+                calc_result = self.calculator.run(question)
+
+            # Step 2: Build tool context dynamically
+            tool_context = ""
+            if file_result:
+                tool_context += f"\nFile content: {file_result}"
+            if web_result:
+                tool_context += f"\nWeb search result: {web_result}"
+            if calc_result:
+                tool_context += f"\nCalculation result: {calc_result}"
+
+            # Step 3: Generate the prompt for LLM
+            prompt = f"""
+You are an expert AI agent solving complex questions. Follow these strict rules:
+1. Use the tools when necessary: web_search, file_reader, calculator.
+2. Combine tools if required for multi-step questions.
+3. Return only the requested format: single name, number, city, or code. No explanations, no extra text.
+4. If you cannot answer, reply exactly: 'No answer found.'
+5. Do not hallucinate or guess.
 
 Question: {question}
-Answer:"""
-            else:
-                prompt = f"""
-You are an intelligent agent answering questions based on external tools or reasoning. Follow these strict guidelines:
-(Same instructions as above)
+{tool_context}
 
-Question: {question}
 Answer:"""
 
-            final_answer = self.query_llm(prompt)
-            expected_format = self.expected_format_detected_from_question(question)
-            return self.clean_output(final_answer, expected_format)
+            response = self.query_llm(prompt)
+            format_type = self.expected_format_detected_from_question(question)
+            return self.clean_output(response, format_type)
 
         except Exception as e:
             return f"[AGENT ERROR: {e}]"
@@ -87,7 +87,7 @@ Answer:"""
             return "city"
         elif "name" in q or "first name" in q or "last name" in q:
             return "name"
-        elif any(w in q for w in ["number", "amount", "how many", "total", "sum", "price", "usd"]):
+        elif any(word in q for word in ["number", "amount", "how many", "total", "sum", "price", "usd"]):
             return "number"
         else:
             return "text"
@@ -96,19 +96,20 @@ Answer:"""
         output = output.strip().strip(' "\'')
         if expected_format == "ioc":
             match = re.search(r'\b[A-Z]{3}\b', output)
-            return match.group(0) if match else "No valid IOC code found"
+            return match.group(0) if match else "No answer found."
         elif expected_format == "city":
             match = re.search(r'\b[A-Z][a-z]+(?: [A-Z][a-z]+)*\b', output)
-            return match.group(0) if match else "No valid city found"
+            return match.group(0) if match else "No answer found."
         elif expected_format == "name":
             match = re.search(r'\b[A-Z][a-z]+\b', output)
-            return match.group(0) if match else "No valid name found"
+            return match.group(0) if match else "No answer found."
         elif expected_format == "number":
             match = re.search(r'\d+(\.\d+)?', output)
-            return match.group(0) if match else "No number found"
+            return match.group(0) if match else "No answer found."
         else:
             return output
 
+
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if profile:

tools/calculator.py

@@ -1,12 +1,47 @@
+import ast
+import operator as op
 from langchain.tools import Tool
 
+operators = {
+    ast.Add: op.add,
+    ast.Sub: op.sub,
+    ast.Mult: op.mul,
+    ast.Div: op.truediv,
+    ast.Pow: op.pow,
+    ast.Mod: op.mod,
+    ast.USub: op.neg,
+}
+
+def safe_eval(expr: str) -> float:
+    """
+    Safely evaluate a mathematical expression string.
+    Supports +, -, *, /, **, %, and negative numbers.
+    """
+    def eval_node(node):
+        if isinstance(node, ast.Num):  # <number>
+            return node.n
+        elif isinstance(node, ast.BinOp):  # <left> <operator> <right>
+            return operators[type(node.op)](eval_node(node.left), eval_node(node.right))
+        elif isinstance(node, ast.UnaryOp):  # <operator> <operand> e.g., -1
+            return operators[type(node.op)](eval_node(node.operand))
+        else:
+            raise TypeError(f"Unsupported type: {node}")
+
+    try:
+        node = ast.parse(expr, mode='eval').body
+        return eval_node(node)
+    except Exception as e:
+        return f"[Calculator error: {e}]"
+
 def calculator(query: str) -> str:
-    """Calculate the result of a mathematical expression"""
-    return eval(query, {"__builtins__": {}})
+    try:
+        result = safe_eval(query)
+        return str(result)
+    except Exception as e:
+        return f"[Calculator error: {e}]"
 
 calculator_tool = Tool.from_function(
     name="calculator",
-    description="Calculate the result of a mathematical expression",
+    description="Performs safe mathematical calculations from a text query. Supports +, -, *, /, %, and powers.",
     func=calculator
-)
-
+)

tools/file_reader.py

@@ -1,8 +1,8 @@
 import requests
 import pandas as pd
-import io
-from io import BytesIO
 import PyPDF2
+import json
+from io import BytesIO
 from langchain.tools import Tool
 
 def read_file(task_id: str) -> str:
@@ -12,38 +12,44 @@ def read_file(task_id: str) -> str:
         response.raise_for_status()
 
         content_type = response.headers.get("Content-Type", "").lower()
+        file_bytes = BytesIO(response.content)
+
+        if "excel" in content_type or task_id.endswith((".xls", ".xlsx")):
+            df = pd.read_excel(file_bytes)
+            return summarize_dataframe(df)
 
-        if "excel" in content_type or task_id.endswith(".xlsx"):
-            df = pd.read_excel(BytesIO(response.content))
-            numeric_cols = df.select_dtypes(include='number').columns
-            if numeric_cols.empty:
-                return df.to_string(index=False, header=True)
-            total = df[numeric_cols].sum().sum()
-            return f"{total:.2f}"
         elif "csv" in content_type or task_id.endswith(".csv"):
-            df = pd.read_csv(BytesIO(response.content))
-            numeric_cols = df.select_dtypes(include='number').columns
-            if numeric_cols.empty:
-                return df.to_string(index=False, header=True)
-            total = df[numeric_cols].sum().sum()
-            return f"{total:.2f}"
+            df = pd.read_csv(file_bytes)
+            return summarize_dataframe(df)
 
         elif "pdf" in content_type or task_id.endswith(".pdf"):
-            pdf = PyPDF2.PdfReader(BytesIO(response.content))
+            pdf = PyPDF2.PdfReader(file_bytes)
             text = "\n".join(page.extract_text() for page in pdf.pages if page.extract_text())
-            return text.strip() if text else "[Error: No text extracted from PDF]"
+            return text.strip() if text else "No text extracted from PDF."
 
-        elif any(task_id.endswith(ext) for ext in [".txt", ".py", ".md", ".json"]):
-            return response.content.decode('utf-8', errors='ignore')
+        elif "json" in content_type or task_id.endswith(".json"):
+            data = json.load(file_bytes)
+            return json.dumps(data, indent=2)
+
+        elif any(task_id.endswith(ext) for ext in [".txt", ".py", ".md"]):
+            return response.content.decode("utf-8", errors="ignore")
 
         else:
-            return response.content.decode('utf-8', errors='ignore')
+            return response.content.decode("utf-8", errors="ignore")
 
     except Exception as e:
         return f"[File reader error: {e}]"
 
+def summarize_dataframe(df: pd.DataFrame) -> str:
+    numeric_cols = df.select_dtypes(include='number').columns
+    if not numeric_cols.empty:
+        total = df[numeric_cols].sum().sum()
+        return f"Total of numeric columns: {total:.2f}"
+    else:
+        return df.head().to_string(index=False)
+
 read_file_tool = Tool.from_function(
     name="read_file",
     description="Reads the content of a file based on the task_id",
     func=read_file
-)
+)

tools/web_searcher.py

@@ -1,52 +1,48 @@
 import requests
 import os
-import re
-from langchain.tools import Tool
 from dotenv import load_dotenv
+from langchain.tools import Tool
 
 load_dotenv()
-
 serper_api_key = os.getenv("SERPER_API_KEY")
 serper_api_url = "https://google.serper.dev/search"
 
 def web_search(query: str) -> str:
     if not serper_api_key:
-        return "Error: SERPER_API_KEY is not set"
+        return "Error: SERPER_API_KEY is not set."
 
     headers = {
         "X-API-KEY": serper_api_key,
         "Content-Type": "application/json"
     }
-    payload = { "q": query }
 
+    payload = { "q": query }
     try:
-        response = requests.post(serper_api_url, headers=headers, json=payload, timeout=10)
+        response = requests.post(serper_api_url, headers=headers, json=payload, timeout=15)
         response.raise_for_status()
         data = response.json()
 
-        # Extract concise answers
-        if data.get("answerBox"):
-            answer = data["answerBox"].get("answer") or data["answerBox"].get("snippet")
-        elif data.get("organic"):
-            answer = data["organic"][0].get("snippet") or data["organic"][0].get("title")
+        results = []
+        if data.get("organic"):
+            for entry in data["organic"]:
+                snippet = entry.get("snippet")
+                link = entry.get("link")
+                if snippet and link:
+                    results.append(f"{snippet} (Source: {link})")
+                elif snippet:
+                    results.append(snippet)
+
+        if results:
+            return "\n".join(results[:5])  
         else:
-            return "No results found"
-
-        # Clean output: remove extra text and punctuation
-        answer = answer.strip()
-        answer = re.sub(r'^(The answer is|Answer:)\s*', '', answer, flags=re.IGNORECASE)
-        answer = answer.strip(' "\'')
-
-        # Optional: Extract only the first sentence or number
-        match = re.match(r'^[^.,;:!?]+', answer)
-        return match.group(0).strip() if match else answer
+            return "No search results found."
 
     except Exception as e:
         return f"[Web search error: {e}]"
 
 web_search_tool = Tool.from_function(
     name="web_search",
-    description="Search the web for concise factual information, like a name, city, or number. Return only the final answer, no explanations.",
+    description="Searches the web using Serper API and provides relevant information.",
     func=web_search
 )