lets give it a go

.gitignore

@@ -1,4 +1,8 @@
 .env
 ragdata/
 chroma_store
-.python-version
+.python-version
+downloads/
+.python_version
+*.jsonl
+*__pycache__/

agent.py

@@ -1,495 +1,296 @@
-import cmath
-import json
-import os
-import re
-import tempfile
-import uuid
-from typing import Any, Dict, List, Optional
-from urllib.parse import urlparse
-
-import numpy as np
-import pandas as pd
-import pytesseract
-import requests
-from code_interpreter import CodeInterpreter
 from dotenv import load_dotenv
-from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
-
-interpreter_instance = CodeInterpreter()
-
-from image_processing import *
-
-"""Langraph"""
-from datasets import load_dataset
-from dotenv import load_dotenv
-from huggingface_hub import login
-from langchain.schema import Document
-from langchain.tools.retriever import create_retriever_tool
-from langchain.vectorstores import Chroma
-from langchain_community.document_loaders import ArxivLoader, WikipediaLoader
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
-from langchain_core.tools import tool
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_groq import ChatGroq
-from langchain_huggingface import HuggingFaceEmbeddings, HuggingFaceEndpoint
-from langgraph.graph import START, MessagesState, StateGraph
-from langgraph.prebuilt import ToolNode, tools_condition
-from supabase.client import Client, create_client
-
-login(token=os.environ["HUGGINGFACE_TOKEN"])
-
-load_dotenv()
-
-
-@tool
-def multiply(a: float, b: float) -> float:
-    """
-    Multiplies two numbers.
-    Args:
-        a (float): the first number
-        b (float): the second number
-    """
-    return a * b
-
-
-@tool
-def add(a: float, b: float) -> float:
-    """
-    Adds two numbers.
-    Args:
-        a (float): the first number
-        b (float): the second number
-    """
-    return a + b
-
-
-@tool
-def subtract(a: float, b: float) -> int:
-    """
-    Subtracts two numbers.
-    Args:
-        a (float): the first number
-        b (float): the second number
-    """
-    return a - b
-
-
-@tool
-def divide(a: float, b: float) -> float:
-    """
-    Divides two numbers.
-    Args:
-        a (float): the first float number
-        b (float): the second float number
-    """
-    if b == 0:
-        raise ValueError("Cannot divided by zero.")
-    return a / b
-
-
-@tool
-def modulus(a: int, b: int) -> int:
-    """
-    Get the modulus of two numbers.
-    Args:
-        a (int): the first number
-        b (int): the second number
-    """
-    return a % b
-
-
-@tool
-def power(a: float, b: float) -> float:
-    """
-    Get the power of two numbers.
-    Args:
-        a (float): the first number
-        b (float): the second number
-    """
-    return a**b
-
-
-@tool
-def square_root(a: float) -> float | complex:
-    """
-    Get the square root of a number.
-    Args:
-        a (float): the number to get the square root of
-    """
-    if a >= 0:
-        return a**0.5
-    return cmath.sqrt(a)
-
-
-### =============== DOCUMENT PROCESSING TOOLS =============== ###
-
-
-@tool
-def save_and_read_file(content: str, filename: Optional[str] = None) -> str:
-    """
-    Save content to a file and return the path.
-    Args:
-        content (str): the content to save to the file
-        filename (str, optional): the name of the file. If not provided, a random name file will be created.
-    """
-    temp_dir = tempfile.gettempdir()
-    if filename is None:
-        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=temp_dir)
-        filepath = temp_file.name
-    else:
-        filepath = os.path.join(temp_dir, filename)
-
-    with open(filepath, "w") as f:
-        f.write(content)
-
-    return f"File saved to {filepath}. You can read this file to process its contents."
-
-
-@tool
-def download_file_from_url(url: str, filename: Optional[str] = None) -> str:
-    """
-    Download a file from a URL and save it to a temporary location.
-    Args:
-        url (str): the URL of the file to download.
-        filename (str, optional): the name of the file. If not provided, a random name file will be created.
-    """
-    try:
-        # Parse URL to get filename if not provided
-        if not filename:
-            path = urlparse(url).path
-            filename = os.path.basename(path)
-            if not filename:
-                filename = f"downloaded_{uuid.uuid4().hex[:8]}"
-
-        # Create temporary file
-        temp_dir = tempfile.gettempdir()
-        filepath = os.path.join(temp_dir, filename)
-
-        # Download the file
-        response = requests.get(url, stream=True)
-        response.raise_for_status()
-
-        # Save the file
-        with open(filepath, "wb") as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-
-        return f"File downloaded to {filepath}. You can read this file to process its contents."
-    except Exception as e:
-        return f"Error downloading file: {str(e)}"
-
-
-@tool
-def extract_text_from_image(image_path: str) -> str:
-    """
-    Extract text from an image using OCR library pytesseract (if available).
-    Args:
-        image_path (str): the path to the image file.
-    """
-    try:
-        # Open the image
-        image = Image.open(image_path)
-
-        # Extract text from the image
-        text = pytesseract.image_to_string(image)
-
-        return f"Extracted text from image:\n\n{text}"
-    except Exception as e:
-        return f"Error extracting text from image: {str(e)}"
-
-
-@tool
-def analyze_csv_file(file_path: str, query: str) -> str:
-    """
-    Analyze a CSV file using pandas and answer a question about it.
-    Args:
-        file_path (str): the path to the CSV file.
-        query (str): Question about the data
-    """
-    try:
-        # Read the CSV file
-        df = pd.read_csv(file_path)
-
-        # Run various analyses based on the query
-        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-
-        # Add summary statistics
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-
-        return result
-
-    except Exception as e:
-        return f"Error analyzing CSV file: {str(e)}"
-
-
-@tool
-def analyze_excel_file(file_path: str, query: str) -> str:
-    """
-    Analyze an Excel file using pandas and answer a question about it.
-    Args:
-        file_path (str): the path to the Excel file.
-        query (str): Question about the data
-    """
-    try:
-        # Read the Excel file
-        df = pd.read_excel(file_path)
-
-        # Run various analyses based on the query
-        result = (
-            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        )
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-
-        # Add summary statistics
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-
-        return result
-
-    except Exception as e:
-        return f"Error analyzing Excel file: {str(e)}"
-
-
-### ============== IMAGE PROCESSING AND GENERATION TOOLS =============== ###
-
-
-@tool
-def wiki_search(query: str) -> str:
-    """Search Wikipedia for a query and return maximum 2 results.
-    Args:
-        query: The search query."""
-    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-            for doc in search_docs
-        ]
-    )
-    return {"wiki_results": formatted_search_docs}
-
-
-@tool
-def web_search(query: str) -> str:
-    """Search Tavily for a query and return maximum 3 results.
-    Args:
-        query: The search query."""
-    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-            for doc in search_docs
-        ]
-    )
-    return {"web_results": formatted_search_docs}
-
-
-@tool
-def arxiv_search(query: str) -> str:
-    """Search Arxiv for a query and return maximum 3 result.
-    Args:
-        query: The search query."""
-    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
-            for doc in search_docs
-        ]
-    )
-    return {"arxiv_results": formatted_search_docs}
-
-
-### =============== CODE INTERPRETER TOOLS =============== ###
-
-
-@tool
-def execute_code_multilang(code: str, language: str = "python") -> str:
-    """Execute code in multiple languages (Python, Bash, SQL, C, Java) and return results.
-    Args:
-        code (str): The source code to execute.
-        language (str): The language of the code. Supported: "python", "bash", "sql", "c", "java".
-    Returns:
-        A string summarizing the execution results (stdout, stderr, errors, plots, dataframes if any).
-    """
-    supported_languages = ["python", "bash", "sql", "c", "java"]
-    language = language.lower()
-
-    if language not in supported_languages:
-        return f"❌ Unsupported language: {language}. Supported languages are: {', '.join(supported_languages)}"
-
-    result = interpreter_instance.execute_code(code, language=language)
+import os
+from typing import Union, List, Dict, Any, Optional, Tuple, Bool
+
+# Import tools from LangChain
+from langchain.agents import get_all_tool_names
+from langchain.agents import load_tools
+
+# Import custom tools
+from Final_Assignment_Template.tools import (
+    ReadFileContentTool,
+    WikipediaSearchTool,
+    VisitWebpageTool,
+    TranscribeAudioTool,
+    TranscibeVideoFileTool,
+    BraveWebSearchTool,
+    DescribeImageTool,
+    ArxivSearchTool,
+    DownloadFileFromLinkTool,
+    DuckDuckGoSearchTool,
+    AddDocumentToVectorStoreTool,
+    QueryVectorStoreTool,
+    image_question_answering
+)
 
-    response = []
+# Import utility functions
+from utils import replace_tool_mentions, extract_final_answer
 
-    if result["status"] == "success":
-        response.append(f"✅ Code executed successfully in **{language.upper()}**")
+# Import SmolaAgents tools
+from smolagents.default_tools import (
+    PythonInterpreterTool,
+    FinalAnswerTool
+)
 
-        if result.get("stdout"):
-            response.append(
-                "\n**Standard Output:**\n```\n" + result["stdout"].strip() + "\n```"
+# Import models from SmolaAgents
+from smolagents import OpenAIServerModel, LiteLLMModel, CodeAgent, HfApiModel
+
+
+class BoomBot:
+    def __init__(self, provider="deepinfra"):
+        """
+        Initialize the BoomBot with the specified provider.
+        
+        Args:
+            provider (str): The model provider to use (e.g., "groq", "qwen", "gemma", "anthropic", "deepinfra", "meta")
+        """
+        load_dotenv()
+        self.provider = provider
+        self.model = self._initialize_model()
+        self.agent = self._create_agent()
+        
+    def _initialize_model(self):
+        """
+        Initialize the appropriate model based on the provider.
+        
+        Returns:
+            The initialized model object
+        """
+        if self.provider == "qwen":
+            qwen_model = "ollama_chat/qwen3:8b"
+            return LiteLLMModel(
+                model_id=qwen_model,
+                device='cuda',
+                num_ctx=32768,
+                temperature=0.6,
+                top_p=0.95
             )
-
-        if result.get("stderr"):
-            response.append(
-                "\n**Standard Error (if any):**\n```\n"
-                + result["stderr"].strip()
-                + "\n```"
+        elif self.provider == "gemma":
+            gemma_model = "ollama_chat/gemma3:12b-it-qat"
+            return LiteLLMModel(
+                model_id=gemma_model,
+                num_ctx=65536,
+                temperature=1.0,
+                device='cuda',
+                top_k=64,
+                top_p=0.95,
+                min_p=0.0
             )
-
-        if result.get("result") is not None:
-            response.append(
-                "\n**Execution Result:**\n```\n"
-                + str(result["result"]).strip()
-                + "\n```"
+        elif self.provider == "anthropic":
+            model_id = "anthropic/claude-3-5-sonnet-latest"
+            return LiteLLMModel(
+                model_id=model_id,
+                temperature=0.6,
+                max_tokens=8192
             )
-
-        if result.get("dataframes"):
-            for df_info in result["dataframes"]:
-                response.append(
-                    f"\n**DataFrame `{df_info['name']}` (Shape: {df_info['shape']})**"
-                )
-                df_preview = pd.DataFrame(df_info["head"])
-                response.append("First 5 rows:\n```\n" + str(df_preview) + "\n```")
-
-        if result.get("plots"):
-            response.append(
-                f"\n**Generated {len(result['plots'])} plot(s)** (Image data returned separately)"
+        elif self.provider == "deepinfra":
+            deepinfra_model = "Qwen/Qwen3-235B-A22B"
+            return OpenAIServerModel(
+                model_id=deepinfra_model,
+                api_base="https://api.deepinfra.com/v1/openai",
+                api_key=os.environ["DEEPINFRA_API_KEY"],
+                flatten_messages_as_text=True,
+                max_tokens=8192,
+                temperature=0.1
             )
-
-    else:
-        response.append(f"❌ Code execution failed in **{language.upper()}**")
-        if result.get("stderr"):
-            response.append(
-                "\n**Error Log:**\n```\n" + result["stderr"].strip() + "\n```"
+        elif self.provider == "meta":
+            meta_model = "meta-llama/Llama-3.3-70B-Instruct-Turbo"
+            return OpenAIServerModel(
+                model_id=meta_model,
+                api_base="https://api.deepinfra.com/v1/openai",
+                api_key=os.environ["DEEPINFRA_API_KEY"],
+                flatten_messages_as_text=True,
+                max_tokens=8192,
+                temperature=0.7
             )
-
-    return "\n".join(response)
-
-
-system_prompt = """You are a helpful assistant tasked with answering questions using a set of tools. 
-Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
-FINAL ANSWER: [YOUR FINAL ANSWER]. 
-YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
-Your answer should only start with "FINAL ANSWER: ", then follows with the answer. """
-
-# System message
-sys_msg = SystemMessage(content=system_prompt)
-
-# build a retriever
-embeddings = HuggingFaceEmbeddings(
-    model_name="sentence-transformers/all-mpnet-base-v2"
-)  #  dim=768
-
-# Load the GAIA validation dataset
-dataset = load_dataset(
-    "gaia-benchmark/GAIA",
-    name="2023_level1",
-    split="validation",
-    trust_remote_code=True,
-    cache_dir="ragdata",
-)
-
-# Extract questions and their answers
-documents = []
-for entry in dataset:
-    question = entry["Question"]
-    answer = entry["Final answer"]
-
-    # Create a document with both the question and the answer as metadata
-    metadata = {
-        "task_id": entry["task_id"],
-        "steps": entry["Annotator Metadata"]["Steps"],
-        "tools": entry["Annotator Metadata"]["Tools"],
-        "answer": answer,
-    }
-
-    # Add the question to the list of documents
-    documents.append(Document(page_content=question, metadata=metadata))
-
-# Insert the documents into Chroma
-vector_store = Chroma.from_documents(
-    documents=documents,
-    embedding=embeddings,
-    collection_name="gaia_validation",
-    persist_directory="./chroma_store",
-)
-
-create_retriever_tool = create_retriever_tool(
-    retriever=vector_store.as_retriever(),
-    name="Question Search",
-    description="A tool to retrieve similar questions from a vector store.",
-)
-
-
-tools = [
-    web_search,
-    wiki_search,
-    arxiv_search,
-    multiply,
-    add,
-    subtract,
-    divide,
-    modulus,
-    power,
-    square_root,
-    save_and_read_file,
-    download_file_from_url,
-    extract_text_from_image,
-    analyze_csv_file,
-    analyze_excel_file,
-    execute_code_multilang,
-]
-
-
-# Build graph function
-def build_graph(provider: str = "groq"):
-    """Build the graph"""
-    # Load environment variables from .env file
-    if provider == "google":
-        # Google Gemini
-        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
-    elif provider == "groq":
-        # Groq https://console.groq.com/docs/models
-        llm = ChatGroq(
-            model="qwen-qwq-32b", temperature=0
-        )  # optional : qwen-qwq-32b gemma2-9b-it
-    elif provider == "huggingface":
-        # TODO: Add huggingface endpoint
-        llm = HuggingFaceEndpoint(
-            repo_id="Meta-DeepLearning/llama-2-7b-chat-hf",
-            temperature=0,
-        )
-    else:
-        raise ValueError("Invalid provider. Choose 'google', 'groq' or 'huggingface'.")
-    # Bind tools to LLM
-    llm_with_tools = llm.bind_tools(tools)
-
-    # Node
-    def assistant(state: MessagesState):
-        """Assistant node"""
-        return {"messages": [llm_with_tools.invoke(state["messages"])]}
-
-    def retriever(state: MessagesState):
-        """Retriever node"""
-        similar_question = vector_store.similarity_search(state["messages"][0].content)
-        example_msg = HumanMessage(
-            content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+        elif self.provider == "groq":
+            # Default to use groq's claude-3-opus or llama-3
+            model_id = "claude-3-opus-20240229"
+            return LiteLLMModel(
+                model_id=model_id,
+                temperature=0.7,
+                max_tokens=8192
+            )
+        else:
+            raise ValueError(f"Unsupported provider: {self.provider}")
+    
+    def _create_agent(self):
+        """
+        Create and configure the agent with all necessary tools.
+        
+        Returns:
+            The configured CodeAgent
+        """
+        # Initialize tools
+        download_file = DownloadFileFromLinkTool()
+        read_file_content = ReadFileContentTool()
+        visit_webpage = VisitWebpageTool()
+        transcribe_video = TranscibeVideoFileTool()
+        transcribe_audio = TranscribeAudioTool()
+        get_wikipedia_info = WikipediaSearchTool()
+        web_searcher = DuckDuckGoSearchTool()
+        arxiv_search = ArxivSearchTool()
+        add_doc_vectorstore = AddDocumentToVectorStoreTool()
+        retrieve_doc_vectorstore = QueryVectorStoreTool()
+        
+        # SmolaAgents default tools
+        python_interpreter = PythonInterpreterTool()
+        final_answer = FinalAnswerTool()
+        
+        # Combine all tools
+        agent_tools = [
+            web_searcher,
+            download_file,
+            read_file_content,
+            visit_webpage,
+            transcribe_video,
+            transcribe_audio,
+            get_wikipedia_info,
+            arxiv_search,
+            add_doc_vectorstore,
+            retrieve_doc_vectorstore,
+            python_interpreter,
+            final_answer
+        ]
+        
+        # Additional imports for the Python interpreter
+        additional_imports = [
+            "json",
+            "os",
+            "glob",
+            "pathlib",
+            "pandas",
+            "numpy",
+            "matplotlib",
+            "seaborn",
+            "sklearn",
+            "tqdm",
+            "argparse",
+            "pickle",
+            "io",
+            "re",
+            "datetime",
+            "collections",
+            "math",
+            "random",
+            "csv",
+            "zipfile",
+            "itertools",
+            "functools",
+        ]
+        
+        # Create the agent
+        agent = CodeAgent(
+            tools=agent_tools,
+            max_steps=12,
+            model=self.model,
+            add_base_tools=False,
+            stream_outputs=True,
+            additional_authorized_imports=additional_imports
         )
-        return {"messages": [sys_msg] + state["messages"] + [example_msg]}
-
-    builder = StateGraph(MessagesState)
-    builder.add_node('retriever', retriever)
-    builder.add_node('assistant', assistant)
-    builder.add_node('tools', ToolNode(tools))
-
-    builder.add_edge(START, 'retriever')
-    builder.add_edge('retriever', 'assistant')
-    builder.add_conditional_edges('assistant', tools_condition)
-    builder.add_edge('tools', 'assistant')
-
-    graph = builder.compile()
-
-    return graph
+        
+        # Modify the system prompt
+        modified_prompt = replace_tool_mentions(agent.system_prompt)
+        agent.system_prompt = modified_prompt + self._get_system_prompt()
+        
+        return agent
+    
+    def _get_system_prompt(self):
+        """
+        Return the system prompt for the agent.
+        
+        Returns:
+            str: The system prompt
+        """
+        return """
+        YOUR BEHAVIOR GUIDELINES:
+          • Do NOT make unfounded assumptions—always ground answers in reliable sources or search results.
+          • For math or puzzles: break the problem into code/math, then solve programmatically.
+        
+        RESEARCH WORKFLOW (in rough priority order):
+          1. SEARCH  
+             - Try web_search, wikipedia_search, or arxiv_search first.  
+             - Refine your query rather than repeating the exact same terms.  
+             - If one search tool yields insufficient info, switch to another before downloading.
+          2. VISIT  
+             - Use visit_webpage to extract and read page content when a promising link appears after one of the SEARCH tools.
+             - For each visited link, also download the file and add to the vector store, you might need to query this later, especially if you have a lot of search results.
+          3. EVALUATE  
+             - ✅ If the page or search snippet fully answers the question, respond immediately.  
+             - ❌ If not, move on to deeper investigation.
+          4. DOWNLOAD  
+             - Use download_file_from_link tool on relevant links found (yes you can download webpages as html).  
+             - For arXiv papers, target the /pdf/ or DOI link (e.g https://arxiv.org/pdf/2011.10672).
+             - 
+          5. INDEX & QUERY  
+             - Add downloaded documents to the vector store with add_document_to_vector_store.  
+             - Use query_downloaded_documents for detailed answers.
+          6. READ
+             - You have access to a read_file_content tool to read most types of files. You can also directly interact with downloaded files in your python code (do this for csv files and excel files)
+        
+             
+        FALLBACK & ADAPTATION:
+          • If a tool fails, reformulate your query or try a different search method before dropping to download.
+          • If a tool fails multiple times, try a different tool.
+          • For arXiv: you might discover a paper link via web_search tool and then directly use download_file_from_link tool
+        
+        COMMON TOOL CHAINS (conceptual outlines):
+        These are just guidelines, each task might require a unique workflow.
+        A tool can provide useful information for the task, it will not always contain the answer. You need to work to get to a final_answer that makes sense.
+        
+          • FACTUAL Qs:  
+              web_search → final_answer  
+          • CURRENT EVENTS:  
+              To have some summary information use web_search, that might output a promising website to visit and read content from using (visit_webpage or download_file_from_link and read_file_content)
+              web_search → visit_webpage → final_answer  
+          • DOCUMENT-BASED Qs:  
+              web_search → download_file_from_link → add_document_to_vector_store → query_downloaded_documents → final_answer  
+          • ARXIV PAPERS:  
+              The arxiv search tool provides a list of results with summary content, to inspect the whole paper you need to download it with download_file_from_link tool.
+              arxiv_search → download_file_from_link → read_file_content
+              If that fails
+              arxiv_search → download_file_from_link → add_document_to_vector_store → query_downloaded_documents  
+          • MEDIA ANALYSIS:  
+              download_file_from_link → transcribe_video/transcribe_audio/describe_image → final_answer
+        
+        FINAL ANSWER FORMAT:
+          - Begin with "FINAL ANSWER: "  
+          - Number → digits only (e.g., 42)  
+          - String → exact text (e.g., Pope Francis)  
+          - List → comma-separated, one space (e.g., 2, 3, 4)  
+          - Conclude with: FINAL ANSWER: <your_answer>
+        """
+    
+    def run(self, question: str, task_id: str, to_download: Bool) -> str:
+        """
+        Run the agent with the given question, task_id, and download flag.
+        
+        Args:
+            question (str): The question or task for the agent to process
+            task_id (str): A unique identifier for the task
+            to_download (Bool): Flag indicating whether to download resources
+            
+        Returns:
+            str: The agent's response
+        """
+        print(f"BoomBot running with question (first 50 chars): {question[:50]}...")
+        
+        # Configure any task-specific settings based on the parameters
+        if to_download:
+            # You could set up specific agent configurations here for download tasks
+            pass
+            
+        # Run the agent with the given question
+        result = self.agent.generate_response(question)
+        
+        # Extract the final answer from the result
+        final_answer = extract_final_answer(result)
+        
+        return final_answer
+
+
+# Example of how to use this code (commented out)
+# if __name__ == "__main__":
+#     agent = BasicAgent()
+#     response = agent("What is the current population of Tokyo?", "population_query", True)
+#     print(f"Response: {response}")

app.py

@@ -5,29 +5,25 @@ import gradio as gr
 import pandas as pd
 import requests
 from langchain_core.messages import HumanMessage
+from traitlets import Bool # type: ignore
 
-from agent import build_graph
+from agent import BoomBot
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
+# --- Basic Agent Definition --
 # --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        self.graph = build_graph(provider = "groq")
-    def __call__(self, question: str) -> str:
+        self.agent = BoomBot(provider="groq")
+        
+    def __call__(self, question: str, task_id: str, to_download: Bool) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        # fixed_answer = "This is a default answer."
-        # print(f"Agent returning fixed answer: {fixed_answer}")
-        # return fixed_answer
-        messages = [HumanMessage(content=question)]
-        messages = self.graph.invoke({'messages': messages})
-        ans = messages['messages'][-1].content
-        return ans[14:]
+        return self.agent.run(question, task_id, to_download)
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
@@ -86,11 +82,18 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
+        file_name = item.get("file_name", "")
+
+        if file_name.strip() != "":
+            to_download = True
+        else:
+            to_download = False
+
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text, task_id, to_download = to_download)
             answers_payload.append(
                 {"task_id": task_id, "submitted_answer": submitted_answer}
             )

cocolabelmap.py

@@ -0,0 +1,186 @@
+LABEL_MAP = {
+    0: "unlabeled",
+    1: "person",
+    2: "bicycle",
+    3: "car",
+    4: "motorcycle",
+    5: "airplane",
+    6: "bus",
+    7: "train",
+    8: "truck",
+    9: "boat",
+    10: "traffic",
+    11: "fire",
+    12: "street",
+    13: "stop",
+    14: "parking",
+    15: "bench",
+    16: "bird",
+    17: "cat",
+    18: "dog",
+    19: "horse",
+    20: "sheep",
+    21: "cow",
+    22: "elephant",
+    23: "bear",
+    24: "zebra",
+    25: "giraffe",
+    26: "hat",
+    27: "backpack",
+    28: "umbrella",
+    29: "shoe",
+    30: "eye",
+    31: "handbag",
+    32: "tie",
+    33: "suitcase",
+    34: "frisbee",
+    35: "skis",
+    36: "snowboard",
+    37: "sports",
+    38: "kite",
+    39: "baseball",
+    40: "baseball",
+    41: "skateboard",
+    42: "surfboard",
+    43: "tennis",
+    44: "bottle",
+    45: "plate",
+    46: "wine",
+    47: "cup",
+    48: "fork",
+    49: "knife",
+    50: "spoon",
+    51: "bowl",
+    52: "banana",
+    53: "apple",
+    54: "sandwich",
+    55: "orange",
+    56: "broccoli",
+    57: "carrot",
+    58: "hot",
+    59: "pizza",
+    60: "donut",
+    61: "cake",
+    62: "chair",
+    63: "couch",
+    64: "potted",
+    65: "bed",
+    66: "mirror",
+    67: "dining",
+    68: "window",
+    69: "desk",
+    70: "toilet",
+    71: "door",
+    72: "tv",
+    73: "laptop",
+    74: "mouse",
+    75: "remote",
+    76: "keyboard",
+    77: "cell",
+    78: "microwave",
+    79: "oven",
+    80: "toaster",
+    81: "sink",
+    82: "refrigerator",
+    83: "blender",
+    84: "book",
+    85: "clock",
+    86: "vase",
+    87: "scissors",
+    88: "teddy",
+    89: "hair",
+    90: "toothbrush",
+    91: "hair",
+    92: "banner",
+    93: "blanket",
+    94: "branch",
+    95: "bridge",
+    96: "building",
+    97: "bush",
+    98: "cabinet",
+    99: "cage",
+    100: "cardboard",
+    101: "carpet",
+    102: "ceiling",
+    103: "ceiling",
+    104: "cloth",
+    105: "clothes",
+    106: "clouds",
+    107: "counter",
+    108: "cupboard",
+    109: "curtain",
+    110: "desk",
+    111: "dirt",
+    112: "door",
+    113: "fence",
+    114: "floor",
+    115: "floor",
+    116: "floor",
+    117: "floor",
+    118: "floor",
+    119: "flower",
+    120: "fog",
+    121: "food",
+    122: "fruit",
+    123: "furniture",
+    124: "grass",
+    125: "gravel",
+    126: "ground",
+    127: "hill",
+    128: "house",
+    129: "leaves",
+    130: "light",
+    131: "mat",
+    132: "metal",
+    133: "mirror",
+    134: "moss",
+    135: "mountain",
+    136: "mud",
+    137: "napkin",
+    138: "net",
+    139: "paper",
+    140: "pavement",
+    141: "pillow",
+    142: "plant",
+    143: "plastic",
+    144: "platform",
+    145: "playingfield",
+    146: "railing",
+    147: "railroad",
+    148: "river",
+    149: "road",
+    150: "rock",
+    151: "roof",
+    152: "rug",
+    153: "salad",
+    154: "sand",
+    155: "sea",
+    156: "shelf",
+    157: "sky",
+    158: "skyscraper",
+    159: "snow",
+    160: "solid",
+    161: "stairs",
+    162: "stone",
+    163: "straw",
+    164: "structural",
+    165: "table",
+    166: "tent",
+    167: "textile",
+    168: "towel",
+    169: "tree",
+    170: "vegetable",
+    171: "wall",
+    172: "wall",
+    173: "wall",
+    174: "wall",
+    175: "wall",
+    176: "wall",
+    177: "wall",
+    178: "water",
+    179: "waterdrops",
+    180: "window",
+    181: "window",
+    182: "wood"
+}
+

example_gaiaqa.json

@@ -0,0 +1,122 @@
+[
+  {
+    "task_id": "8e867cd7-cff9-4e6c-867a-ff5ddc2550be",
+    "Question": "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "a1e91b78-d3d8-4675-bb8d-62741b4b68a6",
+    "Question": "In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "2d83110e-a098-4ebb-9987-066c06fa42d0",
+    "Question": ".rewsna eht sa \"tfel\" drow eht fo etisoppo eht etirw ,ecnetnes siht dnatsrednu uoy fI",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "cca530fc-4052-43b2-b130-b30968d8aa44",
+    "Question": "Review the chess position provided in the image. It is black's turn. Provide the correct next move for black which guarantees a win. Please provide your response in algebraic notation.",
+    "Level": "1",
+    "file_name": "cca530fc-4052-43b2-b130-b30968d8aa44.png"
+  },
+  {
+    "task_id": "4fc2f1ae-8625-45b5-ab34-ad4433bc21f8",
+    "Question": "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "6f37996b-2ac7-44b0-8e68-6d28256631b4",
+    "Question": "Given this table defining * on the set S = {a, b, c, d, e}\n\n|*|a|b|c|d|e|\n|---|---|---|---|---|---|\n|a|a|b|c|b|d|\n|b|b|c|a|e|c|\n|c|c|a|b|b|a|\n|d|b|e|b|e|d|\n|e|d|b|a|d|c|\n\nprovide the subset of S involved in any possible counter-examples that prove * is not commutative. Provide your answer as a comma separated list of the elements in the set in alphabetical order.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "9d191bce-651d-4746-be2d-7ef8ecadb9c2",
+    "Question": "Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec.\n\nWhat does Teal'c say in response to the Question \"Isn't that hot?\"",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "cabe07ed-9eca-40ea-8ead-410ef5e83f91",
+    "Question": "What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "3cef3a44-215e-4aed-8e3b-b1e3f08063b7",
+    "Question": "I'm making a grocery list for my mom, but she's a professor of botany and she's a real stickler when it comes to categorizing things. I need to add different foods to different categories on the grocery list, but if I make a mistake, she won't buy anything inserted in the wrong category. Here's the list I have so far:\n\nmilk, eggs, flour, whole bean coffee, Oreos, sweet potatoes, fresh basil, plums, green beans, rice, corn, bell pepper, whole allspice, acorns, broccoli, celery, zucchini, lettuce, peanuts\n\nI need to make headings for the fruits and vegetables. Could you please create a list of just the vegetables from my list? If you could do that, then I can figure out how to categorize the rest of the list into the appropriate categories. But remember that my mom is a real stickler, so make sure that no botanical fruits end up on the vegetable list, or she won't get them when she's at the store. Please alphabetize the list of vegetables, and place each item in a comma separated list.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3",
+    "Question": "Hi, I'm making a pie but I could use some help with my shopping list. I have everything I need for the crust, but I'm not sure about the filling. I got the recipe from my friend Aditi, but she left it as a voice memo and the speaker on my phone is buzzing so I can't quite make out what she's saying. Could you please listen to the recipe and list all of the ingredients that my friend described? I only want the ingredients for the filling, as I have everything I need to make my favorite pie crust. I've attached the recipe as Strawberry pie.mp3.\n\nIn your response, please only list the ingredients, not any measurements. So if the recipe calls for \"a pinch of salt\" or \"two cups of ripe strawberries\" the ingredients on the list would be \"salt\" and \"ripe strawberries\".\n\nPlease format your response as a comma separated list of ingredients. Also, please alphabetize the ingredients.",
+    "Level": "1",
+    "file_name": "99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3"
+  },
+  {
+    "task_id": "305ac316-eef6-4446-960a-92d80d542f82",
+    "Question": "Who did the actor who played Ray in the Polish-language version of Everybody Loves Raymond play in Magda M.? Give only the first name.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "f918266a-b3e0-4914-865d-4faa564f1aef",
+    "Question": "What is the final numeric output from the attached Python code?",
+    "Level": "1",
+    "file_name": "f918266a-b3e0-4914-865d-4faa564f1aef.py"
+  },
+  {
+    "task_id": "3f57289b-8c60-48be-bd80-01f8099ca449",
+    "Question": "How many at bats did the Yankee with the most walks in the 1977 regular season have that same season?",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "1f975693-876d-457b-a649-393859e79bf3",
+    "Question": "Hi, I was out sick from my classes on Friday, so I'm trying to figure out what I need to study for my Calculus mid-term next week. My friend from class sent me an audio recording of Professor Willowbrook giving out the recommended reading for the test, but my headphones are broken :(\n\nCould you please listen to the recording for me and tell me the page numbers I'm supposed to go over? I've attached a file called Homework.mp3 that has the recording. Please provide just the page numbers as a comma-delimited list. And please provide the list in ascending order.",
+    "Level": "1",
+    "file_name": "1f975693-876d-457b-a649-393859e79bf3.mp3"
+  },
+  {
+    "task_id": "840bfca7-4f7b-481a-8794-c560c340185d",
+    "Question": "On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "bda648d7-d618-4883-88f4-3466eabd860e",
+    "Question": "Where were the Vietnamese specimens described by Kuznetzov in Nedoshivina's 2010 paper eventually deposited? Just give me the city name without abbreviations.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "cf106601-ab4f-4af9-b045-5295fe67b37d",
+    "Question": "What country had the least number of athletes at the 1928 Summer Olympics? If there's a tie for a number of athletes, return the first in alphabetical order. Give the IOC country code as your answer.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "a0c07678-e491-4bbc-8f0b-07405144218f",
+    "Question": "Who are the pitchers with the number before and after Taishō Tamai's number as of July 2023? Give them to me in the form Pitcher Before, Pitcher After, use their last names only, in Roman characters.",
+    "Level": "1",
+    "file_name": ""
+  },
+  {
+    "task_id": "7bd855d8-463d-4ed5-93ca-5fe35145f733",
+    "Question": "The attached Excel file contains the sales of menu items for a local fast-food chain. What were the total sales that the chain made from food (not including drinks)? Express your answer in USD with two decimal places.",
+    "Level": "1",
+    "file_name": "7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx"
+  },
+  {
+    "task_id": "5a0c1adf-205e-4841-a666-7c3ef95def9d",
+    "Question": "What is the first name of the only Malko Competition recipient from the 20th Century (after 1977) whose nationality on record is a country that no longer exists?",
+    "Level": "1",
+    "file_name": ""
+  }
+]

langtools.py

@@ -0,0 +1,104 @@
+import os
+from dotenv import load_dotenv
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+from langchain_core.tools import tool
+
+
+load_dotenv()
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers.
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> int:
+    """Divide two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b
+
+@tool
+def wiki_search(query: str) -> str:
+    """Tool to search Wikipedia for a query about a known or historical person or subject and return maximum 2 results.
+    
+    Args:
+        query: The search query."""
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ])
+    return {"wiki_results": formatted_search_docs}
+
+@tool
+def web_search(query: str) -> str:
+    """Search Tavily for a query and return maximum 3 results.
+    
+    Args:
+        query: The search query."""
+    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ])
+    return {"web_results": formatted_search_docs}
+
+@tool
+def arvix_search(query: str) -> str:
+    """Tool to search Arxiv for a query about a research paper or article and return maximum 3 results.
+    
+    Args:
+        query: The search query."""
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    # formatted_search_docs = "\n\n---\n\n".join(
+    #     [
+    #         f'<Document source="{doc.metadata.get("source", None)}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+    #         for doc in search_docs
+    #     ])
+    # return {"arvix_results": formatted_search_docs}
+    return search_docs
+

tools copy.py

@@ -0,0 +1,352 @@
+import os
+import re
+import tempfile
+import mimetypes
+import requests
+import pandas as pd
+import fitz  # PyMuPDF
+from urllib.parse import unquote
+from smolagents import Tool
+from smolagents import Tool
+import requests
+import traceback
+from langchain_community.retrievers import BM25Retriever
+from smolagents import Tool
+import math
+
+class DownloadFileFromTaskTool(Tool):
+    name = "download_file_from_task"
+    description = """Downloads a file for a GAIA task ID and saves it in a temporary directory. 
+    Use this when question requires information from a mentioned file, before reading a file."""
+
+    inputs = {
+        "task_id": {
+            "type": "string",
+            "description": "The GAIA task ID (REQUIRED)."
+        },
+        "filename": {
+            "type": "string",
+            "description": "Optional custom filename to save the file as (e.g., 'data.xlsx').",
+            "nullable": True
+        }
+    }
+    output_type = "string"
+
+    def forward(self, task_id: str, filename: str = None) -> str:
+        if not task_id or not re.match(r"^[0-9a-f\-]{36}$", task_id):
+            return "❌ Invalid or missing task_id."
+
+        file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+        try:
+            response = requests.get(file_url, timeout=15)
+            if response.status_code == 404:
+                return "⚠️ No file found for this task."
+            response.raise_for_status()
+
+            # Try extracting filename and extension from header
+            disposition = response.headers.get("content-disposition", "")
+            header_filename_match = re.search(r'filename="(.+?)"', disposition)
+            ext = ""
+            if header_filename_match:
+                ext = os.path.splitext(header_filename_match.group(1))[1]
+
+            # Final filename logic
+            if not filename:
+                filename = f"{task_id}{ext or '.bin'}"
+
+            temp_dir = tempfile.mkdtemp()
+            file_path = os.path.join(temp_dir, filename)
+
+            with open(file_path, "wb") as f:
+                f.write(response.content)
+
+            print(f"File saved at: {file_path}")
+            return file_path
+        except Exception as e:
+            return f"❌ Error: {e}"
+
+class ReadFileContentTool(Tool):
+    name = "read_file_content"
+    description = """Reads and returns the content of a file. Use after downloading a file using `download_file_from_task`."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Full path to a file to read."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        if not os.path.exists(file_path):
+            return f"❌ File does not exist: {file_path}"
+
+        ext = os.path.splitext(file_path)[1].lower()
+
+        try:
+            if ext == ".txt":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return f.read()
+
+            elif ext == ".csv":
+                df = pd.read_csv(file_path)
+                return df.head().to_string(index=False)
+
+            elif ext == ".xlsx":
+                df = pd.read_excel(file_path)
+                return df.head().to_string(index=False)
+
+            elif ext == ".pdf":
+                doc = fitz.open(file_path)
+                text = ""
+                for page in doc:
+                    text += page.get_text()
+                doc.close()
+                return text.strip() or "⚠️ PDF contains no readable text."
+
+            elif ext == ".json":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return f.read()
+
+            elif ext == ".py":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return f.read()
+
+            elif ext in [".mp3", ".wav"]:
+                return f"ℹ️ Audio file detected: {os.path.basename(file_path)}. Use audio processing tool if needed."
+
+            elif ext in [".mp4", ".mov", ".avi"]:
+                return f"ℹ️ Video file detected: {os.path.basename(file_path)}. Use video analysis tool if available."
+
+            else:
+                return f"ℹ️ Unsupported file type: {ext}. File saved at {file_path}"
+
+        except Exception as e:
+            return f"❌ Could not read {file_path}: {e}"
+
+class GetWikipediaInfoTool(Tool):
+    name = "get_wikipedia_info"
+    description = """Fetches a short summary about a topic from Wikipedia.
+Use this when a user asks for background information, an explanation, or context on a well-known subject."""
+    
+    inputs = {
+        "topic": {
+            "type": "string",
+            "description": "The topic to search for on Wikipedia."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, topic: str) -> str:
+        print(f"EXECUTING TOOL: get_wikipedia_info(topic='{topic}')")
+        try:
+            search_url = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={topic}&format=json"
+            search_response = requests.get(search_url, timeout=10)
+            search_response.raise_for_status()
+            search_data = search_response.json()
+
+            if not search_data.get('query', {}).get('search', []):
+                return f"No Wikipedia info for '{topic}'."
+
+            page_id = search_data['query']['search'][0]['pageid']
+
+            content_url = (
+                f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
+                f"exintro=1&explaintext=1&pageids={page_id}&format=json"
+            )
+            content_response = requests.get(content_url, timeout=10)
+            content_response.raise_for_status()
+            content_data = content_response.json()
+
+            extract = content_data['query']['pages'][str(page_id)]['extract']
+            if len(extract) > 1500:
+                extract = extract[:1500] + "..."
+
+            result = f"Wikipedia summary for '{topic}':\n{extract}"
+            print(f"-> Tool Result (Wikipedia): {result[:100]}...")
+            return result
+
+        except Exception as e:
+            print(f"❌ Error in get_wikipedia_info: {e}")
+            traceback.print_exc()
+            return f"Error wiki: {e}"
+
+class VisitWebpageTool(Tool):
+    name = "visit_webpage"
+    description = """
+    Visits a given URL and returns structured page content including title, metadata, headings, paragraphs,
+    tables, lists, and links.
+    """
+
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "The full URL of the webpage to visit."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, url: str) -> str:
+        try:
+            import requests
+            from bs4 import BeautifulSoup
+            import json
+
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            def clean(text):
+                return ' '.join(text.strip().split())
+
+            def extract_tables(soup):
+                tables_data = []
+                for table in soup.find_all("table"):
+                    headers = [clean(th.get_text()) for th in table.find_all("th")]
+                    rows = []
+                    for row in table.find_all("tr"):
+                        cells = [clean(td.get_text()) for td in row.find_all("td")]
+                        if cells:
+                            rows.append(cells)
+                    if headers and rows:
+                        tables_data.append({"headers": headers, "rows": rows})
+                return tables_data
+
+            def extract_lists(soup):
+                all_lists = []
+                for ul in soup.find_all("ul"):
+                    items = [clean(li.get_text()) for li in ul.find_all("li")]
+                    if items:
+                        all_lists.append(items)
+                for ol in soup.find_all("ol"):
+                    items = [clean(li.get_text()) for li in ol.find_all("li")]
+                    if items:
+                        all_lists.append(items)
+                return all_lists
+
+            def extract_meta(soup):
+                metas = {}
+                for meta in soup.find_all("meta"):
+                    name = meta.get("name") or meta.get("property")
+                    content = meta.get("content")
+                    if name and content:
+                        metas[name.lower()] = clean(content)
+                return metas
+
+            result = {
+                "title": clean(soup.title.string) if soup.title else None,
+                "meta": extract_meta(soup),
+                "headings": {
+                    "h1": [clean(h.get_text()) for h in soup.find_all("h1")],
+                    "h2": [clean(h.get_text()) for h in soup.find_all("h2")],
+                    "h3": [clean(h.get_text()) for h in soup.find_all("h3")],
+                },
+                "paragraphs": [clean(p.get_text()) for p in soup.find_all("p")],
+                "lists": extract_lists(soup),
+                "tables": extract_tables(soup),
+                "links": [
+                    {"text": clean(a.get_text()), "href": a["href"]}
+                    for a in soup.find_all("a", href=True)
+                ],
+            }
+
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            return f"❌ Failed to fetch or parse webpage: {str(e)}"
+        
+class TranscribeAudioTool(Tool):
+    name = "transcribe_audio"
+    description = """Transcribes spoken audio (e.g. voice memos, lectures) into plain text."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to an audio file."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            import speech_recognition as sr
+            from pydub import AudioSegment
+            import os
+            import tempfile
+            
+            # Initialize recognizer
+            recognizer = sr.Recognizer()
+            
+            # Convert to WAV if not already (needed for speech_recognition)
+            file_ext = os.path.splitext(file_path)[1].lower()
+            
+            if file_ext != '.wav':
+                # Create temp WAV file
+                temp_wav = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
+                
+                # Convert to WAV using pydub
+                audio = AudioSegment.from_file(file_path)
+                audio.export(temp_wav, format="wav")
+                audio_path = temp_wav
+            else:
+                audio_path = file_path
+                
+            # Transcribe audio using Google's speech recognition
+            with sr.AudioFile(audio_path) as source:
+                audio_data = recognizer.record(source)
+                transcript = recognizer.recognize_google(audio_data)
+                
+            # Clean up temp file if created
+            if file_ext != '.wav' and os.path.exists(temp_wav):
+                os.remove(temp_wav)
+                
+            return transcript.strip()
+            
+        except Exception as e:
+            return f"❌ Transcription failed: {str(e)}"
+
+class TranscibeVideoFileTool(Tool):
+    name = "transcribe_video"
+    description = """Transcribes speech from a video file. Use this to understand video lectures, tutorials, or visual demos."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to the video file (e.g., .mp4, .mov)."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            import moviepy.editor as mp
+            import speech_recognition as sr
+            import os
+            import tempfile
+            
+            # Extract audio from video
+            video = mp.VideoFileClip(file_path)
+            
+            # Create temporary audio file
+            temp_audio = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
+            
+            # Extract audio to WAV format (required for speech_recognition)
+            video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
+            video.close()
+            
+            # Initialize recognizer
+            recognizer = sr.Recognizer()
+            
+            # Transcribe audio
+            with sr.AudioFile(temp_audio) as source:
+                audio_data = recognizer.record(source)
+                transcript = recognizer.recognize_google(audio_data)
+            
+            # Clean up temp file
+            if os.path.exists(temp_audio):
+                os.remove(temp_audio)
+                
+            return transcript.strip()
+            
+        except Exception as e:
+            return f"❌ Video processing failed: {str(e)}"

tools.py

@@ -0,0 +1,1078 @@
+import os
+import re
+import tempfile
+import mimetypes
+import requests
+import pandas as pd
+import fitz  # PyMuPDF
+from urllib.parse import unquote
+from smolagents import Tool
+import requests
+import traceback
+import math
+from langchain_community.tools import BraveSearch
+from typing import List, Dict
+import json
+import html
+import requests, cv2, numpy as np, os
+import html
+import json
+import requests
+from bs4 import BeautifulSoup
+from langchain_community.document_loaders import ArxivLoader
+import arxiv
+from smolagents import tool
+
+from smolagents.tools import Tool
+import requests
+import os
+import mimetypes
+import traceback
+from urllib.parse import urlparse
+
+import time
+import traceback
+from duckduckgo_search import DDGS
+from duckduckgo_search.exceptions import (
+    DuckDuckGoSearchException,
+    RatelimitException,
+    TimeoutException,
+    ConversationLimitException,
+)
+
+from smolagents.tools import Tool
+import chromadb
+from pathlib import Path
+import traceback
+import json
+import os
+from langchain.document_loaders import (
+    TextLoader, PyPDFLoader, JSONLoader, UnstructuredFileLoader,BSHTMLLoader
+)
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+import chromadb.utils.embedding_functions as embedding_functions
+
+import os
+import pandas as pd
+import fitz  # PyMuPDF
+from markdownify import markdownify
+from bs4 import BeautifulSoup
+import re
+from smolagents.utils import truncate_content
+import requests
+from bs4 import BeautifulSoup
+from markdownify import markdownify
+import re
+from smolagents.utils import truncate_content
+
+class ReadFileContentTool(Tool):
+    name = "read_file_content"
+    description = """Reads local files in various formats (text, CSV, Excel, PDF, HTML, etc.) and returns their content as readable text. Automatically detects and processes the appropriate file format."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "The full path to the file from which the content should be read."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        if not os.path.exists(file_path):
+            return f"❌ File does not exist: {file_path}"
+
+        ext = os.path.splitext(file_path)[1].lower()
+
+        try:
+            if ext == ".txt":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return truncate_content(f.read())
+
+            elif ext == ".csv":
+                df = pd.read_csv(file_path)
+                return truncate_content(f"CSV Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}")
+
+            elif ext in [".xlsx", ".xls"]:
+                df = pd.read_excel(file_path)
+                return truncate_content(f"Excel Content:\n{df.to_string(index=False)}\n\nColumn names: {', '.join(df.columns)}")
+
+            elif ext == ".pdf":
+                doc = fitz.open(file_path)
+                text = "".join([page.get_text() for page in doc])
+                doc.close()
+                return truncate_content(text.strip() or "⚠️ PDF contains no readable text.")
+
+            elif ext == ".json":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return truncate_content(f.read())
+
+            elif ext == ".py":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return truncate_content(f.read())
+
+            elif ext in [".html", ".htm"]:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    html = f.read()
+                try:
+                    markdown = markdownify(html).strip()
+                    markdown = re.sub(r"\n{3,}", "\n\n", markdown)
+                    return f"📄 HTML content (converted to Markdown):\n\n{truncate_content(markdown)}"
+                except Exception:
+                    soup = BeautifulSoup(html, "html.parser")
+                    text = soup.get_text(separator="\n").strip()
+                    return f"📄 HTML content (raw text fallback):\n\n{truncate_content(text)}"
+
+            elif ext in [".mp3", ".wav"]:
+                return f"ℹ️ Audio file detected: {os.path.basename(file_path)}. Use transcribe_audio tool to process the audio content."
+
+            elif ext in [".mp4", ".mov", ".avi"]:
+                return f"ℹ️ Video file detected: {os.path.basename(file_path)}. Use transcribe_video tool to process the video content."
+
+            else:
+                return f"ℹ️ Unsupported file type: {ext}. File saved at {file_path}"
+
+        except Exception as e:
+            return f"❌ Could not read {file_path}: {e}"
+
+class WikipediaSearchTool(Tool):
+    name = "wikipedia_search"
+    description = """Searches Wikipedia for a specific topic and returns a concise summary. Useful for background information on subjects, concepts, historical events, or scientific topics."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The query or subject to search for on Wikipedia."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        print(f"EXECUTING TOOL: wikipedia_search(query='{query}')")
+        try:
+            search_link = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={query}&format=json"
+            search_response = requests.get(search_link, timeout=10)
+            search_response.raise_for_status()
+            search_data = search_response.json()
+
+            if not search_data.get('query', {}).get('search', []):
+                return f"No Wikipedia info for '{query}'."
+
+            page_id = search_data['query']['search'][0]['pageid']
+
+            content_link = (
+                f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&"
+                f"exintro=1&explaintext=1&pageids={page_id}&format=json"
+            )
+            content_response = requests.get(content_link, timeout=10)
+            content_response.raise_for_status()
+            content_data = content_response.json()
+
+            extract = content_data['query']['pages'][str(page_id)]['extract']
+            if len(extract) > 1500:
+                extract = extract[:1500] + "..."
+
+            result = f"Wikipedia summary for '{query}':\n{extract}"
+            print(f"-> Tool Result (Wikipedia): {result[:100]}...")
+            return result
+
+        except Exception as e:
+            print(f"❌ Error in wikipedia_search: {e}")
+            traceback.print_exc()
+            return f"Error wiki: {e}"
+
+class VisitWebpageTool(Tool):
+    name = "visit_webpage"
+    description = (
+        "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
+    )
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "The url of the webpage to visit.",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, url: str) -> str:
+        try:
+            import re
+
+            import requests
+            from markdownify import markdownify
+            from requests.exceptions import RequestException
+
+            from smolagents.utils import truncate_content
+        except ImportError as e:
+            raise ImportError(
+                "You must install packages `markdownify` and `requests` to run this tool: for instance run `pip install markdownify requests`."
+            ) from e
+        try:
+            response = requests.get(url, timeout=20)
+            response.raise_for_status()  # Raise an exception for bad status codes
+            markdown_content = markdownify(response.text).strip()
+            markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)
+            return truncate_content(markdown_content, 5000)
+
+        except requests.exceptions.Timeout:
+            return "The request timed out. Please try again later or check the URL."
+        except RequestException as e:
+            return f"Error fetching the webpage: {str(e)}"
+        except Exception as e:
+            return f"An unexpected error occurred: {str(e)}"
+   
+class TranscribeAudioTool(Tool):
+    name = "transcribe_audio"
+    description = """Converts spoken content in audio files to text. Handles various audio formats and produces a transcript of the spoken content for analysis."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "The full path to the audio file that needs to be transcribed."
+        }
+    }
+    output_type = "string"
+
+
+    def forward(self, file_path: str) -> str:
+        try:
+            import speech_recognition as sr
+            from pydub import AudioSegment
+            import os
+            import tempfile
+            
+            # Verify file exists
+            if not os.path.exists(file_path):
+                return f"❌ Audio file not found at: {file_path}. Download the file first."
+            
+            # Initialize recognizer
+            recognizer = sr.Recognizer()
+            
+            # Convert to WAV if not already (needed for speech_recognition)
+            file_ext = os.path.splitext(file_path)[1].lower()
+            
+            if file_ext != '.wav':
+                # Create temp WAV file
+                temp_wav = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
+                
+                # Convert to WAV using pydub
+                audio = AudioSegment.from_file(file_path)
+                audio.export(temp_wav, format="wav")
+                audio_path = temp_wav
+            else:
+                audio_path = file_path
+                
+            # Transcribe audio using Google's speech recognition
+            with sr.AudioFile(audio_path) as source:
+                audio_data = recognizer.record(source)
+                transcript = recognizer.recognize_google(audio_data)
+                
+            # Clean up temp file if created
+            if file_ext != '.wav' and os.path.exists(temp_wav):
+                os.remove(temp_wav)
+                
+            return transcript.strip()
+            
+        except Exception as e:
+            return f"❌ Transcription failed: {str(e)}"
+
+class TranscibeVideoFileTool(Tool):
+    name = "transcribe_video"
+    description = """Extracts and transcribes speech from video files. Converts the audio portion of videos into readable text for analysis or reference."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "The full path to the video file that needs to be transcribed."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            # Verify file exists
+            if not os.path.exists(file_path):
+                return f"❌ Video file not found at: {file_path}. Download the file first."
+                
+            import moviepy.editor as mp
+            import speech_recognition as sr
+            import os
+            import tempfile
+            
+            # Extract audio from video
+            video = mp.VideoFileClip(file_path)
+            
+            # Create temporary audio file
+            temp_audio = tempfile.NamedTemporaryFile(suffix='.wav', delete=False).name
+            
+            # Extract audio to WAV format (required for speech_recognition)
+            video.audio.write_audiofile(temp_audio, verbose=False, logger=None)
+            video.close()
+            
+            # Initialize recognizer
+            recognizer = sr.Recognizer()
+            
+            # Transcribe audio
+            with sr.AudioFile(temp_audio) as source:
+                audio_data = recognizer.record(source)
+                transcript = recognizer.recognize_google(audio_data)
+            
+            # Clean up temp file
+            if os.path.exists(temp_audio):
+                os.remove(temp_audio)
+                
+            return transcript.strip()
+            
+        except Exception as e:
+            return f"❌ Video processing failed: {str(e)}"
+     
+class BraveWebSearchTool(Tool):
+    name = "web_search"
+    description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "A web search query string (e.g., a question or query)."
+        }
+    }
+    output_type = "string"
+
+    api_key = os.getenv("BRAVE_SEARCH_API_KEY")
+    count = 3
+    char_limit = 4000  # Adjust based on LLM context window
+    tool = BraveSearch.from_api_key(api_key=api_key, search_kwargs={"count": count})
+
+    def extract_main_text(self, url: str, char_limit: int) -> str:
+        try:
+            headers = {"User-Agent": "Mozilla/5.0"}
+            response = requests.get(url, headers=headers, timeout=10)
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Remove scripts/styles
+            for tag in soup(["script", "style", "noscript"]):
+                tag.extract()
+
+            # Heuristic: extract visible text from body
+            body = soup.body
+            if not body:
+                return "⚠️ Could not extract content."
+
+            text = " ".join(t.strip() for t in body.stripped_strings)
+            return text[:char_limit].strip()
+        except Exception as e:
+            return f"⚠️ Failed to extract article: {e}"
+
+    def forward(self, query: str) -> str:
+        try:
+            results_json = self.tool.run(query)
+            results = json.loads(results_json) if isinstance(results_json, str) else results_json
+
+            output_parts = []
+            for i, r in enumerate(results[:self.count], start=1):
+                title = html.unescape(r.get("title", "").strip())
+                link = r.get("link", "").strip()
+
+                article_text = self.extract_main_text(link, self.char_limit)
+
+                result_block = (
+                    f"Result {i}:\n"
+                    f"Title: {title}\n"
+                    f"URL: {link}\n"
+                    f"Extracted Content:\n{article_text}\n"
+                )
+                output_parts.append(result_block)
+
+            return "\n\n".join(output_parts).strip()
+
+        except Exception as e:
+            return f"Search failed: {str(e)}"
+
+class DescribeImageTool(Tool):
+    name = "describe_image"
+    description = """Analyzes images and generates detailed text descriptions. Identifies objects, scenes, text, and visual elements within the image to provide context or understanding."""
+
+    inputs = {
+        "image_path": {
+            "type": "string",
+            "description": "The full path to the image file to describe."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, image_path: str) -> str:
+        import os
+        from PIL import Image
+        import torch
+        from transformers import BlipProcessor, BlipForConditionalGeneration
+
+        if not os.path.exists(image_path):
+            return f"❌ Image file does not exist: {image_path}"
+
+        try:
+            processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base", use_fast = True)
+            model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+
+            image = Image.open(image_path).convert("RGB")
+            inputs = processor(images=image, return_tensors="pt")
+            output_ids = model.generate(**inputs)
+
+            caption = processor.decode(output_ids[0], skip_special_tokens=True)
+            return caption.strip() or "⚠️ No caption could be generated."
+        except Exception as e:
+            return f"❌ Failed to describe image: {e}"
+
+class DownloadFileFromLinkTool(Tool):
+    name = "download_file_from_link"
+    description = "Downloads files from a URL and saves them locally. Supports various formats including PDFs, documents, images, and data files. Returns the local file path for further processing."
+
+    inputs = {
+        "link": {
+            "type": "string",
+            "description": "The URL to download the file from."
+        },
+        "file_name": {
+            "type": "string",
+            "description": "Desired name of the saved file, without extension.",
+            "nullable": True
+        }
+    }
+
+    output_type = "string"
+    SUPPORTED_EXTENSIONS = {'.xlsx','.pdf', '.txt', '.csv', '.json', '.xml', '.html', '.jpg', '.jpeg', '.png', '.mp4', '.mp3', '.wav', '.zip'}
+
+    def forward(self, link: str, file_name: str = "taskfile") -> str:
+        print(f"⬇️ Downloading file from: {link}")
+        dir_path = "./downloads"
+        os.makedirs(dir_path, exist_ok=True)
+
+        try:
+            response = requests.get(link, stream=True, timeout=30)
+        except requests.RequestException as e:
+            return f"❌ Error: Request failed - {e}"
+
+        if response.status_code != 200:
+            return f"❌ Error: Unable to fetch file. Status code: {response.status_code}"
+
+        # Step 1: Try extracting extension from provided filename
+        base_name, provided_ext = os.path.splitext(file_name)
+        provided_ext = provided_ext.lower()
+
+        # Step 2: Check if provided extension is supported
+        if provided_ext and provided_ext in self.SUPPORTED_EXTENSIONS:
+            ext = provided_ext
+        else:
+            # Step 3: Try to infer from Content-Type
+            content_type = response.headers.get("Content-Type", "").split(";")[0].strip()
+            guessed_ext = mimetypes.guess_extension(content_type or "") or ""
+
+            # Step 4: If mimetype returned .bin or nothing useful, try to fallback to URL
+            if guessed_ext in ("", ".bin"):
+                parsed_link = urlparse(link)
+                _, url_ext = os.path.splitext(parsed_link.path)
+                if url_ext.lower() in self.SUPPORTED_EXTENSIONS:
+                    ext = url_ext.lower()
+                else:
+                    return f"⚠️ Warning: Cannot determine a valid file extension from '{content_type}' or URL. Please retry with an explicit valid filename and extension."
+            else:
+                ext = guessed_ext
+
+        # Step 5: Final path and save
+        file_path = os.path.join(dir_path, base_name + ext)
+        downloaded = 0
+
+        with open(file_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+                    downloaded += len(chunk)
+
+        return file_path
+
+class DuckDuckGoSearchTool(Tool):
+    name = "web_search"
+    description = """Performs web searches and returns content from top results. Provides real-time information from across the internet including current events, facts, and website content relevant to your query."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The search query to run on DuckDuckGo"
+        },
+    }
+    output_type = "string"
+
+    def _configure(self, max_retries: int = 3, retry_sleep: int = 3):
+        self._max_retries = max_retries
+        self._retry_sleep = retry_sleep
+
+    def forward(self, query: str) -> str:
+        self._configure()
+        print(f"EXECUTING TOOL: duckduckgo_search(query='{query}', top_results={top_results})")
+
+        top_results = 5
+
+        retries = 0
+        max_retries = getattr(self, "_max_retries", 3)
+        retry_sleep = getattr(self, "_retry_sleep", 2)
+
+        while retries < max_retries:
+            try:
+                results = DDGS().text(
+                    keywords=query,
+                    region="wt-wt",
+                    safesearch="moderate",
+                    max_results=top_results,
+                )
+
+                if not results:
+                    return "No results found."
+
+                output_lines = []
+                for idx, res in enumerate(results[:top_results], start=1):
+                    title = res.get("title", "N/A")
+                    url = res.get("href", "N/A")
+                    snippet = res.get("body", "N/A")
+                    
+                    output_lines.append(
+                        f"Result {idx}:\n"
+                        f"Title: {title}\n"
+                        f"URL: {url}\n"
+                        f"Snippet: {snippet}\n"
+                    )
+
+                output = "\n".join(output_lines)
+
+                print(f"-> Tool Result (DuckDuckGo): {output[:1500]}...")
+                return output
+
+            except (DuckDuckGoSearchException, TimeoutException, RatelimitException, ConversationLimitException) as e:
+                retries += 1
+                print(f"⚠️ DuckDuckGo Exception (Attempt {retries}/{max_retries}): {type(e).__name__}: {e}")
+                traceback.print_exc()
+                time.sleep(retry_sleep)
+
+            except Exception as e:
+                print(f"❌ Unexpected Error: {e}")
+                traceback.print_exc()
+                return f"Unhandled exception during DuckDuckGo search: {e}"
+
+        return f"❌ Failed to retrieve results after {max_retries} retries."
+    
+huggingface_ef = embedding_functions.HuggingFaceEmbeddingFunction(
+    api_key=os.environ["HF_TOKEN"],
+    model_name="sentence-transformers/all-mpnet-base-v2"
+)
+SUPPORTED_EXTENSIONS = [".txt", ".md", ".py", ".pdf", ".json", ".jsonl", '.html', '.htm']
+
+class AddDocumentToVectorStoreTool(Tool):
+    name = "add_document_to_vector_store"
+    description = "Processes a document and adds it to the vector database for semantic search. Automatically chunks files and creates text embeddings to enable powerful content retrieval."
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Absolute path to the file to be indexed.",
+        }
+    }
+
+    output_type = "string"
+
+    def _load_file(self, path: Path):
+        """Select the right loader for the file extension."""
+        if path.suffix == ".pdf":
+            return PyPDFLoader(str(path)).load()
+        elif path.suffix == ".json":
+            return JSONLoader(str(path), jq_schema=".").load()
+        elif path.suffix in [".md"]:
+            return UnstructuredFileLoader(str(path)).load()
+        elif path.suffix in [".html", ".htm"]:
+            return BSHTMLLoader(str(path)).load()
+        else:  # fallback for .txt, .py, etc.
+            return TextLoader(str(path)).load()
+
+    def forward(self, file_path: str) -> str:
+        print(f"📄 Adding document to vector store: {file_path}")
+        try:
+            collection_name = "vectorstore"
+            path = Path(file_path)
+            if not path.exists() or path.suffix not in SUPPORTED_EXTENSIONS:
+                return f"Unsupported or missing file: {file_path}"
+
+            docs = self._load_file(path)
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+            split_docs = text_splitter.split_documents(docs)
+
+            client = chromadb.Client(chromadb.config.Settings(
+                persist_directory="./chroma_store",
+            ))
+
+            collection = client.get_or_create_collection(name=collection_name,configuration={
+        "embedding_function": huggingface_ef
+    })
+
+            texts = [doc.page_content for doc in split_docs]
+            metadatas = [doc.metadata for doc in split_docs]
+
+            collection.add(
+                documents=texts,
+                metadatas=metadatas,
+                ids=[f"{path.stem}_{i}" for i in range(len(texts))]
+            )
+
+            return f"✅ Successfully added {len(texts)} chunks from '{file_path}' to collection '{collection_name}'."
+
+        except Exception as e:
+            print(f"❌ Error in add_to_vector_store: {e}")
+            traceback.print_exc()
+            return f"Error: {e}"
+        
+class QueryVectorStoreTool(Tool):
+    name = "query_downloaded_documents"
+    description = "Performs semantic searches across your downloaded documents. Use detailed queries to find specific information, concepts, or answers from your collected resources."
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The search query. Ensure this is constructed intelligently so to retrieve the most relevant outputs.",
+        },
+        "top_k": {
+            "type": "integer",
+            "description": "Number of top results to retrieve. Usually between 3 and 30",
+            "nullable": True
+        }
+    }
+    output_type = "string"
+
+    def forward(self, query: str, top_k: int = 5) -> str:
+        collection_name = "vectorstore"
+
+        if k < 3:
+            k = 3
+        if k > 30:
+            k = 30
+
+        print(f"🔎 Querying vector store '{collection_name}' with: '{query}'")
+        try:
+            client = chromadb.Client(chromadb.config.Settings(
+                persist_directory="./chroma_store",
+            ))
+            collection = client.get_collection(name=collection_name)
+
+            results = collection.query(
+                query_texts=[query],
+                n_results=top_k,
+            )
+
+            formatted = []
+            for i in range(len(results["documents"][0])):
+                doc = results["documents"][0][i]
+                metadata = results["metadatas"][0][i]
+                formatted.append(
+                    f"Result {i+1}:\n"
+                    f"Content: {doc}\n"
+                    f"Metadata: {metadata}\n"
+                )
+
+            return "\n".join(formatted) or "No relevant documents found."
+
+        except Exception as e:
+            print(f"❌ Error in query_vector_store: {e}")
+            traceback.print_exc()
+            return f"Error querying vector store: {e}"
+
+@tool
+def image_question_answering(image_path: str, prompt: str) -> str:
+    """
+    Analyzes images and answers specific questions about their content. Can identify objects, read text, describe scenes, or interpret visual information based on your questions.
+    
+    Args:
+        image_path: The path to the image file
+        prompt: The question to ask about the image
+    
+    Returns:
+        A string answer generated by the local Ollama model
+    """
+    # Check for supported file types
+    file_extension = image_path.lower().split(".")[-1]
+    if file_extension not in ["jpg", "jpeg", "png", "bmp", "gif", "webp"]:
+        return "Unsupported file type. Please provide an image."
+
+    path = Path(image_path)
+    if not path.exists():
+        return f"File not found at: {image_path}"
+
+    # Send the image and prompt to Ollama's local model
+    response = chat(
+        model='llava',  # Assuming your model is named 'lava'
+        messages=[
+            {
+                'role': 'user',
+                'content': prompt,
+                'images': [path],
+            },
+        ],
+        options={'temperature': 0.2}  # Slight randomness for naturalness
+    )
+
+    return response.message.content.strip()
+
+
+class VisitWebpageTool(Tool):
+    name = "visit_webpage"
+    description = (
+        "Loads a webpage from a URL and converts its content to markdown format. Use this to browse websites, extract information, or identify downloadable resources from a specific web address."
+    )
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "The url of the webpage to visit.",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, url: str) -> str:
+        try:
+            import re
+            from urllib.parse import urlparse
+
+            import requests
+            from bs4 import BeautifulSoup
+            from markdownify import markdownify
+            from requests.exceptions import RequestException
+
+            from smolagents.utils import truncate_content
+        except ImportError as e:
+            raise ImportError(
+                "You must install packages `markdownify`, `requests`, and `beautifulsoup4` to run this tool: for instance run `pip install markdownify requests beautifulsoup4`."
+            ) from e
+        
+        try:
+            # Get the webpage content
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            response = requests.get(url, headers=headers, timeout=20)
+            response.raise_for_status()
+            
+            # Parse the HTML with BeautifulSoup
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Extract domain name for context
+            domain = urlparse(url).netloc
+            
+            # Remove common clutter elements
+            self._remove_clutter(soup)
+            
+            # Try to identify and prioritize main content
+            main_content = self._extract_main_content(soup)
+            
+            if main_content:
+                # Convert the cleaned HTML to markdown
+                markdown_content = markdownify(str(main_content)).strip()
+            else:
+                # Fallback to full page content if main content extraction fails
+                markdown_content = markdownify(str(soup)).strip()
+            
+            # Post-process the markdown content
+            markdown_content = self._clean_markdown(markdown_content)
+            
+            # Add source information
+            result = f"Content from {domain}:\n\n{markdown_content}"
+            
+            return truncate_content(result, 40000)
+
+        except requests.exceptions.Timeout:
+            return "The request timed out. Please try again later or check the URL."
+        except RequestException as e:
+            return f"Error fetching the webpage: {str(e)}"
+        except Exception as e:
+            return f"An unexpected error occurred: {str(e)}"
+    
+    def _remove_clutter(self, soup):
+        """Remove common elements that clutter web pages."""
+        # Common non-content elements to remove
+        clutter_selectors = [
+            'header', 'footer', 'nav', '.nav', '.navigation', '.menu', '.sidebar', 
+            '.footer', '.header', '#footer', '#header', '#nav', '#sidebar',
+            '.widget', '.cookie', '.cookies', '.ad', '.ads', '.advertisement',
+            'script', 'style', 'noscript', 'iframe', '.social', '.share',
+            '.comment', '.comments', '.subscription', '.newsletter',
+            '[role="banner"]', '[role="navigation"]', '[role="complementary"]'
+        ]
+        
+        for selector in clutter_selectors:
+            for element in soup.select(selector):
+                element.decompose()
+        
+        # Remove hidden elements
+        for hidden in soup.select('[style*="display: none"], [style*="display:none"], [style*="visibility: hidden"], [style*="visibility:hidden"], [hidden]'):
+            hidden.decompose()
+    
+    def _extract_main_content(self, soup):
+        """Try to identify and extract the main content of the page."""
+        # Priority order for common main content containers
+        main_content_selectors = [
+            'main', 
+            '[role="main"]', 
+            'article', 
+            '.content', 
+            '.main-content', 
+            '.post-content',
+            '#content', 
+            '#main', 
+            '#main-content',
+            '.article', 
+            '.post', 
+            '.entry',
+            '.page-content',
+            '.entry-content',
+        ]
+        
+        # Try to find the main content container
+        for selector in main_content_selectors:
+            main_content = soup.select(selector)
+            if main_content:
+                # If multiple matches, find the one with the most text content
+                if len(main_content) > 1:
+                    return max(main_content, key=lambda x: len(x.get_text()))
+                return main_content[0]
+        
+        # If no main content container found, look for the largest text block
+        paragraphs = soup.find_all('p')
+        if paragraphs:
+            # Find the parent that contains the most paragraphs
+            parents = {}
+            for p in paragraphs:
+                if p.parent:
+                    if p.parent not in parents:
+                        parents[p.parent] = 0
+                    parents[p.parent] += 1
+            
+            if parents:
+                # Return the parent with the most paragraphs
+                return max(parents.items(), key=lambda x: x[1])[0]
+        
+        # Return None if we can't identify main content
+        return None
+    
+    def _clean_markdown(self, content):
+        """Clean up the markdown content."""
+        # Normalize whitespace
+        content = re.sub(r'\n{3,}', '\n\n', content)
+        
+        # Remove consecutive duplicate links
+        content = re.sub(r'(\[.*?\]\(.*?\))\s*\1+', r'\1', content)
+        
+        # Remove very short lines that are likely menu items
+        lines = content.split('\n')
+        filtered_lines = []
+        
+        # Skip consecutive short lines (likely menus)
+        short_line_threshold = 40  # characters
+        consecutive_short_lines = 0
+        max_consecutive_short_lines = 3
+        
+        for line in lines:
+            stripped_line = line.strip()
+            if len(stripped_line) < short_line_threshold and not stripped_line.startswith('#'):
+                consecutive_short_lines += 1
+                if consecutive_short_lines > max_consecutive_short_lines:
+                    continue
+            else:
+                consecutive_short_lines = 0
+            
+            filtered_lines.append(line)
+        
+        content = '\n'.join(filtered_lines)
+        
+        # Remove duplicate headers
+        seen_headers = set()
+        lines = content.split('\n')
+        filtered_lines = []
+        
+        for line in lines:
+            if line.startswith('#'):
+                header_text = line.strip()
+                if header_text in seen_headers:
+                    continue
+                seen_headers.add(header_text)
+            filtered_lines.append(line)
+        
+        content = '\n'.join(filtered_lines)
+        
+        # Remove lines containing common footer patterns
+        footer_patterns = [
+            r'^copyright', r'^©', r'^all rights reserved', 
+            r'^terms', r'^privacy policy', r'^contact us',
+            r'^follow us', r'^social media', r'^disclaimer',
+        ]
+        
+        footer_pattern = '|'.join(footer_patterns)
+        lines = content.split('\n')
+        filtered_lines = []
+        
+        for line in lines:
+            if not re.search(footer_pattern, line.lower()):
+                filtered_lines.append(line)
+        
+        content = '\n'.join(filtered_lines)
+        
+        return content
+    
+
+class ArxivSearchTool(Tool):
+    name = "arxiv_search"
+    description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, abstracts, and download links."""
+
+  
+    inputs = {
+        "query":    {"type": "string",  "description": "A research-related query (e.g., 'AI regulation')"},
+        "from_date":{"type": "string",  "description": "Optional search start date in format (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')", "nullable": True},
+        "to_date":  {"type": "string",  "description": "Optional search end date in (YYYY or YYYY-MM or YYYY-MM-DD) (e.g., '2022-06' or '2022' or '2022-04-12')", "nullable": True},
+    }
+
+    output_type = "string"
+
+    def forward(
+        self,
+        query: str,
+        from_date: str = None,
+        to_date: str = None,
+    ) -> str:
+        # 1) build URL
+        url = build_arxiv_url(query, from_date, to_date, size=50)
+
+        # 2) fetch & parse
+        try:
+            papers = fetch_and_parse_arxiv(url)
+        except Exception as e:
+            return f"❌ Failed to fetch or parse arXiv results: {e}"
+
+        if not papers:
+            return "No results found for your query."
+
+        # 3) format into a single string
+        output_lines = []
+        for idx, p in enumerate(papers, start=1):
+            output_lines += [
+                f"🔍 RESULT {idx}",
+                f"Title        : {p['title']}",
+                f"Authors      : {p['authors']}",
+                f"Published    : {p['published']}",
+                f"Summary      : {p['abstract'][:500]}{'...' if len(p['abstract'])>500 else ''}",
+                f"Entry ID     : {p['entry_link']}",
+                f"Download link: {p['download_link']}",
+                ""
+            ]
+
+        return "\n".join(output_lines).strip()
+    
+
+import requests
+from bs4 import BeautifulSoup
+from typing import List, Dict
+
+def fetch_and_parse_arxiv(url: str) -> List[Dict[str, str]]:
+    """
+    Fetches the given arXiv advanced‐search URL, parses the HTML,
+    and returns a list of results. Each result is a dict containing:
+      - title
+      - authors
+      - published
+      - abstract
+      - entry_link
+      - doi (or "[N/A]" if none)
+    """
+    resp = requests.get(url)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, "html.parser")
+
+    results = []
+    for li in soup.find_all("li", class_="arxiv-result"):
+        # Title
+        t = li.find("p", class_="title")
+        title = t.get_text(strip=True) if t else ""
+
+        # Authors
+        a = li.find("p", class_="authors")
+        authors = a.get_text(strip=True).replace("Authors:", "").strip() if a else ""
+
+        # Abstract
+        ab = li.find("span", class_="abstract-full")
+        abstract = ab.get_text(strip=True).replace("Abstract:", "").strip() if ab else ""
+
+        # Published date
+        d = li.find("p", class_="is-size-7")
+        published = d.get_text(strip=True) if d else ""
+
+        # Entry link
+        lt = li.find("p", class_="list-title")
+        entry_link = lt.find("a")["href"] if lt and lt.find("a") else ""
+
+        # DOI
+        idblock = li.find("p", class_="list-identifier")
+        if idblock:
+            for a_tag in idblock.find_all("a", href=True):
+                if "doi.org" in a_tag["href"]:
+                    doi = a_tag["href"]
+                    break
+
+        results.append({
+            "title": title,
+            "authors": authors,
+            "published": published,
+            "abstract": abstract,
+            "entry_link": entry_link,
+            "download_link": entry_link.replace("abs", "pdf") if "abs" in entry_link else "N/A"
+        })
+
+    return results
+
+from urllib.parse import quote_plus
+
+def build_arxiv_url(
+    query: str,
+    from_date: str = None,
+    to_date: str = None,
+    size: int = 50
+) -> str:
+    """
+    Build an arXiv advanced-search URL matching the exact segment order:
+      1) ?advanced
+      2) terms-0-operator=AND
+      3) terms-0-term=…
+      4) terms-0-field=all
+      5) classification-physics_archives=all
+      6) classification-include_cross_list=include
+      [ optional date‐range block ]
+      7) abstracts=show
+      8) size=…
+      9) order=-announced_date_first
+    If from_date or to_date is None, the date-range block is omitted.
+    """
+    base = "https://arxiv.org/search/advanced?advanced="
+    parts = [
+        "&terms-0-operator=AND",
+        f"&terms-0-term={quote_plus(query)}",
+        "&terms-0-field=all",
+        "&classification-physics_archives=all",
+        "&classification-include_cross_list=include",
+    ]
+
+    # optional date-range filtering
+    if from_date and to_date:
+        parts += [
+            "&date-year=",
+            "&date-filter_by=date_range",
+            f"&date-from_date={from_date}",
+            f"&date-to_date={to_date}",
+            "&date-date_type=submitted_date",
+        ]
+
+    parts += [
+        "&abstracts=show",
+        f"&size={size}",
+        "&order=-announced_date_first",
+    ]
+
+    return base + "".join(parts)

tools_beta.py

@@ -0,0 +1,550 @@
+import os
+import re
+import tempfile
+import mimetypes
+import requests
+import pandas as pd
+import fitz  # PyMuPDF
+from urllib.parse import unquote
+from smolagents import Tool
+from smolagents import Tool
+import requests
+import traceback
+from langchain_community.retrievers import BM25Retriever
+from smolagents import Tool
+import math
+
+import subprocess
+import sys
+import os
+import re
+
+
+
+class DetectVisualElementsTool(Tool):
+    name = "detect_visual_elements"
+    description = """Detects objects, people, and common visual elements in an image using a pretrained object detection model."""
+
+    inputs = {
+        "image_path": {
+            "type": "string",
+            "description": "The full path to the image file to analyze."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, image_path: str) -> list:
+        import os
+        from PIL import Image
+        import torch
+        import torchvision.transforms as T
+        import torchvision.models.detection as models
+
+        label_map = {
+    0: "unlabeled",
+    1: "person",
+    2: "bicycle",
+    3: "car",
+    4: "motorcycle",
+    5: "airplane",
+    6: "bus",
+    7: "train",
+    8: "truck",
+    9: "boat",
+    10: "traffic",
+    11: "fire",
+    12: "street",
+    13: "stop",
+    14: "parking",
+    15: "bench",
+    16: "bird",
+    17: "cat",
+    18: "dog",
+    19: "horse",
+    20: "sheep",
+    21: "cow",
+    22: "elephant",
+    23: "bear",
+    24: "zebra",
+    25: "giraffe",
+    26: "hat",
+    27: "backpack",
+    28: "umbrella",
+    29: "shoe",
+    30: "eye",
+    31: "handbag",
+    32: "tie",
+    33: "suitcase",
+    34: "frisbee",
+    35: "skis",
+    36: "snowboard",
+    37: "sports",
+    38: "kite",
+    39: "baseball",
+    40: "baseball",
+    41: "skateboard",
+    42: "surfboard",
+    43: "tennis",
+    44: "bottle",
+    45: "plate",
+    46: "wine",
+    47: "cup",
+    48: "fork",
+    49: "knife",
+    50: "spoon",
+    51: "bowl",
+    52: "banana",
+    53: "apple",
+    54: "sandwich",
+    55: "orange",
+    56: "broccoli",
+    57: "carrot",
+    58: "hot",
+    59: "pizza",
+    60: "donut",
+    61: "cake",
+    62: "chair",
+    63: "couch",
+    64: "potted",
+    65: "bed",
+    66: "mirror",
+    67: "dining",
+    68: "window",
+    69: "desk",
+    70: "toilet",
+    71: "door",
+    72: "tv",
+    73: "laptop",
+    74: "mouse",
+    75: "remote",
+    76: "keyboard",
+    77: "cell",
+    78: "microwave",
+    79: "oven",
+    80: "toaster",
+    81: "sink",
+    82: "refrigerator",
+    83: "blender",
+    84: "book",
+    85: "clock",
+    86: "vase",
+    87: "scissors",
+    88: "teddy",
+    89: "hair",
+    90: "toothbrush",
+    91: "hair",
+    92: "banner",
+    93: "blanket",
+    94: "branch",
+    95: "bridge",
+    96: "building",
+    97: "bush",
+    98: "cabinet",
+    99: "cage",
+    100: "cardboard",
+    101: "carpet",
+    102: "ceiling",
+    103: "ceiling",
+    104: "cloth",
+    105: "clothes",
+    106: "clouds",
+    107: "counter",
+    108: "cupboard",
+    109: "curtain",
+    110: "desk",
+    111: "dirt",
+    112: "door",
+    113: "fence",
+    114: "floor",
+    115: "floor",
+    116: "floor",
+    117: "floor",
+    118: "floor",
+    119: "flower",
+    120: "fog",
+    121: "food",
+    122: "fruit",
+    123: "furniture",
+    124: "grass",
+    125: "gravel",
+    126: "ground",
+    127: "hill",
+    128: "house",
+    129: "leaves",
+    130: "light",
+    131: "mat",
+    132: "metal",
+    133: "mirror",
+    134: "moss",
+    135: "mountain",
+    136: "mud",
+    137: "napkin",
+    138: "net",
+    139: "paper",
+    140: "pavement",
+    141: "pillow",
+    142: "plant",
+    143: "plastic",
+    144: "platform",
+    145: "playingfield",
+    146: "railing",
+    147: "railroad",
+    148: "river",
+    149: "road",
+    150: "rock",
+    151: "roof",
+    152: "rug",
+    153: "salad",
+    154: "sand",
+    155: "sea",
+    156: "shelf",
+    157: "sky",
+    158: "skyscraper",
+    159: "snow",
+    160: "solid",
+    161: "stairs",
+    162: "stone",
+    163: "straw",
+    164: "structural",
+    165: "table",
+    166: "tent",
+    167: "textile",
+    168: "towel",
+    169: "tree",
+    170: "vegetable",
+    171: "wall",
+    172: "wall",
+    173: "wall",
+    174: "wall",
+    175: "wall",
+    176: "wall",
+    177: "wall",
+    178: "water",
+    179: "waterdrops",
+    180: "window",
+    181: "window",
+    182: "wood"
+}
+
+
+        if not os.path.exists(image_path):
+            return [f"❌ Image file does not exist: {image_path}"]
+
+        try:
+            model = models.fasterrcnn_resnet50_fpn(pretrained=True)
+            model.eval()
+
+            image = Image.open(image_path).convert("RGB")
+            transform = T.Compose([T.ToTensor()])
+            img_tensor = transform(image).unsqueeze(0)
+
+            with torch.no_grad():
+                predictions = model(img_tensor)[0]
+
+            labels_list = []
+            for label_id, score in zip(predictions["labels"], predictions["scores"]):
+                if score > 0.8:
+                    print(str(label_id.item()))
+                    labels_list.append(label_map.get(label_id.item()))
+                    
+            labels = ",".join(labels_list)
+
+            return labels or ["⚠️ No confident visual elements detected."]
+        except Exception as e:
+            return [f"❌ Failed to detect visual elements: {e}"]
+
+
+class ChessPositionSolverTool(Tool):
+    name = "chess_position_solver"
+    description = """Analyzes a chessboard image (from a URL or a local file path), detects the position using computer vision,
+    and returns the best move in algebraic notation using the Stockfish engine (e.g., 'Qh5#')."""
+
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "Optional. URL pointing to an image of a chessboard position.",
+            "nullable": True
+        },
+        "file_path": {
+            "type": "string",
+            "description": "Optional. Local file path to an image of a chessboard position.",
+            "nullable": True
+        }
+    }
+
+    output_type = "string"
+
+
+
+    def forward(self, url: str = None, file_path: str = None) -> str:
+        if not url and not file_path:
+            return "❌ Please provide either a URL or a local file path to the chessboard image."
+        if url and file_path:
+            return "❌ Provide only one of: 'url' or 'file_path', not both."
+
+        try:
+            # Step 1 - Load image
+            if url:
+                img_bytes = requests.get(url, timeout=30).content
+                img = cv2.imdecode(np.frombuffer(img_bytes, np.uint8), cv2.IMREAD_COLOR)
+            else:
+                if not os.path.exists(file_path):
+                    return f"❌ File not found: {file_path}"
+                img = cv2.imread(file_path)
+
+            if img is None:
+                return "❌ Could not decode the image. Ensure the file is a valid chessboard image."
+
+            # Step 2 - Infer FEN with chesscog
+            detector = Chesscog(device="cpu")
+            fen = detector.get_fen(img)
+            if fen is None:
+                return "❌ Could not detect chessboard or recognize position."
+
+            board = chess.Board(fen)
+
+            STOCKFISH_PATH = os.getenv("STOCKFISH_PATH", "/home/boom/Desktop/repos/boombot/engines/stockfish-ubuntu-x86-64-bmi2")  # Ensure Stockfish is available
+
+            # Step 3 - Analyze with Stockfish
+            engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
+            result = engine.play(board, chess.engine.Limit(depth=18))  # fixed depth
+            engine.quit()
+
+            best_move = board.san(result.move)
+            return best_move
+
+        except Exception as e:
+            return f"❌ chess_position_solver failed: {str(e)}"
+
+
+def patch_pyproject(path):
+    pyproject_path = os.path.join(path, "pyproject.toml")
+    if not os.path.exists(pyproject_path):
+        raise FileNotFoundError(f"No pyproject.toml found in {path}")
+
+    with open(pyproject_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    with open(pyproject_path, "w", encoding="utf-8") as f:
+        for line in lines:
+            if re.match(r'\s*python\s*=', line):
+                f.write('python = ">=3.8,<3.12"\n')
+            else:
+                f.write(line)
+
+def install_chesscog():
+    TARGET_DIR = "chesscog"
+    REPO_URL = "https://github.com/georg-wolflein/chesscog.git"
+
+    try:
+        import chesscog
+        print("✅ chesscog already installed.")
+        # return
+    except ImportError:
+        print("⬇️ Installing chesscog...")
+
+    if not os.path.exists(TARGET_DIR):
+        subprocess.run(["git", "clone", REPO_URL, TARGET_DIR], check=True)
+
+    patch_pyproject(TARGET_DIR)
+
+    subprocess.run([sys.executable, "-m", "pip", "install", f"./{TARGET_DIR}"], check=True)
+    print("✅ chesscog installed successfully.")
+
+class RetrieverTool(Tool):
+    name = "retriever"
+    description = "Retrieves the most similar known question to the query."
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The query from the user (a question).",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs, **kwargs):
+        super().__init__(**kwargs)
+        self.retriever = BM25Retriever.from_documents(docs, k=1)
+
+    def forward(self, query: str) -> str:
+        docs = self.retriever.invoke(query)
+        if docs:
+            doc = docs[0]
+            return f"{doc.page_content}\n\nEXAMPLE FINAL ANSWER:\n{doc.metadata['answer']}\n"
+        else:
+            return "No similar question found."
+
+class CalculatorTool(Tool):
+    name = "calculator"
+    description = """Performs basic mathematical calculations (e.g., addition, subtraction, multiplication, division, exponentiation, square root).
+Use this tool whenever math is required, especially for numeric reasoning."""
+
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "A basic math expression, e.g., '5 + 3 * 2', 'sqrt(49)', '2 ** 3'. No variables or natural language."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, expression: str) -> str:
+        try:
+            allowed_names = {
+                k: v for k, v in math.__dict__.items()
+                if not k.startswith("__")
+            }
+            allowed_names.update({"abs": abs, "round": round})
+            result = eval(expression, {"__builtins__": {}}, allowed_names)
+            return str(result)
+        except Exception as e:
+            return f"Error: Invalid math expression. ({e})"
+
+class AnalyzeChessImageTool(Tool):
+    name = "analyze_chess_image"
+    description = """Extracts the board state from a chessboard image and returns the best move for black (in algebraic notation)."""
+
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to the image file of the chess board."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            import chess
+            import chess.engine
+            import chessvision  # hypothetical or use OpenCV + custom board parser
+
+            board = chessvision.image_to_board(file_path)
+            if not board or not board.turn == chess.BLACK:
+                return "❌ Invalid board or not black's turn."
+
+            engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish")
+            result = engine.play(board, chess.engine.Limit(time=0.1))
+            move = result.move.uci()
+            engine.quit()
+
+            return move
+        except Exception as e:
+            return f"❌ Chess analysis failed: {e}"
+
+
+   
+class ExecutePythonCodeTool(Tool):
+    name = "execute_python_code"
+    description = """Executes a provided Python code snippet in a controlled, sandboxed environment.
+    This tool is used to safely run Python code and return the output or result of the execution."""
+
+    inputs = {
+        "code": {
+            "type": "string",
+            "description": "A valid Python code block that needs to be executed. It should be a string containing executable Python code."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, code: str) -> str:
+        try:
+            # Create a restricted environment to execute the code safely
+            # Only allow standard Python libraries and prevent unsafe functions like `os.system` or `eval`
+            restricted_globals = {
+                "__builtins__": {
+                    "abs": abs,
+                    "all": all,
+                    "any": any,
+                    "bin": bin,
+                    "bool": bool,
+                    "chr": chr,
+                    "complex": complex,
+                    "dict": dict,
+                    "divmod": divmod,
+                    "float": float,
+                    "hash": hash,
+                    "hex": hex,
+                    "int": int,
+                    "isinstance": isinstance,
+                    "len": len,
+                    "max": max,
+                    "min": min,
+                    "oct": oct,
+                    "pow": pow,
+                    "range": range,
+                    "round": round,
+                    "set": set,
+                    "sorted": sorted,
+                    "str": str,
+                    "tuple": tuple,
+                    "zip": zip,
+                }
+            }
+
+            # Execute the code in the restricted environment
+            exec_locals = {}
+            exec(code, restricted_globals, exec_locals)
+
+            # If the code produces a result, we return that as output
+            if 'result' in exec_locals:
+                return str(exec_locals['result'])
+            else:
+                return "❌ The code did not produce a result."
+
+        except Exception as e:
+            return f"❌ Error executing code: {str(e)}"
+
+
+
+class ArxivSearchTool(Tool):
+    name = "arxiv_search"
+    description = """Searches arXiv for academic papers and returns structured information including titles, authors, publication dates, and abstracts. Ideal for finding scientific research on specific topics."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "A research-related query string (e.g., 'Superstring Cosmology')"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        max_results = 10
+
+        try:
+            search_docs = ArxivLoader(
+                query=query,
+                load_max_docs=max_results,
+                load_all_available_meta=True
+            ).load()
+        except Exception as e:
+            return f"❌ Arxiv search failed: {e}"
+
+        if not search_docs:
+            return "No results found for your query."
+
+        output_lines = []
+        for idx, doc in enumerate(search_docs):
+            meta = getattr(doc, "metadata", {}) or {}
+            content = getattr(doc, "page_content", "").strip()
+
+            output_lines.append(f"🔍 RESULT {idx + 1}")
+            output_lines.append(f"Title        : {meta.get('Title', '[No Title]')}")
+            output_lines.append(f"Authors      : {meta.get('Authors', '[No Authors]')}")
+            output_lines.append(f"Published    : {meta.get('Published', '[No Date]')}")
+            output_lines.append(f"Summary      : {meta.get('Summary', '[No Summary]')}")
+            output_lines.append(f"Entry ID     : {meta.get('entry_id', '[N/A]')}")
+            # output_lines.append(f"First Pub.   : {meta.get('published_first_time', '[N/A]')}")
+            # output_lines.append(f"Comment      : {meta.get('comment', '[N/A]')}")
+            output_lines.append(f"DOI          : {meta.get('doi', '[N/A]')}")
+            # output_lines.append(f"Journal Ref  : {meta.get('journal_ref', '[N/A]')}")
+            # output_lines.append(f"Primary Cat. : {meta.get('primary_category', '[N/A]')}")
+            # output_lines.append(f"Categories   : {', '.join(meta.get('categories', [])) or '[N/A]'}")
+            output_lines.append(f"Links        : {', '.join(meta.get('links', [])) or '[N/A]'}")
+
+            if content:
+                preview = content[:30] + ("..." if len(content) > 30 else "")
+                output_lines.append(f"Content      : {preview}")
+
+            output_lines.append("")  # spacing between results
+
+        return "\n".join(output_lines).strip()

utils.py

@@ -0,0 +1,35 @@
+import re
+
+def extract_final_answer(output: str) -> str:
+    """
+    Extracts the text after 'FINAL ANSWER:' in the model's output.
+    Strips whitespace and ensures clean formatting.
+    If the answer is a comma-separated list, ensures a space after each comma.
+    """
+    output = str(output)
+    marker = "FINAL ANSWER:"
+    lower_output = output.lower()
+    
+    if marker.lower() in lower_output:
+        # Find actual case version in original output (for safety)
+        idx = lower_output.rfind(marker.lower())
+        raw_answer = output[idx + len(marker):].strip()
+        
+        # Normalize comma-separated lists: ensure single space after commas
+        cleaned_answer = re.sub(r',\s*', ', ', raw_answer)
+        return cleaned_answer
+    
+    return output
+
+
+def replace_tool_mentions(prompt: str) -> str:
+    # Replace tool mentions in backticks: `search` -> `web_search`, `wiki` -> `wikipedia_search`
+    prompt = re.sub(r'(?<!\w)`search`(?!\w)', '`web_search`', prompt)
+    prompt = re.sub(r'(?<!\w)`wiki`(?!\w)', '`wikipedia_search`', prompt)
+
+    # Replace function calls: search(...) -> web_search(...), wiki(...) -> wikipedia_search(...)
+    # This ensures we only catch function calls (not words like arxiv_search)
+    prompt = re.sub(r'(?<!\w)(?<!_)search\(', 'web_search(', prompt)
+    prompt = re.sub(r'(?<!\w)(?<!_)wiki\(', 'wikipedia_search(', prompt)
+
+    return prompt