Agent files

app.py

@@ -3,32 +3,46 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from smolagents import CodeAgent
+from helpers import download_file_from_url
+from llm import model
+from prompts import SYSTEM_PROMPT
+from tools import agent_tools
+from dotenv import load_dotenv
+
+load_dotenv()
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
+        agent = CodeAgent(model=model, tools=agent_tools, planning_interval=3)
+        self.agent = agent
+        self.agent.system_prompt = SYSTEM_PROMPT + "\n" + self.agent.system_prompt
+
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
+        fixed_answer = self.agent.run(question)
         print(f"Agent returning fixed answer: {fixed_answer}")
         return fixed_answer
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -37,6 +51,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
+    file_download_url = f"{api_url}/files"
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
@@ -55,16 +70,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
@@ -76,23 +91,46 @@ 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:
+            file_url = f"{file_download_url}/{task_id}"
+            file_path = download_file_from_url(file_url, file_name)
+            question_text = f"{question_text} (File: {file_path})"
         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)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            answers_payload.append(
+                {"task_id": task_id, "submitted_answer": submitted_answer}
+            )
+            results_log.append(
+                {
+                    "Task ID": task_id,
+                    "Question": question_text,
+                    "Submitted Answer": submitted_answer,
+                }
+            )
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append(
+                {
+                    "Task ID": task_id,
+                    "Question": question_text,
+                    "Submitted Answer": f"AGENT ERROR: {e}",
+                }
+            )
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    # 4. Prepare Submission
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
@@ -162,20 +200,19 @@ with gr.Blocks() as demo:
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False
+    )
     # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -183,14 +220,18 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:  # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+        print(
+            f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main"
+        )
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print(
+            "ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined."
+        )
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

helpers.py

@@ -0,0 +1,101 @@
+import base64
+import os
+from litellm import completion, create_file
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+DEFAULT_MODEL = os.getenv("GEMINI_MODEL")
+
+
+def analyze_file_with_gemini(file_path: str, file_name: str) -> str:
+    # 1. Read file and encode in base64
+    try:
+        with open(file_path, "rb") as f:
+            content = f.read()
+        mime_type = _get_mime_type(file_path)
+        base64_data = base64.b64encode(content).decode("utf-8")
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+    file = create_file(
+        file=base64_data,
+        purpose="user_data",
+        extra_body={"custom_llm_provider": "gemini"},
+        api_key=os.getenv("GEMINI_API_KEY"),
+    )
+    # 2. Construct Gemini-style multimodal input
+    prompt = (
+        f"Analyze the following {mime_type} file and provide a detailed report. "
+        "The file is encoded in base64 format. "
+        "Please include any relevant information or insights."
+    )
+
+    try:
+        response = completion(
+            model=DEFAULT_MODEL,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "file",
+                            "file": {
+                                "file_id": file.id,
+                                "filename": file_name,
+                                "format": "audio/wav",
+                            },
+                        },
+                    ],
+                },
+            ],
+        )
+
+        return response.choices[0].message
+    except Exception as e:
+        return f"Error from Gemini: {e}"
+
+
+def _get_mime_type(file_path: str) -> str:
+    if file_path.endswith(".png"):
+        return "image/png"
+    elif file_path.endswith(".jpg") or file_path.endswith(".jpeg"):
+        return "image/jpeg"
+    elif file_path.endswith(".mp3"):
+        return "audio/mpeg"
+    else:
+        raise ValueError(
+            "Unsupported file type: only .png, .jpg, .jpeg, .mp3 are supported"
+        )
+
+
+def download_file_from_url(url: str, save_dir: str = "./downloads") -> str:
+    """
+    Downloads a file from a public URL and saves it locally.
+
+    Args:
+        url (str): The direct URL to the file (must not be a blob: URL).
+        save_dir (str): Directory to save the downloaded file (default: ./downloads).
+
+    Returns:
+        str: Full path to the downloaded file.
+    """
+    try:
+        os.makedirs(save_dir, exist_ok=True)
+
+        # Get file name from the URL or fallback
+        local_filename = url.split("/")[-1] or "downloaded_file"
+        file_path = os.path.join(save_dir, local_filename)
+
+        # Perform streaming download
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(file_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+
+        return file_path
+    except Exception as e:
+        raise RuntimeError(f"Failed to download file from {url}: {e}")

llm.py

@@ -0,0 +1,37 @@
+# llm.py
+import os
+import litellm
+from smolagents import LiteLLMModel
+from dotenv import load_dotenv
+
+load_dotenv()
+# Set default model
+DEFAULT_MODEL = os.getenv("GEMINI_MODEL")
+
+
+def chat_with_llm(messages, model=DEFAULT_MODEL):
+    """
+    messages: list of {"role": "user"/"system"/"assistant", "content": "..."}
+    model: model string (e.g., "gemini-pro" or "gpt-3.5-turbo")
+    """
+    try:
+        response = litellm.completion(
+            model=model, messages=messages, api_key=os.getenv("GEMINI_API_KEY")
+        )
+        return response["choices"][0]["message"]["content"]
+    except Exception as e:
+        return f"[LLM Error] {e}"
+
+
+def ask_llm(prompt: str, model=DEFAULT_MODEL):
+    """
+    Simpler wrapper for single-turn prompts
+    """
+    return chat_with_llm([{"role": "user", "content": prompt}], model=model)
+
+
+model = LiteLLMModel(
+    model_id=DEFAULT_MODEL,
+    api_key=os.getenv("GEMINI_API_KEY"),
+    max_tokens=8192,
+)

prompts.py

@@ -0,0 +1,3 @@
+SYSTEM_PROMPT = """
+You are a general AI assistant. 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.
+"""

requirements.txt

@@ -1,2 +1,8 @@
 gradio
-requests
+requests
+smolagents
+smolagents[litellm]
+pytesseract
+pillow
+pytube
+python-dotenv

tools.py

@@ -0,0 +1,515 @@
+import base64
+import os
+from smolagents import Tool
+import math
+import datetime
+from PIL import Image
+import pandas as pd
+import litellm
+from prompts import SYSTEM_PROMPT
+from pytube import YouTube
+from PIL import Image
+import pytesseract
+from smolagents import DuckDuckGoSearchTool
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class GeminiFileAnalyzerTool(Tool):
+    name = "gemini_file_analyzer"
+    description = "Analyze an image or audio file using Gemini via LiteLLM. Supports jpg, png, and mp3."
+    inputs = {
+        "file_path": {"type": "string", "description": "Path to image/audio file"},
+        "file_name": {
+            "type": "string",
+            "description": "Name of the file (e.g., photo.jpg, audio.mp3)",
+        },
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str, file_name: str):
+        try:
+            with open(file_path, "rb") as f:
+                content = f.read()
+            mime_type = self._get_mime_type(file_path)
+            base64_data = base64.b64encode(content).decode("utf-8")
+        except Exception as e:
+            return f"Error reading file: {e}"
+
+        try:
+            file = litellm.create_file(
+                file=base64_data,
+                purpose="user_data",
+                extra_body={"custom_llm_provider": "gemini"},
+                api_key=os.getenv("GEMINI_API_KEY"),
+            )
+        except Exception as e:
+            return f"Error uploading file: {e}"
+
+        prompt = (
+            f"Analyze the following {mime_type} file and provide a detailed report. "
+            "The file is encoded in base64 format. "
+            "Please include any relevant information or insights."
+        )
+
+        try:
+            response = litellm.completion(
+                model=os.getenv("GEMINI_MODEL", "gemini-pro-vision"),
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "file",
+                                "file": {
+                                    "file_id": file.id,
+                                    "filename": file_name,
+                                    "format": mime_type.split("/")[-1],  # e.g., "mp3"
+                                },
+                            },
+                        ],
+                    },
+                ],
+            )
+            return response["choices"][0]["message"]["content"]
+        except Exception as e:
+            return f"Error from Gemini: {e}"
+
+    def _get_mime_type(self, file_path: str) -> str:
+        if file_path.endswith(".png"):
+            return "image/png"
+        elif file_path.endswith(".jpg") or file_path.endswith(".jpeg"):
+            return "image/jpeg"
+        elif file_path.endswith(".mp3"):
+            return "audio/mpeg"
+        else:
+            raise ValueError(
+                "Unsupported file type: only .png, .jpg, .jpeg, .mp3 are supported"
+            )
+
+
+class ImageTextExtractorTool(Tool):
+    name = "image_text_extractor"
+    description = "Extract text from an image using OCR."
+    inputs = {
+        "image_path": {
+            "type": "string",
+            "description": "Path to the image file (jpg, png, etc.)",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, image_path: str):
+        try:
+            image = Image.open(image_path)
+            text = pytesseract.image_to_string(image)
+            return text.strip() or "No text found in image."
+        except Exception as e:
+            return f"Error extracting text: {e}"
+
+
+class TableInspectorTool(Tool):
+    name = "table_inspector"
+    description = "Load a CSV or Excel file and return table info and summary stats in Markdown format."
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to CSV or Excel file (.csv, .xls, .xlsx)",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str):
+        try:
+            if file_path.endswith(".csv"):
+                df = pd.read_csv(file_path)
+            elif file_path.endswith(".xls") or file_path.endswith(".xlsx"):
+                df = pd.read_excel(file_path)
+            else:
+                return "Unsupported file type. Only CSV and Excel (.xls/.xlsx) are supported."
+
+            # Get basic info
+            n_rows, n_cols = df.shape
+            headers = list(df.columns)
+            summary = (
+                df.describe(include="all", datetime_is_numeric=True)
+                .fillna("")
+                .astype(str)
+            )
+
+            # Markdown output
+            md = f"### File loaded: **{file_path}**\n"
+            md += f"- Rows: **{n_rows}**\n"
+            md += f"- Columns: **{n_cols}**\n"
+            md += f"- Column Headers:\n"
+            for col in headers:
+                md += f"  - `{col}`\n"
+
+            md += "\n### Summary Statistics (markdown table):\n\n"
+            md += summary.to_markdown()
+
+            return md
+
+        except Exception as e:
+            return f"Error loading file: {str(e)}"
+
+
+class YouTubeVideoAnalyzerTool(Tool):
+    name = "youtube_video_analyzer"
+    description = "Given a YouTube URL, extracts metadata and comments, then analyzes it for summary, highlights, and visuals."
+    inputs = {
+        "url": {"type": "string", "description": "Full YouTube video URL"},
+        "user_prompt": {
+            "type": "string",
+            "description": "What you want to analyze from the video content",
+        },
+    }
+    output_type = "string"
+
+    def forward(self, url: str, user_prompt: str):
+        try:
+            yt = YouTube(url)
+            title = yt.title
+            description = yt.description
+            comments = yt.comments[:5] if yt.comments else []
+
+            comment_text = (
+                "\n".join([f"- {c}" for c in comments])
+                if comments
+                else "No comments found."
+            )
+
+            system_prompt = f"""You are an AI video analyzer. A user wants to analyze the following YouTube video.
+
+### Title
+{title}
+
+### Description
+{description or 'No description.'}
+
+### Top Comments
+{comment_text}
+
+### User Request
+{user_prompt}
+
+### Instructions:
+- Identify the main topic of the video.
+- List any unique characteristics or production traits.
+- Mention key highlights or scenes if they are implied.
+- Give an overall summary based on description and social sentiment.
+
+Respond in structured markdown.
+"""
+
+            response = litellm.completion(
+                api_key=os.getenv("GEMINI_API_KEY"),
+                model=os.getenv("GEMINI_MODEL"),
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": system_prompt},
+                ],
+            )
+
+            return response["choices"][0]["message"]["content"]
+
+        except Exception as e:
+            return f"Error analyzing video: {e}"
+
+
+# --- Math Tools ---
+class CalculatorTool(Tool):
+    name = "calculator"
+    description = (
+        "Evaluate a basic mathematical expression (supports +, -, *, /, **, %, etc.)."
+    )
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "A mathematical expression to evaluate",
+        }
+    }
+    output_type = "number"
+
+    def forward(self, expression: str):
+        # Safely evaluate the expression using ast
+        import ast, operator
+
+        # Allowed node types
+        allowed_nodes = {
+            ast.Expression,
+            ast.BinOp,
+            ast.UnaryOp,
+            ast.Num,
+            ast.Constant,
+            ast.Add,
+            ast.Sub,
+            ast.Mult,
+            ast.Div,
+            ast.Pow,
+            ast.Mod,
+            ast.USub,
+            ast.UAdd,
+        }
+        node = ast.parse(expression, mode="eval")
+        for subnode in ast.walk(node):
+            if type(subnode) not in allowed_nodes:
+                raise ValueError(f"Unsafe or unsupported expression: {expression}")
+        return eval(compile(node, "<string>", "eval"))
+
+
+# Optionally, separate basic operations could be defined (e.g., add, subtract).
+class AddTool(Tool):
+    name = "add"
+    description = "Add two numbers together."
+    inputs = {
+        "a": {"type": "number", "description": "First number"},
+        "b": {"type": "number", "description": "Second number"},
+    }
+    output_type = "number"
+
+    def forward(self, a: float, b: float):
+        return a + b
+
+
+class MultiplyTool(Tool):
+    name = "multiply"
+    description = "Multiply two numbers."
+    inputs = {
+        "a": {"type": "number", "description": "First number"},
+        "b": {"type": "number", "description": "Second number"},
+    }
+    output_type = "number"
+
+    def forward(self, a: float, b: float):
+        return a * b
+
+
+# --- Date/Time Tools ---
+class DayOfWeekTool(Tool):
+    name = "day_of_week"
+    description = "Return the day of week for a given date (YYYY-MM-DD)."
+    inputs = {"date": {"type": "string", "description": "Date in format YYYY-MM-DD"}}
+    output_type = "string"
+
+    def forward(self, date: str):
+        year, month, day = map(int, date.split("-"))
+        dow = datetime.date(year, month, day).strftime("%A")
+        return dow
+
+
+class AddDaysTool(Tool):
+    name = "add_days"
+    description = "Add a number of days to a date (YYYY-MM-DD)."
+    inputs = {
+        "date": {"type": "string", "description": "Start date (YYYY-MM-DD)"},
+        "days": {"type": "integer", "description": "Number of days to add"},
+    }
+    output_type = "string"
+
+    def forward(self, date: str, days: int):
+        year, month, day = map(int, date.split("-"))
+        new_date = datetime.date(year, month, day) + datetime.timedelta(days=days)
+        return new_date.isoformat()
+
+
+class DateDiffTool(Tool):
+    name = "date_diff"
+    description = "Compute difference in days between two dates (YYYY-MM-DD)."
+    inputs = {
+        "start_date": {"type": "string", "description": "First date (YYYY-MM-DD)"},
+        "end_date": {"type": "string", "description": "Second date (YYYY-MM-DD)"},
+    }
+    output_type = "integer"
+
+    def forward(self, start_date: str, end_date: str):
+        y1, m1, d1 = map(int, start_date.split("-"))
+        y2, m2, d2 = map(int, end_date.split("-"))
+        d0 = datetime.date(y1, m1, d1)
+        d1 = datetime.date(y2, m2, d2)
+        return abs((d1 - d0).days)
+
+
+# --- Unit Conversion Tools ---
+class TempConvertTool(Tool):
+    name = "convert_temperature"
+    description = "Convert temperature between Celsius and Fahrenheit."
+    inputs = {
+        "value": {"type": "number", "description": "Temperature value to convert"},
+        "from_unit": {"type": "string", "description": "Unit of input ('C' or 'F')"},
+    }
+    output_type = "number"
+
+    def forward(self, value: float, from_unit: str):
+        unit = from_unit.strip().upper()
+        if unit == "C":
+            # Celsius to Fahrenheit
+            return value * 9 / 5 + 32
+        elif unit == "F":
+            # Fahrenheit to Celsius
+            return (value - 32) * 5 / 9
+        else:
+            raise ValueError("Unit must be 'C' or 'F'.")
+
+
+class LengthConvertTool(Tool):
+    name = "convert_length"
+    description = "Convert length between kilometers, miles, meters, and feet."
+    inputs = {
+        "value": {"type": "number", "description": "Length value to convert"},
+        "from_unit": {
+            "type": "string",
+            "description": "Original unit ('km','mi','m','ft')",
+        },
+        "to_unit": {
+            "type": "string",
+            "description": "Target unit ('km','mi','m','ft')",
+        },
+    }
+    output_type = "number"
+
+    def forward(self, value: float, from_unit: str, to_unit: str):
+        u1 = from_unit.lower()
+        u2 = to_unit.lower()
+        # Convert input to meters first
+        if u1 == "km":
+            meters = value * 1000
+        elif u1 == "m":
+            meters = value
+        elif u1 == "mi":
+            meters = value * 1609.34
+        elif u1 == "ft":
+            meters = value * 0.3048
+        else:
+            raise ValueError("Unsupported from_unit")
+        # Convert meters to target unit
+        if u2 == "km":
+            return meters / 1000
+        if u2 == "m":
+            return meters
+        if u2 == "mi":
+            return meters / 1609.34
+        if u2 == "ft":
+            return meters / 0.3048
+        raise ValueError("Unsupported to_unit")
+
+
+# --- Text Tools ---
+class WordCountTool(Tool):
+    name = "word_count"
+    description = "Count the number of words in a text string."
+    inputs = {"text": {"type": "string", "description": "Input text"}}
+    output_type = "integer"
+
+    def forward(self, text: str):
+        return len(text.split())
+
+
+class FindTextTool(Tool):
+    name = "find_text"
+    description = "Find occurrences of a substring in a text; returns count."
+    inputs = {
+        "text": {"type": "string", "description": "Text to search in"},
+        "query": {"type": "string", "description": "Substring to search for"},
+    }
+    output_type = "integer"
+
+    def forward(self, text: str, query: str):
+        return text.count(query)
+
+
+# --- List/Sequence Tools ---
+class SortListTool(Tool):
+    name = "sort_list"
+    description = "Sort a list of items (numbers or strings)."
+    inputs = {"items": {"type": "array", "description": "List of items to sort"}}
+    output_type = "array"
+
+    def forward(self, items):
+        return sorted(items)
+
+
+class UniqueListTool(Tool):
+    name = "unique_list"
+    description = "Return a list with duplicate items removed (preserving order)."
+    inputs = {"items": {"type": "array", "description": "List of items"}}
+    output_type = "array"
+
+    def forward(self, items):
+        seen = []
+        for x in items:
+            if x not in seen:
+                seen.append(x)
+        return seen
+
+
+# --- File I/O Tools ---
+class ReadFileTool(Tool):
+    name = "read_file"
+    description = "Read and return the contents of a text file."
+    inputs = {"file_path": {"type": "string", "description": "Path to a text file"}}
+    output_type = "string"
+
+    def forward(self, file_path: str):
+        try:
+            with open(file_path, "r") as f:
+                return f.read()
+        except FileNotFoundError:
+            return f"Error: File not found: {file_path}"
+
+
+class WriteFileTool(Tool):
+    name = "write_file"
+    description = "Write a string to a text file (overwrites if exists)."
+    inputs = {
+        "file_path": {"type": "string", "description": "Path to write the file"},
+        "content": {"type": "string", "description": "Content to write"},
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str, content: str):
+        with open(file_path, "w") as f:
+            f.write(content)
+        return f"Wrote to {file_path}"
+
+
+# --- Image Tool (stub) ---
+class ImageInfoTool(Tool):
+    name = "image_info"
+    description = "Load an image and report basic info (size and mode)."
+    inputs = {"image_path": {"type": "string", "description": "Path to an image file"}}
+    output_type = "string"
+
+    def forward(self, image_path: str):
+        try:
+            img = Image.open(image_path)
+            return f"Image {image_path}: size={img.size}, mode={img.mode}"
+        except Exception as e:
+            return f"Error loading image: {e}"
+
+
+# List of all available tools
+agent_tools = [
+    GeminiFileAnalyzerTool(),
+    ImageTextExtractorTool(),
+    TableInspectorTool(),
+    YouTubeVideoAnalyzerTool(),
+    CalculatorTool(),
+    AddTool(),
+    MultiplyTool(),
+    DayOfWeekTool(),
+    AddDaysTool(),
+    DateDiffTool(),
+    TempConvertTool(),
+    LengthConvertTool(),
+    WordCountTool(),
+    FindTextTool(),
+    SortListTool(),
+    UniqueListTool(),
+    ReadFileTool(),
+    WriteFileTool(),
+    ImageInfoTool(),
+    DuckDuckGoSearchTool(),
+]