Upload 3 files

agent.py

@@ -4,9 +4,12 @@
 
 import os
 import re
-import time
+import sys
+import json
 import tempfile
 import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
 
 from dotenv import load_dotenv
 
@@ -18,10 +21,16 @@ from langchain_core.tools import tool
 from langchain_core.messages import SystemMessage
 
 from langchain_community.document_loaders import WikipediaLoader
-from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchResults
 
 import requests
 from bs4 import BeautifulSoup
+import pandas as pd
+
+try:
+    from youtube_transcript_api import YouTubeTranscriptApi
+except Exception:
+    YouTubeTranscriptApi = None
 
 load_dotenv()
 
@@ -51,9 +60,12 @@ def wiki_search(query: str) -> str:
 
 @tool
 def web_search(query: str) -> str:
-    """Search the web via DuckDuckGo for current events, recent data, or specific facts."""
+    """Search the web and return compact title/url/snippet results."""
     try:
-        result = DuckDuckGoSearchRun(max_results=5).run(query)
+        result = DuckDuckGoSearchResults(
+            max_results=5,
+            output_format="list",
+        ).run(query)
         return result if result else "No results found. Try a different query."
     except Exception as e:
         return f"Web search unavailable: {type(e).__name__}. Try wiki_search instead."
@@ -74,15 +86,180 @@ def fetch_page(url: str) -> str:
         return f"Could not fetch page: {type(e).__name__}."
 
 
+def _youtube_video_id(text: str) -> str | None:
+    patterns = [
+        r"(?:v=|youtu\.be/|shorts/|embed/)([A-Za-z0-9_-]{11})",
+        r"^([A-Za-z0-9_-]{11})$",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1)
+    return None
+
+
+@tool
+def youtube_transcript(video_url_or_id: str) -> str:
+    """Get available YouTube captions/transcript for a video URL or video id."""
+    if YouTubeTranscriptApi is None:
+        return "YouTube transcript library is unavailable."
+    video_id = _youtube_video_id(video_url_or_id)
+    if not video_id:
+        return "Could not identify a YouTube video id."
+    try:
+        rows = YouTubeTranscriptApi.get_transcript(video_id, languages=["en", "en-US", "en-GB"])
+    except Exception:
+        try:
+            rows = YouTubeTranscriptApi.get_transcript(video_id)
+        except Exception as e:
+            return f"Transcript unavailable: {type(e).__name__}. Use web_search for quotes or descriptions."
+    lines = []
+    for row in rows[:220]:
+        start = int(float(row.get("start", 0)))
+        text = " ".join(str(row.get("text", "")).split())
+        if text:
+            lines.append(f"{start}s: {text}")
+    return "\n".join(lines)[:7000] if lines else "Transcript is empty."
+
+
+def _download_to_temp(source: str) -> tuple[Path | None, str]:
+    if re.fullmatch(r"[0-9a-fA-F-]{36}", source.strip()):
+        source = f"https://agents-course-unit4-scoring.hf.space/files/{source.strip()}"
+    if not source.startswith(("http://", "https://")):
+        return None, "Input must be a URL or benchmark task_id."
+
+    try:
+        r = requests.get(source, timeout=25, headers={"User-Agent": "Mozilla/5.0"})
+        if r.status_code == 404:
+            return None, "No attached file found for this task."
+        r.raise_for_status()
+    except Exception as e:
+        return None, f"Download failed: {type(e).__name__}."
+
+    parsed = urlparse(source)
+    suffix = Path(parsed.path).suffix
+    content_type = r.headers.get("content-type", "").lower()
+    if not suffix:
+        if "spreadsheet" in content_type or "excel" in content_type:
+            suffix = ".xlsx"
+        elif "csv" in content_type:
+            suffix = ".csv"
+        elif "pdf" in content_type:
+            suffix = ".pdf"
+        elif "python" in content_type or "text" in content_type:
+            suffix = ".txt"
+        elif "image" in content_type:
+            suffix = "." + content_type.split("/")[-1].split(";")[0]
+        else:
+            cd = r.headers.get("content-disposition", "")
+            match = re.search(r'filename="?([^";]+)', cd)
+            suffix = Path(match.group(1)).suffix if match else ".bin"
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as f:
+        f.write(r.content)
+        return Path(f.name), f"Downloaded {len(r.content)} bytes as {suffix or '.bin'}."
+
+
+def _read_text_file(path: Path) -> str:
+    for enc in ("utf-8", "latin-1"):
+        try:
+            return path.read_text(encoding=enc)[:9000]
+        except Exception:
+            continue
+    return "Could not decode text file."
+
+
+@tool
+def inspect_file(source: str) -> str:
+    """Download and inspect an attached benchmark file or URL. Input can be a task_id or URL."""
+    path, status = _download_to_temp(source)
+    if path is None:
+        return status
+
+    try:
+        suffix = path.suffix.lower()
+
+        if suffix in {".py", ".txt", ".md", ".json", ".html", ".csv"}:
+            if suffix == ".csv":
+                df = pd.read_csv(path)
+                return _summarize_dataframe(df, "csv")
+            text = _read_text_file(path)
+            if suffix == ".py":
+                run = subprocess.run(
+                    [sys.executable, str(path)],
+                    capture_output=True,
+                    text=True,
+                    timeout=20,
+                )
+                stdout = run.stdout.strip()
+                stderr = run.stderr.strip()
+                return f"{status}\nPython stdout:\n{stdout[:3000] or '(empty)'}\nPython stderr:\n{stderr[:1000] or '(empty)'}\n\nCode preview:\n{text[:4000]}"
+            return f"{status}\n{text}"
+
+        if suffix in {".xlsx", ".xls"}:
+            xl = pd.ExcelFile(path)
+            parts = [status, f"Workbook sheets: {', '.join(xl.sheet_names)}"]
+            for sheet in xl.sheet_names[:4]:
+                df = xl.parse(sheet)
+                parts.append(_summarize_dataframe(df, sheet))
+            return "\n\n".join(parts)[:9000]
+
+        if suffix == ".pdf":
+            try:
+                from pypdf import PdfReader
+                reader = PdfReader(str(path))
+                text = "\n".join((p.extract_text() or "") for p in reader.pages[:8])
+                return f"{status}\nPDF pages: {len(reader.pages)}\n{text[:8500] or 'No extractable text.'}"
+            except Exception as e:
+                return f"{status}\nPDF extraction unavailable: {type(e).__name__}."
+
+        if suffix in {".png", ".jpg", ".jpeg", ".webp", ".gif"}:
+            return f"{status}\nImage file detected. If the question requires visual reasoning, use any visible description in the question and web_search; this runtime has no vision model."
+
+        if suffix in {".mp3", ".wav", ".m4a", ".ogg", ".flac"}:
+            return f"{status}\nAudio file detected. This runtime has no local speech-to-text model; use web_search if the recording is from public material."
+
+        return f"{status}\nUnsupported file type: {suffix or 'unknown'}."
+    except Exception as e:
+        return f"{status}\nInspection failed: {type(e).__name__}: {e}"
+    finally:
+        try:
+            path.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+def _summarize_dataframe(df: pd.DataFrame, name: str) -> str:
+    rows, cols = df.shape
+    df = df.dropna(how="all")
+    preview = df.head(12).to_string(index=False)
+    numeric = df.select_dtypes(include="number")
+    sums = numeric.sum(numeric_only=True).to_dict()
+    sums_text = json.dumps({str(k): round(float(v), 4) for k, v in sums.items()}, ensure_ascii=True)
+    cols_text = ", ".join(map(str, df.columns))
+    food_hint = ""
+    lower_cols = {str(c).lower(): c for c in df.columns}
+    category_col = next((c for key, c in lower_cols.items() if any(x in key for x in ["category", "type", "item type"])), None)
+    sales_col = next((c for key, c in lower_cols.items() if any(x in key for x in ["sales", "revenue", "amount", "total"])), None)
+    if category_col is not None and sales_col is not None:
+        try:
+            grouped = df.groupby(category_col)[sales_col].sum(numeric_only=True).to_dict()
+            food_hint = "\nGrouped sums: " + json.dumps({str(k): round(float(v), 2) for k, v in grouped.items()}, ensure_ascii=True)
+        except Exception:
+            pass
+    return f"Sheet/table {name}: {rows} rows x {cols} cols\nColumns: {cols_text}\nNumeric sums: {sums_text}{food_hint}\nPreview:\n{preview}"
+
+
 @tool
 def run_python(code: str) -> str:
     """Execute Python code and return stdout. Use for calculations, counting, data processing."""
+    fname = None
     try:
         with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
             f.write(code)
             fname = f.name
         p = subprocess.run(
-            ["python3", fname],
+            [sys.executable, fname],
             capture_output=True,
             text=True,
             timeout=20
@@ -98,6 +275,12 @@ def run_python(code: str) -> str:
         return "Script timed out after 20 seconds."
     except Exception as e:
         return f"Execution failed: {type(e).__name__}."
+    finally:
+        if fname:
+            try:
+                Path(fname).unlink(missing_ok=True)
+            except Exception:
+                pass
 
 
 @tool
@@ -106,7 +289,7 @@ def reverse_text(text: str) -> str:
     return text[::-1]
 
 
-TOOLS = [wiki_search, web_search, fetch_page, run_python, reverse_text]
+TOOLS = [wiki_search, web_search, fetch_page, youtube_transcript, inspect_file, run_python, reverse_text]
 
 # ==========================================================
 # MODELS — primary + ordered fallback chain
@@ -117,6 +300,9 @@ def _llm(name: str) -> ChatGroq:
         model=name,
         api_key=os.getenv("GROQ_API_KEY"),
         temperature=0,
+        max_tokens=384,
+        timeout=45,
+        max_retries=1,
     )
 
 
@@ -141,9 +327,11 @@ Produce the exact correct answer — nothing more, nothing less.
 - Use wiki_search for historical facts, biographies, science, geography.
 - Use web_search for recent events, specific articles, prices, or anything time-sensitive.
 - Use fetch_page when a URL is provided or a search result points to a relevant page.
+- Use youtube_transcript first for YouTube questions.
+- Use inspect_file whenever the question says attached file, attached image, spreadsheet, audio, Python code, or provides a task file URL.
 - Use run_python for any arithmetic, counting, sorting, or data transformation.
 - Use reverse_text only when asked to reverse a string.
-- You may use up to 5 tool calls. Stop as soon as you have a confident answer.
+- Prefer tools over guessing. Use compact searches. Stop as soon as you have a confident answer.
 
 ## Answer format rules
 1. Output the raw value only — no explanation, no preamble.

app.py

@@ -29,7 +29,7 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # Single values — no per-difficulty branching
 TIMEOUT_SECONDS  = 120
-RECURSION_LIMIT  = 12
+RECURSION_LIMIT  = 20
 PAUSE_SECONDS    = 1.5
 
 # ==========================================================
@@ -78,9 +78,16 @@ class BenchmarkAgent:
         self.graph = build_graph()
         log("Agent ready.")
 
-    def __call__(self, question: str) -> tuple[str, list, dict]:
+    def __call__(self, question: str, task_id: str = "") -> tuple[str, list, dict]:
+        enriched_question = question
+        if task_id:
+            enriched_question = (
+                f"Task ID: {task_id}\n"
+                f"Attached file URL, if any: {DEFAULT_API_URL}/files/{task_id}\n\n"
+                f"Question: {question}"
+            )
         result = self.graph.invoke(
-            {"messages": [HumanMessage(content=question)]},
+            {"messages": [HumanMessage(content=enriched_question)]},
             {"recursion_limit": RECURSION_LIMIT},
         )
         answer = extract_final_answer(result) or "N/A"
@@ -164,7 +171,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         try:
             def solve():
-                return agent(question)
+                return agent(question, task_id)
 
             result, did_timeout = run_with_timeout(solve, TIMEOUT_SECONDS)
             elapsed = round(time.time() - start, 1)
@@ -260,8 +267,8 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
 **Model**: `qwen/qwen3-32b` (primary) → `llama-3.3-70b-versatile` → `llama-3.1-8b-instant`  
-**Routing**: All questions use the same path — no classification.  
-**Timeout**: 60 s per question · **Recursion limit**: 12
+**Tools**: structured search, page fetch, YouTube transcripts, task-file inspection, Python execution  
+**Timeout**: 120 s per question · **Recursion limit**: 20
         """
     )
 

requirements.txt

@@ -10,6 +10,7 @@ groq
 # Data / file processing
 pandas
 openpyxl          # required by pandas for .xlsx read/write
+pypdf             # lightweight PDF text extraction
  
 # Web tools
 requests
@@ -26,4 +27,4 @@ youtube-transcript-api
 gradio
  
 # Env vars
-python-dotenv
+python-dotenv