updated tools

app.py

@@ -16,6 +16,9 @@ from langchain_openai import ChatOpenAI
 import fitz
 import yt_dlp
 import re
+import subprocess
+from PIL import Image
+from transformers import pipeline
 
 ## # Load environment variables from .env file
 # --- Constants ---
@@ -32,16 +35,48 @@ OPENAI_MODEL = os.getenv ('OPENAI_MODEL')
 # --- TOOL 1: Web Search Tool (DuckDuckGo) ---
 
 @tool
-def search_tool(query: str) -> str:
-    """Answer general knowledge or current events queries using DuckDuckGo."""
+def current_events_news_search_tool(query: str) -> str:
+    """
+    General web search tool for current events, news, or trending topics not yet on Wikipedia.
+    Use this tool only if the Wikipedia tool is not suitable.
+    Returns relevant context and source URL if available.
+    """
     url = f"https://api.duckduckgo.com/?q={query}&format=json&no_html=1"
     try:
-        resp = requests.get(url, timeout=20)
+        resp = requests.get(url, timeout=120)
         resp.raise_for_status()
         data = resp.json()
+        # Check main answer fields
         for key in ["AbstractText", "Answer", "Definition"]:
             if data.get(key):
-                return data[key].split(".")[0]
+                answer = data[key].strip()
+                break
+        else:
+            answer = None
+
+        # Check for related topics if no direct answer
+        if not answer:
+            related = data.get("RelatedTopics")
+            if related and isinstance(related, list) and related:
+                first_topic = related[0]
+                if isinstance(first_topic, dict) and first_topic.get("Text"):
+                    answer = first_topic["Text"].strip()
+
+        # Check for results if still no answer
+        if not answer:
+            results = data.get("Results")
+            if results and isinstance(results, list) and results:
+                first_result = results[0]
+                if isinstance(first_result, dict) and first_result.get("Text"):
+                    answer = first_result["Text"].strip()
+
+        # Try to include a source URL if available
+        source_url = data.get("AbstractURL") or data.get("Redirect") or ""
+        if answer:
+            result = answer
+            if source_url:
+                result += f"\nSource: {source_url}"
+            return result.strip()
         return "no_answer"
     except Exception:
         return "error"
@@ -58,7 +93,7 @@ def get_weather(city: str) -> str:
     api_key = os.environ.get("WEATHER_API_KEY")
     url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric"
     try:
-        resp = requests.get(url, timeout=20)
+        resp = requests.get(url, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return str(round(data["main"]["temp"]))
@@ -119,95 +154,52 @@ def get_date(input: str) -> str:
 
 # --- TOOL 6: Wikipedia Summary Tool ---
 @tool
-def wikipedia_summary(query: str) -> str:
+def wikipedia_and_generalknowledge_search(query: str) -> str:
     """
-    Answer questions from Wikipedia related to world information, facts, sports, olympics, history, facts, general knowledge etc. 
+    Answer questions related to general knowledge, world information, facts, sports, olympics, history, etc. from Wikipedia by scraping the text and returns text as context for LLM to use.
     """
-
-    # Heuristic: If the query looks data-driven, extract tables/lists
-    data_keywords = [
-        "list", "table", "which", "who", "how many", "after", "before", "country", "year", "wikipedia", "winners", "recipients", "participants", "awards", "nationality", "film", "olympics", "sports", "statistics", "events", "year", "rankings"
-    ]
-    if any(word in query.lower() for word in data_keywords):
-        # Step 1: Search Wikipedia for the most relevant page
-        search_url = "https://en.wikipedia.org/w/api.php"
-        params = {
-            "action": "query",
-            "list": "search",
-            "srsearch": query,
-            "format": "json"
-        }
-        try:
-            resp = requests.get(search_url, params=params, timeout=15)
-            resp.raise_for_status()
-            results = resp.json().get("query", {}).get("search", [])
-            if not results:
-                return "no_answer"
-            page_title = results[0]["title"]
-            page_url = f"https://en.wikipedia.org/wiki/{page_title.replace(' ', '_')}"
-        except Exception:
-            return "error: Could not search Wikipedia"
-
-        # Step 2: Fetch the Wikipedia page and extract tables/lists
-        try:
-            page_resp = requests.get(page_url, timeout=20)
-            page_resp.raise_for_status()
-            soup = BeautifulSoup(page_resp.text, "html.parser")
-            output = f"Source: {page_url}\n"
-
-            # Extract all tables with relevant columns
-            tables = soup.find_all("table", {"class": ["wikitable", "sortable"]})
-            found_table = False
-            for table in tables:
-                table_str = str(table)
-                if any(word in table_str.lower() for word in ["winner", "name", "year", "nationality", "country", "recipient", "team"]):
-                    try:
-                        df = pd.read_html(table_str)[0]
-                        output += "\n--- Extracted Table ---\n"
-                        output += df.to_csv(index=False)
-                        found_table = True
-                    except Exception:
-                        continue
-
-            # If no relevant table, extract lists
-            if not found_table:
-                lists = soup.find_all(['ul', 'ol'])
-                for lst in lists:
-                    items = lst.find_all('li')
-                    if len(items) > 2:
-                        output += "\n--- Extracted List ---\n"
-                        for item in items:
-                            text = item.get_text(separator=" ", strip=True)
-                            output += f"{text}\n"
-                        break
-
-            # Fallback: return the first paragraph if nothing else
-            if not found_table and "--- Extracted List ---" not in output:
-                first_p = soup.find("p")
-                output += first_p.get_text(strip=True)[:500] if first_p else "no_answer"
-
-            # Limit output length for LLM context
-            return output[:3500]
-        except Exception as e:
-            return f"error: {e}"
-
-    # Otherwise, just return the summary as before
-    url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{query.replace(' ', '_')}"
+    # Step 1: Search Wikipedia for the most relevant page
+    search_url = "https://en.wikipedia.org/w/api.php"
+    params = {
+        "action": "query",
+        "list": "search",
+        "srsearch": query,
+        "format": "json"
+    }
     try:
-        resp = requests.get(url, timeout=20)
+        resp = requests.get(search_url, params=params, timeout=150)
         resp.raise_for_status()
-        data = resp.json()
-        return data.get("extract", "no_answer").split(".")[0]
+        results = resp.json().get("query", {}).get("search", [])
+        if not results:
+            return "no_answer"
+        page_title = results[0]["title"]
+        page_url = f"https://en.wikipedia.org/wiki/{page_title.replace(' ', '_')}"
     except Exception:
-        return "error"
+        return "error: Could not search Wikipedia"
+
+    # Step 2: Fetch the Wikipedia page and extract main text
+    try:
+        page_resp = requests.get(page_url, timeout=120)
+        page_resp.raise_for_status()
+        soup = BeautifulSoup(page_resp.text, "html.parser")
+        output = f"Source: {page_url}\n"
+
+        # Extract main text from all paragraphs
+        paragraphs = soup.find_all("p")
+        text = " ".join(p.get_text(separator=" ", strip=True) for p in paragraphs)
+        # Limit to first 3000 characters for brevity
+        output += text[:3000] if text else "No textual content found."
+        return output
+    except Exception as e:
+        return f"error: {e}"
 
 # --- TOOL 7: Dictionary Tool ---
 @tool
 def dictionary_lookup(word: str) -> str:
-    """Get the definition of an English word."""
+    """Get the definition of an English word using dictionary."""
     url = f"https://api.dictionaryapi.dev/api/v2/entries/en/{word}"
     try:
-        resp = requests.get(url, timeout=20)
+        resp = requests.get(url, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return data[0]["meanings"][0]["definitions"][0]["definition"]
@@ -227,7 +219,7 @@ def currency_convert(args: str) -> str:
         from_currency = parts[1]
         to_currency = parts[3]
         url = f"https://api.exchangerate.host/convert?from={from_currency}&to={to_currency}&amount={amount}"
-        resp = requests.get(url, timeout=20)
+        resp = requests.get(url, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return str(round(data["result"], 2))
@@ -242,7 +234,7 @@ def image_caption(image_url: str) -> str:
     headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
     payload = {"inputs": image_url}
     try:
-        resp = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        resp = requests.post(api_url, headers=headers, json=payload, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return data[0]["generated_text"] if isinstance(data, list) else data.get("generated_text", "no_caption")
@@ -257,7 +249,7 @@ def ocr_image(image_url: str) -> str:
     headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
     payload = {"inputs": {"image": image_url, "question": "What text is in the image?"}}
     try:
-        resp = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        resp = requests.post(api_url, headers=headers, json=payload, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return data.get("answer", "no_text_found")
@@ -272,7 +264,7 @@ def classify_image(image_url: str) -> str:
     headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
     payload = {"inputs": image_url}
     try:
-        resp = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        resp = requests.post(api_url, headers=headers, json=payload, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return data[0]["label"] if isinstance(data, list) else data.get("label", "no_label")
@@ -281,29 +273,28 @@ def classify_image(image_url: str) -> str:
 
 # --- TOOL 12: Web Scraping Tool ---
 @tool
-def web_scrape_tool(url: str) -> str:
+def URL_scrape_tool(url: str) -> str:
     """
-    Scrape the main textual content from a given website URL and return a concise summary or answer.
-    Input: A valid URL (e.g., 'https://en.wikipedia.org/wiki/Python_(programming_language)')
+    Scrape the main textual content from a given website URL and returns the text - to be used as context by model.
     """
     try:
         headers = {
             "User-Agent": "Mozilla/5.0 (compatible; WebScrapeTool/1.0)"
         }
-        resp = requests.get(url, headers=headers, timeout=20)
+        resp = requests.get(url, headers=headers, timeout=120)
         resp.raise_for_status()
         soup = BeautifulSoup(resp.text, "html.parser")
         # Try to extract main content from common tags
         paragraphs = soup.find_all("p")
         text = " ".join(p.get_text() for p in paragraphs)
         # Limit to first 2000 characters for brevity
-        return text[:2000] if text else "No textual content found."
+        return text[:4000] if text else "No textual content found."
     except Exception as e:
         return f"error: {e}"
 
 # --- TOOL 13: Audio to Text Transcription Tool ---
 @tool
-def audio_to_text(audio_url: str) -> str:
+def audio_url_to_text(audio_url: str) -> str:
     """
     Transcribe speech from an audio file URL to text using Hugging Face's Whisper model.
     Input: A direct link to an audio file (e.g., .mp3, .wav).
@@ -313,7 +304,7 @@ def audio_to_text(audio_url: str) -> str:
     headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
     try:
         # Download the audio file
-        audio_resp = requests.get(audio_url, timeout=30)
+        audio_resp = requests.get(audio_url, timeout=120)
         audio_resp.raise_for_status()
         audio_bytes = audio_resp.content
         # Encode audio as base64 for API
@@ -322,7 +313,7 @@ def audio_to_text(audio_url: str) -> str:
             "inputs": audio_b64,
             "parameters": {"return_timestamps": False}
         }
-        resp = requests.post(api_url, headers=headers, json=payload, timeout=60)
+        resp = requests.post(api_url, headers=headers, json=payload, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         return data.get("text", "no_answer")
@@ -349,8 +340,8 @@ def python_executor(code: str) -> str:
 @tool
 def python_excel_audio_video_attached_file_tool(input_str: str) -> str:
     """
-    Processes an input attachment (audio, image, video, Excel, or Python .py file) and returns extracted text or a summary suitable for LLM input.
-    This function accepts a JSON string 'input_str' with keys: 'file_bytes' (base64), and 'filename'. So input the file and filename as json strings. For unsupported file types the function returns an error message.
+    Processes an input attachment (audio, image, video, Excel, or Python .py file) and returns extracted info (text, encoded information, metadata, etc.) to be used by LLM.
+    This function accepts a JSON string 'input_str' with keys: 'file_bytes' (base64), and 'filename'. So input the file and filename as json strings.
     """
     import pandas as pd
 
@@ -384,7 +375,7 @@ def python_excel_audio_video_attached_file_tool(input_str: str) -> str:
         headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
         files = {"file": (filename, file_bytes)}
         try:
-            resp = requests.post(api_url, headers=headers, files=files, timeout=60)
+            resp = requests.post(api_url, headers=headers, files=files, timeout=120)
             resp.raise_for_status()
             data = resp.json()
             transcript = data.get("text", "")
@@ -473,10 +464,9 @@ def python_excel_audio_video_attached_file_tool(input_str: str) -> str:
 @tool
 def search_and_extract_research_paper_info(query: str) -> str:
     """
-    Searches for research papers using the Semantic Scholar API, downloads the top result's PDF,
-    and extracts the title, authors, abstract, and main sections.
+    Searches for research and online papers/journals using the Semantic Scholar API.
     Input: A search query (e.g., topic, paper title, or keywords).
-    Output: A summary with title, authors, abstract, and main sections from the top result.
+    Output: A summary with title, authors, abstract, and a longer excerpt from the main sections of the top result.
     """
     try:
         # Search for papers using Semantic Scholar API
@@ -486,7 +476,7 @@ def search_and_extract_research_paper_info(query: str) -> str:
             "limit": 1,
             "fields": "title,authors,abstract,url,openAccessPdf"
         }
-        resp = requests.get(search_url, params=params, timeout=20)
+        resp = requests.get(search_url, params=params, timeout=120)
         resp.raise_for_status()
         data = resp.json()
         if not data.get("data"):
@@ -495,12 +485,13 @@ def search_and_extract_research_paper_info(query: str) -> str:
         title = paper.get("title", "")
         authors = ", ".join([a["name"] for a in paper.get("authors", [])])
         abstract = paper.get("abstract", "")
+        paper_url = paper.get("url", "")
         pdf_url = paper.get("openAccessPdf", {}).get("url")
         if not pdf_url:
-            return f"Paper found: {title}\nAuthors: {authors}\nAbstract: {abstract}\n(No open access PDF available.)"
+            return f"Paper found: {title}\nAuthors: {authors}\nAbstract: {abstract}\nURL: {paper_url}\n(No open access PDF available.)"
 
         # Download the PDF
-        pdf_resp = requests.get(pdf_url, timeout=30)
+        pdf_resp = requests.get(pdf_url, timeout=120)
         pdf_resp.raise_for_status()
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_pdf:
             tmp_pdf.write(pdf_resp.content)
@@ -513,7 +504,7 @@ def search_and_extract_research_paper_info(query: str) -> str:
         for page in doc:
             full_text += page.get_text("text") + "\n"
 
-        # Simple heuristics to extract main sections
+        # Extract a longer excerpt from the main sections (e.g., Introduction + first 2000 chars)
         lines = full_text.splitlines()
         main_sections = ""
         in_main = False
@@ -522,14 +513,15 @@ def search_and_extract_research_paper_info(query: str) -> str:
                 in_main = True
             if in_main:
                 main_sections += line.strip() + " "
-                if len(main_sections) > 1000:
+                if len(main_sections) > 2000:
                     break
 
         summary = (
             f"Title: {title}\n"
             f"Authors: {authors}\n"
             f"Abstract: {abstract}\n"
-            f"Main Sections (excerpt): {main_sections.strip()}"
+            f"URL: {paper_url}\n"
+            f"Main Sections (excerpt): {main_sections.strip() if main_sections else full_text[:2000]}"
         )
         return summary if summary.strip() else "No information extracted."
     except Exception as e:
@@ -540,9 +532,7 @@ def search_and_extract_research_paper_info(query: str) -> str:
 @tool
 def sports_awards_historicalfacts_tool(query: str) -> str:
     """
-    For questions about lists, awards, competitions, or historical facts, this tool searches Wikipedia,
-    extracts all tables and lists from the most relevant page, and returns them as CSV or plain text.
-    This gives the LLM enough context to answer complex queries about people, years, nationalities, etc.
+    For questions about sports, awards, competitions, historical facts, or generic wikipedia available data, this tool fetches relevant context from Wikipedia.
     """
 
     # Step 1: Search Wikipedia for the most relevant page
@@ -554,7 +544,7 @@ def sports_awards_historicalfacts_tool(query: str) -> str:
         "format": "json"
     }
     try:
-        resp = requests.get(search_url, params=params, timeout=15)
+        resp = requests.get(search_url, params=params, timeout=150)
         resp.raise_for_status()
         results = resp.json().get("query", {}).get("search", [])
         if not results:
@@ -566,7 +556,7 @@ def sports_awards_historicalfacts_tool(query: str) -> str:
 
     # Step 2: Fetch the Wikipedia page and extract tables and lists
     try:
-        page_resp = requests.get(page_url, timeout=20)
+        page_resp = requests.get(page_url, timeout=150)
         page_resp.raise_for_status()
         soup = BeautifulSoup(page_resp.text, "html.parser")
         output = f"Source: {page_url}\n"
@@ -609,32 +599,55 @@ def sports_awards_historicalfacts_tool(query: str) -> str:
 
 # --- TOOL 18: YouTube Transcript Tool ---
 @tool
-def audio_video_url_transcript_tool(youtube_url: str) -> str:
+def video_url_to_transcript_tool(media_url: str) -> str:
     """
-    Given a URL about video or audio, like YouTube video URL, download the audio and return a transcript using Whisper.
+    Given a URL to a video or audio file (YouTube, direct .mp4/.mp3/.wav, etc.), download the audio and return a transcript.
     """
     api_url = "https://api-inference.huggingface.co/models/openai/whisper-large-v3"
     headers = {"Authorization": f"Bearer {HF_ACCESS_KEY}"}
 
     try:
-        # Download audio from YouTube
         with tempfile.TemporaryDirectory() as tmpdir:
-            ydl_opts = {
-                'format': 'bestaudio/best',
-                'outtmpl': f'{tmpdir}/audio.%(ext)s',
-                'quiet': True,
-                'noplaylist': True,
-                'extractaudio': True,
-                'audioformat': 'wav',
-                'postprocessors': [{
-                    'key': 'FFmpegExtractAudio',
-                    'preferredcodec': 'wav',
-                    'preferredquality': '192',
-                }],
-            }
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(youtube_url, download=True)
-                audio_path = ydl.prepare_filename(info).rsplit('.', 1)[0] + '.wav'
+            audio_path = None
+
+            # Check if it's a YouTube URL
+            if "youtube.com" in media_url or "youtu.be" in media_url:
+                ydl_opts = {
+                    'format': 'bestaudio/best',
+                    'outtmpl': f'{tmpdir}/audio.%(ext)s',
+                    'quiet': True,
+                    'noplaylist': True,
+                    'extractaudio': True,
+                    'audioformat': 'wav',
+                    'postprocessors': [{
+                        'key': 'FFmpegExtractAudio',
+                        'preferredcodec': 'wav',
+                        'preferredquality': '192',
+                    }],
+                }
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    info = ydl.extract_info(media_url, download=True)
+                    audio_path = ydl.prepare_filename(info).rsplit('.', 1)[0] + '.wav'
+            else:
+                # Download direct media file
+                resp = requests.get(media_url, timeout=120)
+                resp.raise_for_status()
+                # Guess extension
+                ext = media_url.split('?')[0].split('.')[-1].lower()
+                if ext not in ["mp3", "wav", "m4a", "mp4"]:
+                    ext = "mp3"
+                file_path = os.path.join(tmpdir, f"audio.{ext}")
+                with open(file_path, "wb") as f:
+                    f.write(resp.content)
+                # If video, extract audio using ffmpeg
+                if ext in ["mp4", "mkv", "webm"]:
+                    audio_path = os.path.join(tmpdir, "audio.wav")
+                    import subprocess
+                    subprocess.run([
+                        "ffmpeg", "-i", file_path, "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", audio_path
+                    ], check=True)
+                else:
+                    audio_path = file_path
 
             # Read audio bytes
             with open(audio_path, "rb") as f:
@@ -653,31 +666,93 @@ def audio_video_url_transcript_tool(youtube_url: str) -> str:
     except Exception as e:
         return f"error: {e}"
     
+
+# --- TOOL 19: Audio to Text Transcription Tool ---
+@tool
+def max_object_in_video(video_url: str, object_label: str = "bird") -> str:
+    """
+    Given a video URL and an object label, extracts frames and uses an object detection model to count the specified object in each frame.
+    Returns the maximum number of objects detected in any single frame.
+    Example: max_object_in_video("https://...", "car") -> "Maximum car count in a frame: 4"
+    """
+
+    # Download video
+    try:
+        resp = requests.get(video_url, timeout=120)
+        resp.raise_for_status()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
+            tmp_video.write(resp.content)
+            tmp_video.flush()
+            video_path = tmp_video.name
+    except Exception as e:
+        return f"error: Could not download video: {e}"
+
+    # Extract frames every 2 seconds (adjust as needed)
+    frames_dir = tempfile.mkdtemp()
+    frame_pattern = os.path.join(frames_dir, "frame_%04d.jpg")
+    try:
+        subprocess.run([
+            "ffmpeg", "-i", video_path, "-vf", "fps=0.5", frame_pattern
+        ], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception as e:
+        return f"error: Could not extract frames: {e}"
+
+    # Load object detection pipeline
+    try:
+        detector = pipeline("object-detection", model="facebook/detr-resnet-50")
+    except Exception as e:
+        return f"error: Could not load detection model: {e}"
+
+    max_count = 0
+    for fname in sorted(os.listdir(frames_dir)):
+        fpath = os.path.join(frames_dir, fname)
+        try:
+            image = Image.open(fpath)
+            results = detector(image)
+            count = sum(1 for obj in results if obj['label'].lower() == object_label.lower() and obj['score'] > 0.5)
+            if count > max_count:
+                max_count = count
+        except Exception:
+            continue
+
+    # Clean up
+    try:
+        os.remove(video_path)
+        for fname in os.listdir(frames_dir):
+            os.remove(os.path.join(frames_dir, fname))
+        os.rmdir(frames_dir)
+    except Exception:
+        pass
+
+    return f"Maximum {object_label} count in a single frame: {max_count}"
+
+
 ##-- Tool Discovery ---
 # Use @tool for each function.
 # Use get_all_tools() to auto-discover all decorated tools.
 # tools_list = get_all_tools()
 tools_list = [
     python_excel_audio_video_attached_file_tool,
-    wikipedia_summary,
-    sports_awards_historicalfacts_tool,
+    wikipedia_and_generalknowledge_search,
+    # sports_awards_historicalfacts_tool,
     search_and_extract_research_paper_info,
     python_executor,
-    get_weather,
-    calculator,
-    convert_units,
-    get_time,
-    get_date,
+    # get_weather,
+    # calculator,
+    # convert_units,
+    # get_time,
+    # get_date,
     dictionary_lookup,
-    currency_convert,
-    image_caption,
-    ocr_image,
-    classify_image,
-    search_tool,
-    web_scrape_tool,
-    audio_to_text, 
+    # currency_convert,
+    # image_caption,
+    # ocr_image,
+    # classify_image,
+    current_events_news_search_tool,
+    URL_scrape_tool,
+    audio_url_to_text, 
     # sports_awards_historicalfacts_tool,
-    audio_video_url_transcript_tool
+    video_url_to_transcript_tool,
+    max_object_in_video,
 ]
 
 tool_descriptions = "\n".join(f"- {tool.name}: {tool.description}" for tool in tools_list)
@@ -688,11 +763,20 @@ tool_descriptions = "\n".join(f"- {tool.name}: {tool.description}" for tool in t
 # --- System Prompt for the Agent ---
 
 system_prompt = f"""
-You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: [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, preferably not more than two lines.
-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.
+You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: [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.
+First check if you can answer the question by yourself without the need for a tool. If you can answer without hallucination then answer the question directly. If you cannot, use the tools provided to answer the question.
+
+You also have access to a set of tools, which you can use to answer the question, if you can't answer the question directly. The available tools are:
+{tool_descriptions}
+
+If there is a file (image, audio, or video) attached to the question, you should use the process_attachment tool to process it and follow the instructions below:
+ - For audio or video attachments, the process_attachment tool will transcribe the audio and return the transcript, which you can use to answer the question. 
+ -  For image attachments, the process_attachment tool will return a base64 encoded string of the image. You can use this encoded information to provide answer.
+
+If the question is related to sports, awards, historical facts or similar topic that can be answered from wikipedia, you should use the 'wikipedia_and_generalknowledge_search', if the question is based on current events or news kind then you can utilize the tool 'current_events_news_search_tool' to fetch relevant page information and answer from it. 
+You must not use multiple tools in a single call. Don't hallucinate.
+
 
 For each question, follow this format:
 
@@ -704,10 +788,6 @@ Observation: the result of the action
 ... (repeat Thought/Action/Action Input/Observation as needed)
 Final Answer: the answer to the original question, as concise as possible (number, short string, or comma-separated list, no extra explanation).
 
-Rules for YOUR FINAL ANSWER:
-- If the questions is about 'how many' or 'how many times' or 'how many years' or 'how many people' or 'how many items' or 'how many albums' or 'how many songs' (basically needing quantitative reply), then YOUR FINAL ANSWER should just be a number.
-- If the question is about 'what', 'who', 'where', 'when', 'which', 'why', 'how' or similar, then YOUR FINAL ANSWER should be a short string or a comma separated list of strings.
-
 **Examples:**
 Q: Which country had the least number of athletes at the 1928 Summer Olympics?
 Final Answer: Luxembourg
@@ -718,17 +798,10 @@ Final Answer: 5
 Q: List the top 3 programming languages.
 Final Answer: Python, JavaScript, Java
 
-You also have access to a set of tools, which you can use to answer the question. The available tools with their descriptions are:
-{tool_descriptions}
-
-If there is a file (image, audio, or video) attached to the question, you should use the process_attachment tool to process it and follow the instructions below:
- - For audio or video attachments, the process_attachment tool will transcribe the audio and return the transcript, which you can use to answer the question. 
- -  For image attachments, the process_attachment tool will return a base64 encoded string of the image. You can use this encoded information to provide answer.
-
-If the question is related to sports, awards, historical facts or similar topic that can be answered from wikipedia, you should use the 'sports_awards_historicalfacts_tool' or if the question is similar or related that can be searched in wikipedia, use the more specific tool 'wikipedia_summary' to fetch relevant page information and answer from it. 
-In general, you must use tools only if needed for the question and only if the question can be answered by one of the provided tools. Otherwise provide the answer based on your knowledge. You must not use multiple tools in a single call. Don't hallucinate.
+Q: What is the maximum number os birds in the video https://www.youtube.com/watch?v=example?
+Final Answer: 12
 
-If after 12 iterations also a tool usage is not useful then try to answer directly based on your knowledge. If you cannot answer, respond with "no_answer".
+If after 12 iterations also a tool usage is not useful then try to answer directly based on your knowledge. If you cannot answer then just say "no_answer" as YOUR FINAL ANSWER.
 
 """
 # If your final answer is something like 'there were 5 studio albums published between 2000 and 2009' then modify YOUR FINAL ANSWER as: '5' 
@@ -844,7 +917,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(questions_url, timeout=120)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
@@ -894,7 +967,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response = requests.post(submit_url, json=submission_data, timeout=120)
         response.raise_for_status()
         result_data = response.json()
         final_status = (

requirements.txt

@@ -12,4 +12,5 @@ beautifulsoup4
 mimetype
 PyMuPDF
 yt_dlp
-pandas
+pandas
+pillow