app.py

from smolagents import CodeAgent, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
import os
import asyncio
import json
from tools.final_answer import FinalAnswerTool
from tools.web_search import DuckDuckGoSearchTool
from bs4 import BeautifulSoup
from duckduckgo_search import DDGS
import re
from typing import List, Dict, Any

from Gradio_UI import GradioUI

#################################################################
# Below is an example of a tool that does nothing. Amaze us with your creativity !
@tool
def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
    #Keep this format for the description / args / args description but feel free to modify the tool
    """A tool that does nothing yet
    Args:
        arg1: the first argument
        arg2: the second argument
    """
    return "What magic will you build ?"
##############################################################

@tool
def visit_webpage(url: str) -> Dict[str, Any]:
    """Visits a webpage and extracts ingredients and instructions.
    Args:
        url: The recipe URL.
    Returns:
        A dictionary containing 'ingredients' and 'instructions', or an error message if the URL is invalid.
    """
    try:
        # Validate URL format before making a request
        if not url.startswith("http"):
            return {"error": f"Invalid URL format: {url}"}

        response = requests.get(url, timeout=10, headers={
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
        response.raise_for_status()  # Raise an error for 404, 403, etc.

        soup = BeautifulSoup(response.content, 'html.parser')

        # Extract ingredients
        ingredients = [tag.get_text(strip=True) for tag in soup.select('ul li, .ingredient')]
        if not ingredients:
            ingredients = [tag.get_text(strip=True) for tag in soup.find_all('li') if "ingredient" in tag.get_text(strip=True).lower()]

        # Extract instructions
        instructions = [tag.get_text(strip=True) for tag in soup.select('ol li, .instruction, .step')]
        if not instructions:
            instructions = [tag.get_text(strip=True) for tag in soup.find_all('p') if "step" in tag.get_text(strip=True).lower()]

        return {
            "ingredients": ingredients if ingredients else [],
            "instructions": instructions if instructions else []
        }

    except requests.exceptions.HTTPError as http_err:
        return {"error": f"HTTP error {response.status_code}: {http_err}"}

    except requests.exceptions.RequestException as req_err:
        return {"error": f"Request failed: {req_err}"}

    except Exception as e:
        return {"error": f"Failed to scrape {url}: {str(e)}"}

###############################################################

@tool
def web_search(query: str) -> str:
    """Searches the web using DuckDuckGo and formats output in a code block.

    Args:
        query: The search query.

    Returns:
        A string formatted as Python code.
    """
    result = DuckDuckGoSearchTool()(query)

    # 🔹 Ensure the response is wrapped as Python code
    return f"{result}"

###############################################################

@tool
def search_flights(departure: str, destination: str, date: str) -> str:
    """Finds flights from departure to destination on the given date using DuckDuckGo.

    Args:
        departure: The city or airport code where the flight starts.
        destination: The city or airport code where the flight ends.
        date: The departure date in YYYY-MM-DD format.

    Returns:
        A string containing flight search results.
    """
    query = f"flights from {departure} to {destination} on {date}"
    search_results = DuckDuckGoSearchTool()(query)  # Calls DuckDuckGo search
    return f"Here are some flight options:\n{search_results}"

################################################################

API_KEY = os.getenv("FREECURRENCYAPI_KEY")  # 🔹 Your API key

@tool
def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
    """Converts currency from one to another using FreeCurrencyAPI.

    Args:
        amount: The amount to convert.
        from_currency: The original currency (e.g., "USD").
        to_currency: The target currency (e.g., "EUR").

    Returns:
        The converted amount in the target currency.
    """
    try:
        url = f"https://api.freecurrencyapi.com/v1/latest?apikey={API_KEY}&base_currency={from_currency.upper()}"

        response = requests.get(url).json()

        # ✅ Check if the API returned valid exchange rates
        if "data" in response and to_currency.upper() in response["data"]:
            rate = response["data"][to_currency.upper()]
            converted_amount = amount * rate
            return f"{amount} {from_currency.upper()} is approximately {converted_amount:.2f} {to_currency.upper()}."

        return f"Error: Could not find exchange rate for {to_currency.upper()}."

    except Exception as e:
        return f"Error fetching exchange rates: {str(e)}"
########################################################################

chat_history = []  # Store conversation history

@tool
def chat_with_ai(message: str) -> str:
    """A tool that allows the AI to engage in general conversation with memory.
    Args:
        message: The user's message.
    """
    global chat_history

    # Keep the last 5 messages for context
    if len(chat_history) > 5:
        chat_history.pop(0)

    # Add user message to history
    chat_history.append({"role": "user", "content": message})

    # Format the history as input for the AI model
    formatted_history = "\n".join(f"{msg['role']}: {msg['content']}" for msg in chat_history)

    # ✅ Ensure AI response is handled correctly
    try:
        response = model(formatted_history)  # Call model

        # ✅ Handle both string and dictionary responses
        if isinstance(response, dict):
            response_text = response.get("text", str(response))  # Extract text if available
        else:
            response_text = str(response)  # Convert non-dict responses to string

        # Add AI response to history
        chat_history.append({"role": "assistant", "content": response_text})
        return response_text

    except Exception as e:
        return f"Error processing chat: {str(e)}"
#########################################################################

@tool
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)}"
#########################################################################

final_answer = FinalAnswerTool()

########################################################################

# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud'

model = HfApiModel(
max_tokens=512,
temperature=0.5,
model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
custom_role_conversions=None,
)
#deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
#deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B
#Qwen/Qwen2.5-Coder-32B-Instruct
#deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
#oieieio/Qwen2.5-0.5B-Instruct
#oieieio/meta-llama-Llama-3.2-1B-Instruct
###############################################################################





##############################################################################


# web_search settings, specific/custom
hotels = web_search("Recommended hotels in Paris with pricing and location details")
restaurants = web_search("Top-rated local restaurants in Paris, different budgets and cuisines")

# Import tool from Hub
image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)

agent = CodeAgent(
    model=model,
    tools=[
        final_answer,
        get_current_time_in_timezone,
        my_custom_tool,
        chat_with_ai,           # Regular chat tool
        search_flights,
        web_search,
        #scrape_webpage,
        convert_currency,
        #get_weather,
        #generate_ai_image
    ],
    max_steps=8,
    verbosity_level=5,
    prompt_templates=prompt_templates
)

GradioUI(agent).launch()