changes, new tools

app.py

@@ -11,14 +11,14 @@ from langgraph.graph.message import add_messages
 from typing import TypedDict, Annotated
 from tools import (
     image_recognition_tool,
-    download_file_tool,
+    download_file,
     reverse_text_tool,
-    hub_stats_tool,
-    web_search_tool,
+    serp_search_tool,
     python_execution_tool,
     video_analysis_tool,
     audio_processing_tool,
-    file_type_detection_tool
+    file_type_detection_tool,
+    read_file_tool
 )
 
 # (Keep Constants as is)
@@ -28,15 +28,15 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # Setting up the llm
 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
 tools = [
-    web_search_tool,
-    hub_stats_tool,
-    download_file_tool,
+    serp_search_tool,
+    download_file,
     image_recognition_tool,
     reverse_text_tool,
     python_execution_tool,
     video_analysis_tool,
     audio_processing_tool,
-    file_type_detection_tool
+    file_type_detection_tool,
+    read_file_tool
 ]
 chat_with_tools = llm.bind_tools(tools)
 
@@ -47,18 +47,79 @@ class MyAgent(TypedDict):
     messages: Annotated[list[AnyMessage], add_messages]
 
 
+# =========================
+# File Handling Functions
+# =========================
+def process_question_with_files(question_data: dict) -> str:
+    """
+    Process a question that may have attached files.
+    Downloads and processes files, then combines with the question.
+    """
+    question_text = question_data.get('question', '')
+    file_name = question_data.get('file_name', '')
+
+    if not file_name:
+        return question_text
+
+    print(f"📎 Processing question with attached file: {file_name}")
+    try:
+        # Download the file from the API
+        file_url = f"{DEFAULT_API_URL}/files/{file_name}"
+        local_file_path = f"/tmp/{file_name}"
+        print(f"📥 Downloading file from: {file_url}")
+        download_result = download_file(file_url, local_file_path)
+        print(f"📥 Download result: {download_result}")
+        if "Failed to download" in download_result:
+            return f"{question_text}\n\n[Note: Could not download attached file {file_name}]"
+        # Detect file type
+        file_extension = file_name.lower().split('.')[-1]
+        if file_extension in ['png', 'jpg', 'jpeg', 'gif', 'bmp']:
+            print(f"🖼️ Processing image file: {file_name}")
+            image_result = image_recognition_tool.invoke(local_file_path)
+            enhanced_question = f"{question_text}\n\n[Image Analysis: {image_result}]"
+        elif file_extension in ['mp3', 'wav', 'm4a', 'flac', 'ogg']:
+            print(f"🎵 Processing audio file: {file_name}")
+            audio_result = audio_processing_tool.invoke(local_file_path)
+            enhanced_question = f"{question_text}\n\n[Audio Transcription: {audio_result}]"
+        elif file_extension in ['xls', 'xlsx', 'csv']:
+            print(f"📊 Processing spreadsheet file: {file_name}")
+            file_content = read_file_tool.invoke(local_file_path)
+            enhanced_question = f"{question_text}\n\n[Spreadsheet Content: {file_content}]"
+        elif file_extension == 'py':
+            print(f"🐍 Processing Python file: {file_name}")
+            code_content = read_file_tool.invoke(local_file_path)
+            enhanced_question = f"{question_text}\n\n[Python Code: {code_content}]"
+        else:
+            print(f"📄 Processing general file: {file_name}")
+            file_content = read_file_tool.invoke(local_file_path)
+            enhanced_question = f"{question_text}\n\n[File Content: {file_content}]"
+        try:
+            os.remove(local_file_path)
+            print(f"🧹 Cleaned up temporary file: {local_file_path}")
+        except:
+            pass
+        return enhanced_question
+    except Exception as e:
+        print(f"❌ Error processing file {file_name}: {e}")
+        return f"{question_text}\n\n[Note: Error processing attached file {file_name}: {str(e)}]"
+
+
 class AgentWrapper:
     def __init__(self):
         print("AgentWrapper initialized.")
 
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-
-        # Use the LangGraph agent to process the question
+    def __call__(self, question_data: dict | str) -> str:
+        if isinstance(question_data, str):
+            question_text = question_data
+            print(
+                f"Agent received question (first 50 chars): {question_text[:50]}...")
+        else:
+            question_text = process_question_with_files(question_data)
+            print(
+                f"Agent received enhanced question (first 50 chars): {question_text[:50]}...")
         try:
             result = my_agent.invoke(
-                {"messages": [HumanMessage(content=question)]})
-            # Get the last message from the result
+                {"messages": [HumanMessage(content=question_text)]})
             last_message = result["messages"][-1]
             answer = last_message.content
             print(f"Agent returning answer: {answer}")
@@ -78,16 +139,40 @@ Your answer should be a number OR as few words as possible OR a comma-separated
 If you're asked for a number, don't use commas or units like $ or %, unless specified.
 If you're asked for a string, don't use articles or abbreviations (e.g. for cities), and write digits in plain text unless told otherwise.
 
-    Tool Use Guidelines:
-    1. Do **not** use any tools outside of the provided tools list.
-    2. Always use **only one tool at a time** in each step of your execution.
-    3. For HuggingFace Hub information (models, authors, downloads), use **get_hub_stats** tool.    
-    4. For web searches and current information, use **web_search_tool** .
-    5. If the question looks reversed (starts with a period or reads backward), first use **reverse_text_tool** to reverse it, then process the question.
-    6. When you need to download files from URLs, use **download_file_tool**.
-    7. For image analysis and description, use **image_recognition_tool** (requires OpenAI API key).
-    8. Even for complex tasks, assume a solution exists. If one method fails, try another approach using different tools.
-    9. Keep responses concise and efficient.""")
+IMPORTANT: You have a maximum of 3 tool uses per question. After 3 tool uses, you MUST provide your best answer based on available information.
+
+DECISION MAKING:
+1. First, try to answer from your knowledge if it's a general fact.
+2. If you need specific, current, or detailed information, use serp_search_tool ONCE.
+3. If the question looks reversed (starts with a period), use reverse_text_tool ONCE first.
+4. For file-based questions, use the appropriate file tool.
+5. After using a tool, analyze the result and provide your final answer.
+6. Do NOT cycle between tools unnecessarily.
+
+Tool Use Guidelines:
+1. Do **not** use any tools outside of the provided tools list.
+2. Always use **only one tool at a time** in each step of your execution.
+3. You have a MAXIMUM of 3 tool uses per question.
+4. For web searches and current information, use **serp_search_tool** (15s timeout).
+5. If the question looks reversed (starts with a period or reads backward), first use **reverse_text_tool** to reverse it, then process the question.
+6. For image analysis and description, use **image_recognition_tool** (requires OpenAI API key).
+7. For Python code execution, use **python_execution_tool**.
+8. For video analysis, use **video_analysis_tool**.
+9. For audio processing, use **audio_processing_tool**.
+10. For file type detection, use **file_type_detection_tool**.
+11. For reading file contents, use **read_file_tool**.
+12. File downloading is handled automatically - you don't need to download files manually.
+13. Keep responses concise and efficient.
+14. If you can't find the answer after using 2-3 tools, provide your best estimate based on available information.
+15. NEVER use more than 3 tools for a single question.
+16. After using a tool, provide your final answer immediately.
+
+FILE PROCESSING:
+- Questions may come with attached files (mp3, excel, images, etc.)
+- File processing is automatically handled before the question reaches you
+- If a file is attached, you'll see the file content/analysis in the question
+- Focus on answering based on the enhanced question that includes file information
+- You don't need to process files manually - just use the information provided""")
 
     # Combine system message with user messages
     all_messages = [system_message] + state["messages"]

requirements.txt

@@ -11,10 +11,10 @@ transformers
 torch
 pillow
 python-dotenv
-duckduckgo-search
 pandas
 datasets
 langchain-huggingface
-pathlib
-SpeechRecognition
-librosa
+pydub
+google-search-results
+pytesseract
+numpy 

tools.py

@@ -1,76 +1,151 @@
-from io import BytesIO
-import requests
-from PIL import Image as PILImage
-from transformers import BlipProcessor, BlipForConditionalGeneration
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage
-from huggingface_hub import list_models
-import random
-import pprint
-from langchain_community.tools import DuckDuckGoSearchRun
-from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
-from langgraph.prebuilt import tools_condition
-from langgraph.graph import START, StateGraph
-
-from langgraph.prebuilt import ToolNode
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage
-from langgraph.graph.message import add_messages
-from typing import TypedDict, Annotated
-from langchain.tools import Tool
-from langchain_community.retrievers import BM25Retriever
-from langchain.docstore.document import Document
-import datasets
-from langchain_openai import ChatOpenAI
-from dotenv import load_dotenv
+# =========================
+# Imports and Environment
+# =========================
 import os
-import torch
-import base64
+import requests
 import subprocess
 import tempfile
-import json
-import re
+import base64
+import io
 from pathlib import Path
+from dotenv import load_dotenv
+from typing import TypedDict, Annotated
+from huggingface_hub import list_models
+from langchain.tools import Tool
+from langchain_community.utilities import SerpAPIWrapper
+from langchain_core.messages import HumanMessage
+from langchain_huggingface import ChatHuggingFace
+from langchain_openai import ChatOpenAI
+import openai
+from pydub import AudioSegment
+import pandas as pd
+from PIL import Image
 
 # Load environment variables
-load_dotenv()
+print("Current working directory:", os.getcwd())
+
+load_dotenv(dotenv_path=os.path.join(os.path.dirname(__file__), ".env"))
+# =========================
+# 1. Web Search Tools
+# =========================
+
+
+def serp_search(query: str) -> str:
+    """
+    Searches the web using SerpAPI and returns the top result snippet.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The top result snippet or an error message.
+    """
+    try:
+        search = SerpAPIWrapper()
+        results = search.run(query)
+        return results
+    except Exception as e:
+        return f"Search failed: {e}"
 
-# DEFINE HUB STAT TOOLS
 
+serp_search_tool = Tool(
+    name="serp_search_tool",
+    func=serp_search,
+    description="Searches the web using SerpAPI and returns the top result."
+)
 
-def get_hub_stats(author: str) -> str:
-    """Fetches the most downloaded model from a specific author on the Hugging Face Hub."""
-    try:
-        # List models from the specified author, sorted by downloads
-        models = list(list_models(
-            author=author, sort="downloads", direction=-1, limit=1))
 
-        if models:
-            model = models[0]
-            return f"The most downloaded model by {author} is {model.id} with {model.downloads:,} downloads."
-        else:
-            return f"No models found for author {author}."
+# =========================
+# 2. File Download/Handling Tools
+# =========================
+
+# Note: File downloading is now handled in app.py via process_question_with_files()
+# This section is kept for reference but the download_file_tool is not exported
+
+def download_file(url: str, save_path: str) -> str:
+    """
+    Downloads a file from a URL and saves it to the given path.
+    Args:
+        url (str): The URL from which to download the file.
+        save_path (str): The local file path where the downloaded file will be saved.
+    Returns:
+        str: A message indicating the result of the download operation.
+    """
+    try:
+        # Reduced from 30 to 15 seconds
+        response = requests.get(url, timeout=15)
+        response.raise_for_status()
+        with open(save_path, "wb") as f:
+            f.write(response.content)
+        return f"File downloaded to {save_path}"
     except Exception as e:
-        return f"Error fetching models for {author}: {str(e)}"
+        return f"Failed to download: {e}"
 
 
-# Initialize the tool
-hub_stats_tool = Tool(
-    name="get_hub_stats",
-    func=get_hub_stats,
-    description="Search HuggingFace Hub for model statistics, downloads, and author information. Use this when asking about specific models, authors, or HuggingFace Hub data."
-)
+# download_file_tool is now used internally by process_question_with_files() in app.py
+# and is not exported as a standalone tool for the agent
+
+# =========================
+# 3. Python Execution Tools
+# =========================
+
+
+def RunPythonFileTool(file_path: str) -> str:
+    """
+    Executes a Python script loaded from the specified path using the PythonInterpreterTool if available, otherwise subprocess.
+    Args:
+        file_path (str): The full path to the python (.py) file containing the Python code.
+    Returns:
+        str: The output produced by the code execution, or an error message if it fails.
+    """
+    try:
+        if not os.path.exists(file_path):
+            return f"File not found: {file_path}"
+        with open(file_path, "r") as f:
+            code = f.read()
+        try:
+            from langchain.tools.python.tool import PythonInterpreterTool
+            interpreter = PythonInterpreterTool()
+            result = interpreter.run({"code": code})
+            return result.get("output", "No output returned.")
+        except ImportError:
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp:
+                temp.write(code)
+                temp_path = temp.name
+            result = subprocess.run(
+                ["python", temp_path],
+                capture_output=True,
+                text=True,
+                timeout=15
+            )
+            os.unlink(temp_path)
+            if result.returncode == 0:
+                return result.stdout.strip() or "No output returned."
+            else:
+                return f"Error: {result.stderr.strip()}"
+    except subprocess.TimeoutExpired:
+        return "Error: Code execution timed out"
+    except Exception as e:
+        return f"Execution failed: {e}"
+
 
-# DEFINE WEB SEARCH TOOLS
-web_search_tool = Tool(
-    name="search_tool",
-    func=DuckDuckGoSearchRun(),
-    description="Search the general web for current information, news, and general knowledge. Use this for questions about companies, people, events, etc."
+python_execution_tool = Tool(
+    name="python_execution_tool",
+    func=RunPythonFileTool,
+    description="Executes Python code and returns the output. Use this when you need to run Python scripts or calculate values."
 )
 
-# REVERSE TOOLS
+# =========================
+# 4. Text Utilities
+# =========================
 
 
 def ReverseTextTool(text: str) -> str:
-    """Reverses the order of characters in a given text string."""
+    """
+    Reverses the order of characters in a given text string.
+    Args:
+        text (str): The text to reverse.
+    Returns:
+        str: The reversed text or an error message.
+    """
     try:
         return text[::-1]
     except Exception as e:
@@ -83,85 +158,102 @@ reverse_text_tool = Tool(
     description="Reverses the order of characters in a given text string. Use this when you need to reverse text."
 )
 
-# DOWNLOAD A FILE
-
-
-def download_file(url: str) -> str:
-    """Downloads a file from a given URL and returns the local file path."""
-    try:
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-
-        # Define save_path - extract filename from URL
-        filename = url.split(
-            '/')[-1] if url.split('/')[-1] else 'downloaded_file'
-        save_path = f"./{filename}"
 
-        with open(save_path, "wb") as f:
-            f.write(response.content)
-        return save_path
-    except Exception as e:
-        return f"Failed to download: {e}"
+# =========================
+# 5. Audio, Video, and Image Tools
+# =========================
 
 
-download_file_tool = Tool(
-    name="download_file_tool",
-    func=download_file,
-    description="Downloads a file from a given URL and returns the local file path."
-)
+def process_audio(audio_file_path: str) -> str:
+    """
+    Processes audio files to extract information and transcribe speech content.
+    Args:
+        audio_file_path (str): Path to the audio file.
+    Returns:
+        str: Transcription result or file info with error message.
+    """
+    try:
+        if not os.path.exists(audio_file_path):
+            return f"Audio file not found: {audio_file_path}"
 
-# PYTHON CODE EXECUTION TOOL
+        file_extension = Path(audio_file_path).suffix.lower()
+
+        # Check if it's an audio file we can process
+        if file_extension not in ['.mp3', '.wav', '.m4a', '.flac', '.ogg']:
+            file_size = os.path.getsize(audio_file_path)
+            return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. Unsupported audio format for transcription."
+
+        # Try to transcribe the audio
+        try:
+            # Initialize OpenAI client
+            client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+            # Convert MP3 to WAV if needed (Whisper works better with WAV)
+            if file_extension == '.mp3':
+                audio = AudioSegment.from_mp3(audio_file_path)
+                # Export as WAV to a temporary buffer
+                wav_buffer = io.BytesIO()
+                audio.export(wav_buffer, format="wav")
+                wav_buffer.seek(0)
+
+                # Use the WAV buffer for transcription
+                transcription = client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=wav_buffer,
+                    response_format="text"
+                )
+            else:
+                # For other formats, try direct transcription
+                with open(audio_file_path, "rb") as audio_file:
+                    transcription = client.audio.transcriptions.create(
+                        model="whisper-1",
+                        file=audio_file,
+                        response_format="text"
+                    )
 
+            file_size = os.path.getsize(audio_file_path)
+            return f"Transcription successful!\nFile: {audio_file_path}\nSize: {file_size} bytes\nType: {file_extension}\n\nTranscription:\n{transcription}"
 
-def execute_python_code(code: str) -> str:
-    """Executes Python code and returns the output."""
-    try:
-        # Create a temporary file to execute the code
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-            f.write(code)
-            temp_file = f.name
+        except openai.AuthenticationError:
+            file_size = os.path.getsize(audio_file_path)
+            return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. OpenAI API key not found or invalid. Please set OPENAI_API_KEY in your environment variables."
 
-        # Execute the code
-        result = subprocess.run(['python', temp_file],
-                                capture_output=True, text=True, timeout=30)
+        except openai.BadRequestError as e:
+            file_size = os.path.getsize(audio_file_path)
+            return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. Audio format not supported or file too large: {str(e)}"
 
-        # Clean up
-        os.unlink(temp_file)
+        except Exception as e:
+            file_size = os.path.getsize(audio_file_path)
+            return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. Transcription error: {str(e)}"
 
-        if result.returncode == 0:
-            return f"Output: {result.stdout.strip()}"
-        else:
-            return f"Error: {result.stderr.strip()}"
-    except subprocess.TimeoutExpired:
-        return "Error: Code execution timed out"
     except Exception as e:
-        return f"Error executing Python code: {str(e)}"
+        return f"Error processing audio: {str(e)}"
 
 
-python_execution_tool = Tool(
-    name="python_execution_tool",
-    func=execute_python_code,
-    description="Executes Python code and returns the output. Use this when you need to run Python scripts or calculate values."
+audio_processing_tool = Tool(
+    name="audio_processing_tool",
+    func=process_audio,
+    description="Transcribes audio files (MP3, WAV, M4A, FLAC, OGG) to text using speech recognition. Use this when you need to convert speech in audio files to text."
 )
 
-# VIDEO ANALYSIS TOOL
-
 
 def analyze_video(video_url: str) -> str:
-    """Analyzes video content from YouTube or other video URLs."""
+    """
+    Analyzes video content from YouTube or other video URLs.
+    Args:
+        video_url (str): The video URL.
+    Returns:
+        str: Video analysis or an error message.
+    """
     try:
-        # Extract video ID from YouTube URL
         if 'youtube.com' in video_url or 'youtu.be' in video_url:
-            # For YouTube videos, we can extract some basic info
             video_id = None
             if 'youtube.com/watch?v=' in video_url:
                 video_id = video_url.split('watch?v=')[1].split('&')[0]
             elif 'youtu.be/' in video_url:
                 video_id = video_url.split('youtu.be/')[1].split('?')[0]
-
             if video_id:
-                # Use web search to get video information
-                search_result = web_search_tool.func(
+                search_result = serp_search(
                     f"youtube video {video_id} title description")
                 return f"Video analysis for {video_id}: {search_result}"
             else:
@@ -178,89 +270,39 @@ video_analysis_tool = Tool(
     description="Analyzes video content from URLs. Use this when questions involve video content or YouTube links."
 )
 
-# AUDIO PROCESSING TOOL
-
-
-def process_audio(audio_file_path: str) -> str:
-    """Processes audio files to extract information."""
-    try:
-        if not os.path.exists(audio_file_path):
-            return f"Audio file not found: {audio_file_path}"
-
-        # For now, return basic file info
-        file_size = os.path.getsize(audio_file_path)
-        file_extension = Path(audio_file_path).suffix
-
-        return f"Audio file: {audio_file_path}, Size: {file_size} bytes, Type: {file_extension}. Audio processing requires additional libraries like speech_recognition or librosa."
-    except Exception as e:
-        return f"Error processing audio: {str(e)}"
-
-
-audio_processing_tool = Tool(
-    name="audio_processing_tool",
-    func=process_audio,
-    description="Processes audio files to extract information. Use this when questions involve audio files or MP3 content."
-)
-
-# ENHANCED IMAGE RECOGNITION TOOLS
-
-
-def create_vision_llm():
-    """Creates a vision-capable LLM with proper error handling."""
-    try:
-        # Check if OpenAI API key is available
-        if not os.getenv("OPENAI_API_KEY"):
-            return None, "OpenAI API key not found. Please set OPENAI_API_KEY in your environment variables."
-
-        vision_llm = ChatOpenAI(model="gpt-4o")
-        return vision_llm, None
-    except Exception as e:
-        return None, f"Error creating vision LLM: {str(e)}"
+# =========================
+# 6. Image Recognition Tools
+# =========================
 
 
 def image_recognition(img_path: str) -> str:
-    """Analyzes and describes the content of images using AI vision."""
+    """
+    Analyzes and describes the content of images using AI vision.
+    Args:
+        img_path (str): Path to the image file.
+    Returns:
+        str: Description or extracted text, or an error message.
+    """
     try:
-        # Check if file exists
         if not os.path.exists(img_path):
             return f"Error: Image file not found at {img_path}"
-
-        # Create vision LLM
-        vision_llm, error = create_vision_llm()
-        if error:
-            return error
-
-        # Read image and encode as base64
+        if not os.getenv("OPENAI_API_KEY"):
+            return "OpenAI API key not found. Please set OPENAI_API_KEY in your environment variables."
+        vision_llm = ChatOpenAI(model="gpt-4o")
         with open(img_path, "rb") as image_file:
             image_bytes = image_file.read()
-
         image_base64 = base64.b64encode(image_bytes).decode("utf-8")
-
-        # Prepare the prompt including the base64 image data
         message = [
             HumanMessage(
                 content=[
-                    {
-                        "type": "text",
-                        "text": (
-                            "Describe the image or extract all the text from this image. "
-                            "Return only the description or extracted text, no explanations."
-                        ),
-                    },
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/png;base64,{image_base64}"
-                        },
-                    },
+                    {"type": "text", "text": "Describe the image or extract all the text from this image. Return only the description or extracted text, no explanations."},
+                    {"type": "image_url", "image_url": {
+                        "url": f"data:image/png;base64,{image_base64}"}},
                 ]
             )
         ]
-
-        # Call the vision-capable model
         response = vision_llm.invoke(message)
         return response.content.strip()
-
     except Exception as e:
         return f"Error analyzing image: {str(e)}"
 
@@ -271,18 +313,24 @@ image_recognition_tool = Tool(
     description="Analyzes and describes the content of images using AI vision. Use this when you need to understand what's in an image."
 )
 
-# FILE TYPE DETECTION TOOL
+# =========================
+# 7. File Type Detection
+# =========================
 
 
 def detect_file_type(file_path: str) -> str:
-    """Detects the type of file and provides appropriate handling suggestions."""
+    """
+    Detects the type of file and provides appropriate handling suggestions.
+    Args:
+        file_path (str): Path to the file.
+    Returns:
+        str: File type info or an error message.
+    """
     try:
         if not os.path.exists(file_path):
             return f"File not found: {file_path}"
-
         file_extension = Path(file_path).suffix.lower()
         file_size = os.path.getsize(file_path)
-
         file_types = {
             '.py': 'Python script',
             '.mp3': 'Audio file',
@@ -297,7 +345,6 @@ def detect_file_type(file_path: str) -> str:
             '.xls': 'Excel spreadsheet',
             '.xlsx': 'Excel spreadsheet'
         }
-
         file_type = file_types.get(file_extension, 'Unknown file type')
         return f"File: {file_path}, Type: {file_type}, Size: {file_size} bytes"
     except Exception as e:
@@ -309,3 +356,173 @@ file_type_detection_tool = Tool(
     func=detect_file_type,
     description="Detects file types and provides information about files. Use this when you need to understand what type of file you're working with."
 )
+
+# =========================
+# 8. Enhanced File Reading Tools
+# =========================
+
+
+def read_file(file_name: str) -> str:
+    """
+    Read and process different file types (text, CSV, images).
+    """
+    if not file_name or not os.path.exists(file_name):
+        return "File not found"
+
+    try:
+        file_extension = os.path.splitext(file_name)[1].lower()
+
+        if file_extension == ".csv":
+            return _read_csv_file(file_name)
+        elif file_extension in [".png", ".jpg", ".jpeg", ".gif", ".bmp"]:
+            return _read_image_file(file_name)
+        elif file_extension in [".txt", ".md", ".py", ".js", ".html", ".json"]:
+            return _read_text_file(file_name)
+        else:
+            # Try to read as text file
+            return _read_text_file(file_name)
+
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+
+def _read_text_file(file_name: str) -> str:
+    """Read a text file."""
+    try:
+        with open(file_name, "r", encoding="utf-8") as f:
+            content = f.read()
+        return content[:5000]  # Limit to first 5000 characters
+    except UnicodeDecodeError:
+        # Try with different encoding
+        try:
+            with open(file_name, "r", encoding="latin-1") as f:
+                content = f.read()
+            return content[:5000]
+        except Exception as e:
+            return f"Text file reading error: {str(e)}"
+
+
+def _read_csv_file(file_name: str) -> str:
+    """Read and summarize a CSV file."""
+    try:
+        df = pd.read_csv(file_name)
+
+        # Create a summary
+        summary = []
+        summary.append(
+            f"CSV file shape: {df.shape[0]} rows, {df.shape[1]} columns")
+        summary.append(f"Columns: {', '.join(df.columns.tolist())}")
+
+        # Show first few rows
+        summary.append("\nFirst 5 rows:")
+        summary.append(df.head().to_string())
+
+        # Show basic statistics for numeric columns
+        numeric_columns = df.select_dtypes(include=['number']).columns
+        if len(numeric_columns) > 0:
+            summary.append(f"\nNumeric column statistics:")
+            summary.append(df[numeric_columns].describe().to_string())
+
+        return "\n".join(summary)
+
+    except Exception as e:
+        return f"CSV reading error: {str(e)}"
+
+
+def _read_image_file(file_name: str) -> str:
+    """Read and analyze an image file."""
+    try:
+        # Try OCR first
+        try:
+            import pytesseract
+            img = Image.open(file_name)
+
+            # Get image info
+            info = f"Image: {img.size[0]}x{img.size[1]} pixels, mode: {img.mode}"
+
+            # Try OCR
+            text = pytesseract.image_to_string(img).strip()
+            if text:
+                return f"{info}\n\nExtracted text:\n{text}"
+            else:
+                return f"{info}\n\nNo text detected in image."
+
+        except ImportError:
+            # OCR not available, just return image info
+            img = Image.open(file_name)
+            return f"Image: {img.size[0]}x{img.size[1]} pixels, mode: {img.mode}\n(OCR not available - install pytesseract for text extraction)"
+
+    except Exception as e:
+        return f"Image reading error: {str(e)}"
+
+
+read_file_tool = Tool(
+    name="read_file_tool",
+    func=read_file,
+    description="Reads and processes different file types including text files, CSV files, and images. Use this when you need to extract content from files."
+)
+
+# =========================
+# 9. Code Execution and Math Tools
+# =========================
+
+
+def execute_code(code: str, timeout: int = 5) -> str:
+    """
+    Execute Python code safely with timeout.
+    """
+    try:
+        # Basic security check - prevent dangerous operations
+        dangerous_keywords = [
+            "import os", "import subprocess", "__import__", "exec", "eval", "open("]
+        if any(keyword in code.lower() for keyword in dangerous_keywords):
+            return "Code execution blocked: potentially unsafe operations detected"
+
+        result = subprocess.run(
+            ["python3", "-c", code],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd="/tmp"  # Run in safe directory
+        )
+
+        if result.returncode == 0:
+            return result.stdout.strip() if result.stdout else "Code executed successfully (no output)"
+        else:
+            return f"Code execution error: {result.stderr.strip()}"
+
+    except subprocess.TimeoutExpired:
+        return "Code execution timeout"
+    except Exception as e:
+        return f"Code execution error: {str(e)}"
+
+
+def calculate_simple_math(expression: str) -> str:
+    """
+    Safely evaluate simple mathematical expressions.
+    """
+    try:
+        # Only allow basic math characters
+        allowed_chars = set("0123456789+-*/.() ")
+        if not all(c in allowed_chars for c in expression):
+            return "Invalid mathematical expression"
+
+        # Use eval safely for basic math
+        result = eval(expression)
+        return str(result)
+
+    except Exception as e:
+        return f"Math calculation error: {str(e)}"
+
+
+code_execution_tool = Tool(
+    name="code_execution_tool",
+    func=execute_code,
+    description="Executes Python code safely with timeout and security checks. Use this when you need to run small Python code snippets."
+)
+
+math_calculation_tool = Tool(
+    name="math_calculation_tool",
+    func=calculate_simple_math,
+    description="Safely evaluates simple mathematical expressions. Use this when you need to perform basic math calculations."
+)