Update app.py

app.py

@@ -2,6 +2,10 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+import datetime
+import requests
+import pytz
+import yaml
 from transformers import HfAgent
 from bs4 import BeautifulSoup
 import math
@@ -13,6 +17,110 @@ import inspect
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# --- Tool Definitions ---
+def get_current_time_in_timezone(timezone: str) -> str:
+    """A tool that fetches the current local time in a specified timezone.
+    Args:
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+    """
+    try:
+        # Create timezone object
+        tz = pytz.timezone(timezone)
+        # Get current time in that timezone
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+
+def web_search(query: str) -> str:
+    """
+    Performs a web search using DuckDuckGo (via HTML scraping) and returns the text content of the top result snippets.
+    Use this tool to find up-to-date information about events, facts, or topics when the answer isn't already known.
+
+    Args:
+        query (str): The search query string.
+
+    Returns:
+        str: A string containing the summarized search results (titles and snippets of top hits), or an error message if the search fails.
+    """
+    print(f"--- Tool: Executing web_search with query: {query} ---")
+    try:
+        search_url = "https://html.duckduckgo.com/html/"
+        params = {"q": query}
+        headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36'} # Common user agent
+
+        response = requests.post(search_url, data=params, headers=headers, timeout=15) # Increased timeout
+        response.raise_for_status() # Check for HTTP errors (4xx or 5xx)
+
+        soup = BeautifulSoup(response.text, 'html.parser')
+        results = soup.find_all('div', class_='result__body') # Find result containers
+
+        snippets = []
+        for i, result in enumerate(results[:3]): # Get top 3 results for brevity
+            title_tag = result.find('a', class_='result__a')
+            snippet_tag = result.find('a', class_='result__snippet')
+            title = title_tag.get_text(strip=True) if title_tag else "No Title"
+            snippet = snippet_tag.get_text(strip=True) if snippet_tag else "No Snippet"
+            if snippet != "No Snippet": # Only include results with a snippet
+                snippets.append(f"Result {i+1}: {title} - {snippet}")
+
+        if not snippets:
+            return "No search results with relevant snippets found."
+
+        return "\n".join(snippets)
+
+    except requests.exceptions.Timeout:
+        print(f"Error during web search request: Timeout")
+        return "Error: The web search request timed out."
+    except requests.exceptions.RequestException as e:
+        print(f"Error during web search request: {e}")
+        return f"Error: Could not perform web search. Network issue: {e}"
+    except Exception as e:
+        print(f"Error processing web search results: {e}")
+        return f"Error: Could not process search results. {e}"
+
+def safe_calculator(expression: str) -> str:
+    """
+    Evaluates a simple mathematical expression involving numbers, +, -, *, /, %, parentheses, and the math functions: sqrt, pow.
+    Use this tool *only* for calculations. Do not use it to run other code.
+
+    Args:
+        expression (str): The mathematical expression string (e.g., "(2 + 3) * 4", "pow(2, 5)", "sqrt(16)").
+
+    Returns:
+        str: The numerical result of the calculation or a descriptive error message if the expression is invalid or unsafe.
+    """
+    print(f"--- Tool: Executing safe_calculator with expression: {expression} ---")
+    try:
+        # Basic check for allowed characters/patterns first
+        # Allows numbers (including scientific notation), operators, parentheses, whitespace, and known function names
+        pattern = r"^[0-9eE\.\+\-\*\/\%\(\)\s]*(sqrt|pow)?[0-9eE\.\+\-\*\/\%\(\)\s\,]*$"
+        if not re.match(pattern, expression):
+             # Fallback simple pattern check (less precise)
+             allowed_chars_pattern = r"^[0-9eE\.\+\-\*\/\%\(\)\s\,sqrtpow]+$"
+             if not re.match(allowed_chars_pattern, expression):
+                raise ValueError(f"Expression '{expression}' contains disallowed characters.")
+
+        # Define allowed functions/names for eval's context
+        allowed_names = {
+            "sqrt": math.sqrt,
+            "pow": math.pow,
+            # Add other safe math functions if needed e.g. "log": math.log
+        }
+        # Evaluate the expression in a restricted environment
+        # Limited builtins, only allowed names are accessible.
+        result = eval(expression, {"__builtins__": {}}, allowed_names)
+
+        # Ensure the result is a number before converting to string
+        if not isinstance(result, (int, float)):
+             raise ValueError("Calculation did not produce a numerical result.")
+
+        return str(result)
+    except Exception as e:
+        # Catch potential errors during eval (SyntaxError, NameError, TypeError etc.) or from the checks
+        print(f"Error during calculation for '{expression}': {e}")
+        return f"Error calculating '{expression}': Invalid expression or calculation error ({e})."
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent: