feat: implement modular tool architecture and expand LLM provider support while cleaning up legacy test scripts.

agent.py

@@ -1,204 +1,25 @@
 import os
 import re
-import subprocess
-import tempfile
-from pathlib import Path
 from typing import TypedDict, List, Union
 
-import pandas as pd
-import fitz
-from langchain_tavily import TavilySearch
 from dotenv import load_dotenv
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage
-from langchain_core.tools import tool
-from langchain_groq import ChatGroq
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langgraph.graph import StateGraph, START, END
-from langchain_community.document_loaders import WikipediaLoader, UnstructuredFileLoader
-from langchain_community.document_loaders.image import UnstructuredImageLoader
 
-load_dotenv()
-
-@tool
-def python_repl(code: str) -> str:
-    """Execute python code and return the output. Use this for calculations, data analysis, or processing files.
-    The code should be a valid python script that prints the final result.
-    You can use libraries like pandas, numpy, PIL, etc.
-    Example: print(df.head()) or print(2 + 2)"""
-    try:
-        import sys
-        from io import StringIO
-        old_stdout = sys.stdout
-        redirected_output = StringIO()
-        sys.stdout = redirected_output
-        try:
-            # Execute in a persistent-ish way by using globals
-            exec(code, globals())
-        finally:
-            sys.stdout = old_stdout
-        return redirected_output.getvalue().strip() or "Code executed successfully (no output)."
-    except Exception as e:
-        return f"PYTHON_ERROR: {e}"
-
-@tool
-def web_search(keywords: str) -> str:
-    """Search the web using Tavily. This tool performs a concise, focused search to answer factual questions or gather brief information snippets.
-    For deeper research or browsing specific URLs, additional tools may be required.
-    """
-    try:
-        tavily = TavilySearch(max_results=5)
-        results = tavily.invoke(keywords)
-        formatted_results = []
-        for r in results:
-            formatted_results.append(f"Title: {r['title']}\nURL: {r['url']}\nContent: {r['content'][:300]}")
-        return "\n".join(formatted_results) or "NO_RESULTS"
-    except Exception as e:
-        return f"SEARCH_ERROR: {e}"
-
-@tool  
-def wiki_search(query: str) -> str:
-    """Search Wikipedia."""
-    try:
-        docs = WikipediaLoader(query=query, load_max_docs=2).load()
-        return "\n".join([f"{d.metadata.get('title', 'Unknown')}: {d.page_content[:500]}" for d in docs]) or "NO_RESULTS"
-    except Exception as e:
-        return f"WIKI_ERROR: {e}"
-
-@tool
-def read_file(path: str) -> str:
-    """Read a local file using robust parsing for various document types. 
-    For PDFs, it first tries PyMuPDF (fitz) for high-quality text extraction, 
-    falling back to UnstructuredFileLoader. For images, it uses UnstructuredImageLoader.
-    The content will be truncated to 15000 characters.
-    """
-    if not path or not os.path.exists(path):
-        return "ERROR: File not found"
-    try:
-        ext = os.path.splitext(path)[1].lower()
-        if ext in {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"}:
-            loader = UnstructuredImageLoader(path)
-            docs = loader.load()
-            content = "\n\n".join([doc.page_content for doc in docs])
-        elif ext == ".pdf":
-            try:
-                doc = fitz.open(path)
-                content = "\n".join([page.get_text() for page in doc])
-                doc.close()
-                if not content.strip():
-                    raise ValueError("No text extracted with fitz")
-            except Exception:
-                loader = UnstructuredFileLoader(path)
-                docs = loader.load()
-                content = "\n\n".join([doc.page_content for doc in docs])
-        else:
-            loader = UnstructuredFileLoader(path)
-            docs = loader.load()
-            content = "\n\n".join([doc.page_content for doc in docs])
-        
-        return content[:15000] if content else "EMPTY_FILE"
-    except Exception as e:
-        return f"ERROR: {e}"
+from tools import __all__ as tools, tools_by_name
+from llm import invoke_llm
 
-@tool
-def browse_url(url: str) -> str:
-    """Browse a URL and return its clean text content. Use this to read the full content of a webpage identified by web_search.
-    If the page content is too large, it will be truncated.
-    """
-    try:
-        import requests
-        from bs4 import BeautifulSoup
-        response = requests.get(url, timeout=10, headers={"User-Agent": "mozilla/5.0"})
-        response.raise_for_status()
-        soup = BeautifulSoup(response.text, 'html.parser')
-        for script in soup(['script', 'style', 'nav', 'header', 'footer', 'aside', 'form']):
-            script.extract()
-        text = soup.get_text()
-        lines = (line.strip() for line in text.splitlines())
-        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-        text = '\n'.join(chunk for chunk in chunks if chunk)
-        return text[:15000] # Truncate to avoid long contexts
-    except Exception as e:
-        return f"BROWSE_ERROR: {e}"
-
-@tool
-def get_youtube_transcript(url: str) -> str:
-    """Get YouTube transcript."""
-    try:
-        with tempfile.TemporaryDirectory() as tmp:
-            cmd = ["yt-dlp", "--skip-download", "--write-auto-subs", "--sub-lang", "en", "-o", f"{tmp}/video", url]
-            subprocess.run(cmd, capture_output=True, timeout=60)
-            vtt_files = list(Path(tmp).glob("*.vtt"))
-            if vtt_files:
-                content = vtt_files[0].read_text(encoding="utf-8", errors="replace")
-                lines = [l for l in content.splitlines() if l and not l.startswith(('<', '-->', 'WEBVTT')) and not l.isdigit()]
-                return "\n".join(lines)[:15000] or "NO_TRANSCRIPT"
-            return "NO_SUBTITLES"
-    except Exception as e:
-        return f"TRANSCRIPT_ERROR: {e}"
-
-@tool
-def reverse_text(text: str) -> str:
-    """Reverse the given text."""
-    return text[::-1]
-
-
-@tool
-def transcribe_audio(path: str) -> str:
-    """Transcribe audio file to text."""
-    try:
-        import whisper
-        model = whisper.load_model("base")
-        result = model.transcribe(path)
-        return result["text"][:5000] or "NO_TRANSCRIPTION"
-    except Exception as e:
-        return f"AUDIO_TRANSCRIPTION_ERROR: {e}"
+load_dotenv()
 
-# --- Tools Configuration ---
-tools = [
-    web_search, 
-    wiki_search, 
-    read_file, 
-    get_youtube_transcript, 
-    reverse_text, 
-    transcribe_audio,
-    python_repl,
-    browse_url
-]
-tools_by_name = {t.name: t for t in tools}
 
 class AgentState(TypedDict):
     messages: List[Union[HumanMessage, AIMessage, SystemMessage, ToolMessage]]
     reflection_count: int
 
-# --- LLM Invocation with Fallback ---
+
 def _invoke_llm_with_tools(messages, fallback_count=0):
-    """Invoke LLM with tool binding and rate limit handling. 
-    Primary: Gemini 1.5 Flash (Multimodal, Free Tier).
-    Fallback: Groq (Llama 3.3).
-    """
-    try:
-        # Primary: Gemini 1.5 Flash
-        model = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
-        model_with_tools = model.bind_tools(tools)
-        return model_with_tools.invoke(messages)
-    except Exception as e:
-        print(f"Gemini Error: {e}. Falling back to Groq...")
-        try:
-            # Fallback: Groq
-            groq_model = "llama-3.3-70b-versatile" if fallback_count == 0 else "llama-3.1-8b-instant"
-            model = ChatGroq(model=groq_model, temperature=0)
-            model_with_tools = model.bind_tools(tools)
-            return model_with_tools.invoke(messages)
-        except Exception as groq_e:
-            err_msg = str(groq_e).lower()
-            if ("rate limit" in err_msg or "429" in err_msg) and fallback_count < 2:
-                import time
-                wait_time = 10 * (fallback_count + 1)
-                print(f"Groq Rate limit hit. Waiting {wait_time}s...")
-                time.sleep(wait_time)
-                return _invoke_llm_with_tools(messages, fallback_count + 1)
-            print(f"Critical LLM Error: {groq_e}")
-            return AIMessage(content=f"ERROR: All LLM invocations failed: {groq_e}")
+    """Invoke LLM with provider fallback."""
+    return invoke_llm(messages, tools, fallback_count)
 
 # --- Helper Functions ---
 def is_reversed_text(question: str) -> bool:

agent_old.py

@@ -1,615 +0,0 @@
-import os
-import base64
-import requests
-import json
-import traceback
-import datetime
-import subprocess
-import tempfile
-import time
-from typing import TypedDict, List, Dict, Any, Optional, Union
-from langchain_core import tools
-from langgraph.graph import StateGraph, START, END
-from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFacePipeline
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage
-from langchain_core.tools import tool
-from langchain_community.document_loaders import WikipediaLoader
-from ddgs import DDGS
-from dotenv import load_dotenv
-from groq import Groq
-from langchain_groq import ChatGroq
-from langchain_community.document_loaders.image import UnstructuredImageLoader
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_google_genai import ChatGoogleGenerativeAI
-
-try:
-    import cv2
-except ImportError:
-    cv2 = None
-
-# os.environ["USER_AGENT"] = "gaia-agent/1.0"
-
-whisper_model = None
-def get_whisper():
-    global whisper_model
-    if whisper_model is None:
-        import whisper
-        # Lazy load the smallest, fastest model
-        whisper_model = whisper.load_model("base")
-    return whisper_model
-
-load_dotenv(override=True)
-
-# Base Hugging Face LLM used by the chat wrapper
-# base_llm = HuggingFaceEndpoint(
-#     repo_id="openai/gpt-oss-20b:hyperbolic",
-#     # deepseek-ai/DeepSeek-OCR:novita
-#     task="text-generation",
-#     temperature=0.0,
-#     huggingfacehub_api_token=os.getenv("HUGGINGFACEHUB_API_TOKEN"),
-# )
-
-# Model initializations moved to smart_invoke for lazy loading to prevent import errors if keys are missing.
-
-def smart_invoke(msgs, use_tools=False, start_tier=0):
-    """
-    Tiered fallback: OpenRouter -> Gemini -> Groq -> NVIDIA -> Vercel.
-    Retries next tier if a 429 (rate limit), 402 (credits), or 404 (model found) error occurs.
-    """
-    
-    # Adaptive Gemini names verified via list_models (REST API)
-    gemini_alternatives = ["gemini-2.5-flash", "gemini-2.0-flash", "gemini-flash-latest", "gemini-pro-latest"]
-    
-    tiers_config = [
-        {"name": "Qwen3-Next-80B", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "qwen/qwen3-next-80b-a3b-instruct:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "Gemma-3-27B", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "google/gemma-3-27b-it:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "NVIDIA-Nemotron-Super", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "nvidia/nemotron-3-super-120b-a12b:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "OpenRouter-FreeRouter", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "openrouter/free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "DeepSeek-R1", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "deepseek/deepseek-r1:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "Gemini-Flash", "key": "GOOGLE_API_KEY", "provider": "google", "model_name": "gemini-2.0-flash", "alternatives": gemini_alternatives},
-        {"name": "Groq", "key": "GROQ_API_KEY", "provider": "groq", "model_name": "llama-3.3-70b-versatile"},
-    ]
-    
-    last_exception = None
-    for i in range(start_tier, len(tiers_config)):
-        tier = tiers_config[i]
-        api_key = os.getenv(tier["key"])
-        if not api_key:
-            continue 
-            
-        def create_model_instance(m_name, provider, b_url=None):
-            if provider == "openai":
-                from langchain_openai import ChatOpenAI
-                return ChatOpenAI(model=m_name, openai_api_key=api_key, openai_api_base=b_url, temperature=0)
-            elif provider == "google":
-                from langchain_google_genai import ChatGoogleGenerativeAI
-                return ChatGoogleGenerativeAI(model=m_name, temperature=0)
-            elif provider == "groq":
-                from langchain_groq import ChatGroq
-                return ChatGroq(model=m_name, temperature=0, max_retries=2)
-            return None
-
-        primary_model = create_model_instance(tier["model_name"], tier["provider"], tier.get("base_url"))
-        if use_tools:
-            primary_model = primary_model.bind_tools(tools)
-            
-        models_to_try = [primary_model]
-        if "alternatives" in tier:
-            for alt_name in tier["alternatives"]:
-                alt_model = create_model_instance(alt_name, tier["provider"], tier.get("base_url"))
-                if use_tools:
-                    alt_model = alt_model.bind_tools(tools)
-                models_to_try.append(alt_model)
-
-        for current_model in models_to_try:
-            try:
-                model_name = getattr(current_model, "model", tier["name"])
-                print(f"--- Calling {tier['name']} ({model_name}) ---")
-                return current_model.invoke(msgs), i
-            except Exception as e:
-                err_str = str(e).lower()
-                # If it's a 404 (not found) and we have more alternatives, continue to the next alternative
-                if any(x in err_str for x in ["not_found", "404"]) and current_model != models_to_try[-1]:
-                    print(f"--- {tier['name']} model {model_name} not found. Trying alternative... ---")
-                    continue
-                
-                # Catch other fallback triggers
-                if any(x in err_str for x in ["rate_limit", "429", "500", "503", "overloaded", "not_found", "404", "402", "credits", "decommissioned", "invalid_request_error"]):
-                    print(f"--- {tier['name']} Error: {e}. Trying next model/tier... ---")
-                    last_exception = e
-                    # If this tier has more alternatives, continue to the next one
-                    if current_model != models_to_try[-1]:
-                        continue
-                    break # Move to next tier
-                raise e
-            
-    if last_exception:
-        print("CRITICAL: All fallback tiers failed.")
-        raise last_exception
-    return None, 0
-
-@tool
-def web_search(keywords: str) -> str:
-    """
-    Uses duckduckgo to search the top 5 result on web
-
-    Use cases:
-     - Identify personal information
-     - Information search
-     - Finding organisation information
-     - Obtain the latest news
-
-      Args:
-         keywords: keywords used to search the web
-
-     Returns:
-         Search result (Header + body + url)
-     """
-    max_retries = 3
-    for attempt in range(max_retries):
-        try:
-            with DDGS() as ddgs:
-                output = ""
-                results = ddgs.text(keywords, max_results = 5)
-                for result in results:
-                    output += f"Results: {result['title']}\n{result['body']}\n{result['href']}\n\n"
-                return output
-        except Exception as e:
-            if attempt < max_retries - 1:
-                time.sleep(2 ** attempt)
-                continue
-            return f"Search failed after {max_retries} attempts: {str(e)}"
-
-@tool
-def wiki_search(query: str) -> str:
-    """
-    Search Wikipedia for a query and return up to 3 results.
-
-    Use cases:
-    When the question requires the use of information from wikipedia
-
-    Args:
-    query: The search query
-    """
-
-    search_docs = WikipediaLoader(query=query, load_max_docs=3, doc_content_chars_max=15000).load()
-    
-    if not search_docs:
-        return "No Wikipedia results found."
-        
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("title", "Unknown Title")}"/>\n{doc.page_content}\n</Document>'
-            for doc in search_docs
-        ])
-    return formatted_search_docs
-
-def get_vision_models():
-    """Returns a list of vision models to try, in order of preference."""
-    configs = [
-        {"name": "OpenRouter-Qwen3-VL", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "qwen/qwen3-vl-235b-thinking:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "NVIDIA-Nemotron-VL", "key": "NVIDIA_API_KEY", "provider": "openai", "model_name": "nvidia/nemotron-nano-2-vl:free", "base_url": "https://integrate.api.nvidia.com/v1"},
-        {"name": "OpenRouter-Gemma-3-27b-it", "key": "OPENROUTER_API_KEY", "provider": "openai", "model_name": "google/gemma-3-27b-it:free", "base_url": "https://openrouter.ai/api/v1"},
-        {"name": "Google-Gemini-2.0-Flash", "key": "GOOGLE_API_KEY", "provider": "google", "model_name": "gemini-2.0-flash"},
-        {"name": "Google-Gemini-Flash-Latest", "key": "GOOGLE_API_KEY", "provider": "google", "model_name": "gemini-flash-latest"},
-    ]
-    models = []
-    for cfg in configs:
-        api_key = os.getenv(cfg["key"])
-        if not api_key:
-            continue
-        if cfg["provider"] == "openai":
-            from langchain_openai import ChatOpenAI
-            m = ChatOpenAI(model=cfg["model_name"], openai_api_key=api_key, openai_api_base=cfg.get("base_url"), temperature=0)
-        elif cfg["provider"] == "google":
-            from langchain_google_genai import ChatGoogleGenerativeAI
-            m = ChatGoogleGenerativeAI(model=cfg["model_name"], temperature=0)
-        elif cfg["provider"] == "groq":
-            from langchain_groq import ChatGroq
-            m = ChatGroq(model=cfg["model_name"], temperature=0)
-        models.append({"name": cfg["name"], "model": m})
-    return models
-
-@tool
-def analyze_image(image_path: str, question: str) -> str:
-    """
-    EXTERNAL SIGHT API: Sends an image path to a Vision Model to answer a specific question.
-    YOU MUST CALL THIS TOOL ANY TIME an image (.png, .jpg, .jpeg) is attached to the prompt.
-    NEVER claim you cannot see images. Use this tool instead.
-    
-    Args:
-        image_path: The local path or URL to the image file.
-        question: Specific question describing what you want the vision model to look for.
-    """
-    try:
-        if not os.path.exists(image_path):
-            return f"Error: Image file not found at {image_path}"
-            
-        # If it's a local file, we encode it to base64
-        with open(image_path, "rb") as image_file:
-            encoded_image = base64.b64encode(image_file.read()).decode('utf-8')
-            
-        message = HumanMessage(
-            content=[
-                {"type": "text", "text": question},
-                {
-                    "type": "image_url",
-                    "image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"},
-                },
-            ]
-        )
-        
-        vision_models = get_vision_models()
-        if not vision_models:
-            return "Error: No vision models configured (missing API keys)."
-            
-        last_err = None
-        for item in vision_models:
-            try:
-                m_name = getattr(item['model'], 'model', 'unknown')
-                print(f"--- Calling Vision Model: {item['name']} ({m_name}) ---")
-                response = item['model'].invoke([message])
-                return extract_text_from_content(response.content)
-            except Exception as e:
-                print(f"Vision Model {item['name']} failed.")
-                traceback.print_exc()
-                last_err = e
-        return f"Error analyzing image: All vision models failed. Last error: {str(last_err)}"
-    except Exception as e:
-        traceback.print_exc()
-        return f"Error reading/processing image: {str(e)}"
-
-@tool
-def analyze_audio(audio_path: str, question: str) -> str:
-    """
-    Transcribes an audio file (.mp3, .wav, .m4a) to answer questions about what is spoken.
-    
-    Args:
-        audio_path: The local path to the audio file.
-        question: The specific question to ask.
-    """
-    try:
-        model = get_whisper()
-        result = model.transcribe(audio_path)
-        transcript = result["text"]
-        return f"Audio Transcript:\n{transcript}"
-    except Exception as e:
-        return f"Error analyzing audio: {str(e)}. Tip: You requires 'ffmpeg' installed on your system."
-
-@tool
-def analyze_video(video_path: str, question: str) -> str:
-    """
-    EXTERNAL SIGHT/HEARING API: Sends a video file to an external Vision/Audio model.
-    YOU MUST CALL THIS TOOL ANY TIME a video (.mp4, .avi) is attached to the prompt.
-    NEVER claim you cannot analyze videos. Use this tool instead.
-    
-    Args:
-        video_path: The local path to the video file.
-        question: Specific question describing what you want to extract from the video.
-    """
-    if cv2 is None:
-        return "Error: cv2 is not installed. Please install opencv-python."
-    
-    temp_dir = tempfile.gettempdir()
-    downloaded_video = None
-    
-    try:
-        # Check if video_path is a URL
-        if video_path.startswith("http"):
-            print(f"Downloading video from URL: {video_path}")
-            downloaded_video = os.path.join(temp_dir, f"video_{int(time.time())}.mp4")
-            try:
-                # Use yt-dlp to download the video
-                # Note: --ffmpeg-location could be used if we knew where it was, but we assume it's in path or missing
-                subprocess.run(["yt-dlp", "-f", "best[ext=mp4]/mp4", "-o", downloaded_video, video_path], check=True, timeout=120)
-                video_path = downloaded_video
-            except Exception as e:
-                return f"Error downloading video from URL: {str(e)}. Tip: Check if yt-dlp is installed and the URL is valid."
-
-        # 1. Extract frames evenly spaced throughout the video
-        cap = cv2.VideoCapture(video_path)
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        if total_frames == 0:
-            return "Error: Could not read video frames."
-        
-        # Take 5 frames as a summary
-        frame_indices = [int(i * total_frames / 5) for i in range(5)]
-        extracted_descriptions = []
-        
-        vision_models = get_vision_models()
-        # Ensure Groq-Llama is at the front for video if preferred, but we'll use the default order for now.
-        
-        for idx_num, frame_idx in enumerate(frame_indices):
-            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-            ret, frame = cap.read()
-            if ret:
-                # Convert frame to base64
-                _, buffer = cv2.imencode('.jpg', frame)
-                encoded_image = base64.b64encode(buffer).decode('utf-8')
-                
-                # Ask a vision model to describe the frame (with fallback)
-                msg = HumanMessage(
-                    content=[
-                        {"type": "text", "text": f"Describe what is happening in this video frame concisely. Focus on aspects related to: {question}"},
-                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}},
-                    ]
-                )
-                
-                desc = "No description available."
-                for item in vision_models:
-                    try:
-                        print(f"--- Calling Vision Model for Frame {idx_num+1}: {item['name']} ---")
-                        desc = item['model'].invoke([msg]).content
-                        break
-                    except Exception as e:
-                        print(f"Vision Model {item['name']} failed for frame: {e}")
-                        continue
-                
-                extracted_descriptions.append(f"Frame {idx_num + 1}: {desc}")
-                
-        cap.release()
-        
-        # 2. Compile the context for the agent
-        video_context = "\n".join(extracted_descriptions)
-        
-        # 3. Transcribe audio if possible
-        try:
-            whisper_mod = get_whisper()
-            trans_result = whisper_mod.transcribe(video_path)
-            transcript = trans_result.get("text", "")
-            if transcript.strip():
-                video_context += f"\n\nVideo Audio Transcript:\n{transcript}"
-        except Exception as e:
-            video_context += f"\n\n(No audio transcript generated: {e})"
-        
-        return f"Video Summary based on extracted frames and audio:\n{video_context}"
-    except Exception as e:
-        err_msg = str(e)
-        if "No address associated with hostname" in err_msg or "Failed to resolve" in err_msg:
-            return f"Error: The environment cannot access the internet (DNS failure). Please use 'web_search' or 'wiki_search' to find information about this video content instead of trying to download it."
-        return f"Error analyzing video: {err_msg}"
-    finally:
-        if downloaded_video and os.path.exists(downloaded_video):
-            try:
-                os.remove(downloaded_video)
-            except:
-                pass
-
-@tool
-def read_url(url: str) -> str:
-    """
-    Reads and extracts text from a specific webpage URL.
-    Use this if a web search snippet doesn't contain enough detail.
-    """
-    try:
-        loader = WebBaseLoader(url)
-        docs = loader.load()
-        # Truncate to first 15000 characters to fit context
-        if not docs:
-            return "No content could be extracted from this URL."
-        return docs[0].page_content[:15000]
-    except Exception as e:
-        return f"Error reading URL: {e}"
-
-@tool
-def run_python_script(code: str) -> str:
-    """
-    Executes a Python script locally and returns the stdout and stderr.
-    Use this to perform complex math, data analysis (e.g. pandas), or file processing.
-    When given a file path, you can write python code to read and analyze it.
-    """
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-        f.write(code)
-        temp_file_name = f.name
-        
-    try:
-        result = subprocess.run(
-            ["python", temp_file_name],
-            capture_output=True,
-            text=True,
-            timeout=60
-        )
-        os.remove(temp_file_name)
-        
-        output = result.stdout
-        if result.stderr:
-            output += f"\nErrors:\n{result.stderr}"
-            
-        return (output or "Script executed successfully with no output.")[:15000]
-    except subprocess.TimeoutExpired:
-        os.remove(temp_file_name)
-        return "Script execution timed out after 60 seconds."
-    except Exception as e:
-        if os.path.exists(temp_file_name):
-            os.remove(temp_file_name)
-        return f"Failed to execute script: {str(e)}"
-
-@tool
-def read_document(file_path: str) -> str:
-    """
-    Reads the text contents of a local document (.txt, .csv, .json, .md).
-    For binary files like .xlsx or .pdf, use run_python_script to process them instead.
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-            if len(content) > 15000:
-                return content[:15000] + "... (truncated)"
-            return content
-    except Exception as e:
-        return f"Error reading document: {str(e)}. Tip: You can try running a python script to read it!"
-
-system_prompt = """
-You are a helpful assistant tasked with answering questions using a set of tools. 
-Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
-FINAL ANSWER: [YOUR FINAL ANSWER]. 
-YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
-Your answer should only start with "FINAL ANSWER: ", then follows with the answer. 
-"""
-
-class AgentState(TypedDict):
-    messages: List[Union[HumanMessage, AIMessage, SystemMessage]]
-
-def read_message(state: AgentState) -> AgentState:
-    messages = state["messages"]
-    print(f"Processing question: {messages[-1].content if messages else ''}")
-    # Just pass the messages through to the next node
-    return {"messages": messages}
-
-def restart_required(state: AgentState) -> AgentState:
-    messages = state["messages"]
-    print(f"Processing question: {messages[-1].content if messages else ''}")
-    # Just pass the messages through to the next node
-    return {"messages": messages}
-
-# def tool_message(state: AgentState) -> AgentState:
-#     messages = state["messages"]
-#     prompt = f"""
-#     You are a GAIA question answering expert. 
-#     Your task is to decide whether to use a tool or not.
-#     If you need to use a tool, answer ONLY:
-#         CALL_TOOL: <your tool name>
-#     If you do not need to use a tool, answer ONLY:
-#         NO_TOOL
-#     Here is the question:
-#     {messages}
-#     """
-#     return {"messages": messages}
-#     response = model_with_tools.invoke(prompt)
-#     return {"messages": messages + [response]}
-
-# Augment the LLM with tools
-tools = [web_search, wiki_search, analyze_image, analyze_audio, analyze_video, read_url, run_python_script, read_document]
-tools_by_name = {tool.name: tool for tool in tools}
-def extract_text_from_content(content: Any) -> str:
-    """Extracts a simple string from various possible AIMessage content formats."""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        text_parts = []
-        for part in content:
-            if isinstance(part, str):
-                text_parts.append(part)
-            elif isinstance(part, dict) and "text" in part:
-                text_parts.append(part["text"])
-            elif isinstance(part, dict) and "type" in part and part["type"] == "text":
-                text_parts.append(part.get("text", ""))
-        return "".join(text_parts)
-    return str(content)
-
-def answer_message(state: AgentState) -> AgentState:
-    messages = state["messages"]
-    current_date = datetime.datetime.now().strftime("%Y-%m-%d")
-    
-    prompt = [SystemMessage(f"""
-You are a master of the GAIA benchmark, a general AI assistant designed to solve complex multi-step tasks.
-Think carefully and logically. Use your tools effectively. Use your internal monologue to plan your steps.
-
-TODAY'S EXACT DATE is {current_date}. Keep this in mind for all time-sensitive queries.
-
-CRITICAL RULES:
-1. If you see a path like `[Attached File Local Path: ...]` followed by an image, video, or audio file, YOU MUST USE THE CORRESPONDING TOOL (analyze_image, analyze_video, analyze_audio) IMMEDIATELY in your next step.
-2. Plan your steps ahead. 12 steps is your LIMIT for the reasoning loop, so make every step count.
-3. If a tool fails (e.g., 429 or 402), the system will automatically try another model for you, so just keep going!
-4. Be concise and accurate. YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list.
-5. CHAIN-OF-THOUGHT: For complex questions, show your reasoning step by step before giving the final answer.
-6. USE TOOLS AGGRESSIVELY: If a question requires computation, file reading, or web search, use the appropriate tools - don't try to answer from memory.
-7. VERIFY YOUR ANSWER: Double-check calculations and facts using tools when uncertain.
-""")]
-    messages = prompt + messages
-
-    # Force tool usage if image path is detected
-    for msg in state["messages"]:
-        if isinstance(msg, HumanMessage) and "[Attached File Local Path:" in msg.content:
-            messages.append(HumanMessage(content="IMPORTANT: I see an image path in the message. I MUST call the analyze_image tool IMMEDIATELY in my next step to see it."))
-
-    # Multi-step ReAct Loop (Up to 12 reasoning steps)
-    max_steps = 12
-    draft_response = None
-    current_tier = 0
-    
-    for step in range(max_steps):
-        if step > 0:
-            time.sleep(3)
-            
-        print(f"--- ReAct Step {step + 1} ---")
-        
-        # Max history truncation to avoid 413 Request Too Large errors
-        safe_messages = messages[:2] + messages[-6:] if len(messages) > 10 else messages
-        
-        ai_msg, current_tier = smart_invoke(safe_messages, use_tools=True, start_tier=current_tier)
-        messages.append(ai_msg)
-
-        # Check if the model requested tools
-        tool_calls = getattr(ai_msg, "tool_calls", None) or []
-        if not tool_calls:
-            # Model decided it has enough info to answer
-            draft_response = ai_msg
-            print(f"Model found answer or stopped tools: {ai_msg.content}")
-            break
-
-        # Execute requested tools and append their text output into the conversation
-        for tool_call in tool_calls:
-            name = tool_call["name"]
-            args = tool_call["args"]
-            tool_call_id = tool_call.get("id")
-            print(f"Calling tool: {name} with args: {args}")
-            try:
-                tool = tools_by_name[name]
-                tool_result = tool.invoke(args)
-            except Exception as e:
-                tool_result = f"Error executing tool {name}: {str(e)}"
-            
-            # Using ToolMessage allows the model to map the result back perfectly to its request
-            messages.append(ToolMessage(content=str(tool_result), tool_call_id=tool_call_id, name=name))
-
-    # If we exhausted all steps without an answer, force a draft response
-    if draft_response is None:
-        print("Max reasoning steps reached. Forcing answer extraction.")
-        forced_msg = HumanMessage(content="You have reached the maximum reasoning steps. Please provide your best final answer based on the current context without any more tool calls.")
-        messages.append(forced_msg)
-        draft_response, _ = smart_invoke(messages, use_tools=False)
-
-    # Third pass: strict GAIA formatting extraction
-    formatting_sys = SystemMessage(
-        content=(
-            "You are a strict output formatter for the GAIA benchmark. "
-            "Given a verbose draft answer, extract ONLY the final exact answer required. "
-            "Return nothing else. DO NOT include prefixes like 'The answer is'. "
-            "Strip trailing whitespace only. "
-            "If the answer is a number, just return the number. "
-            "If the answer is a list or set of elements, return them as a COMMA-SEPARATED list (e.g., 'a, b, c'). "
-            "Preserve necessary punctuation within answers (e.g., 'Dr. Smith' should keep the period)."
-        )
-    )
-    final_response, _ = smart_invoke([formatting_sys, HumanMessage(content=extract_text_from_content(draft_response.content))], use_tools=False, start_tier=current_tier)
-    print(f"Draft response: {draft_response.content}")
-    print(f"Strict Final response: {final_response.content}")
-
-    # Return messages including the final AIMessage so BasicAgent reads .content
-    # Ensure final_response has string content for basic agents
-    if not isinstance(final_response.content, str):
-        final_response.content = extract_text_from_content(final_response.content)
-        
-    messages.append(draft_response)
-    messages.append(final_response)
-    return {"messages": messages}
-
-
-def build_graph():
-    agent_graph = StateGraph(AgentState)
-
-    # Add nodes
-    agent_graph.add_node("read_message", read_message)
-    agent_graph.add_node("answer_message", answer_message)
-
-    # Add edges
-    agent_graph.add_edge(START, "read_message")
-    agent_graph.add_edge("read_message", "answer_message")
-
-    # Final edge
-    agent_graph.add_edge("answer_message", END)
-
-    # Compile and return the executable graph for use in app.py
-    compiled_graph = agent_graph.compile()
-    return compiled_graph

app copy.py

@@ -1,264 +0,0 @@
-import os
-# import gradio as gr
-import requests
-import inspect
-import pandas as pd
-from langchain_core.messages import HumanMessage
-from agent import build_graph 
-from huggingface_hub import HfApi, hf_hub_download
-import logging
-
-logger = logging.getLogger(__name__)
-
-# (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.")
-        self.graph = build_graph()
-
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        messages = [HumanMessage(content=question)]
-        result = self.graph.invoke({"messages": messages})
-        answer = result['messages'][-1].content
-        return answer
-
-def file_extract(local_file_path, task_id):
-    if not local_file_path:
-        return None
-        
-    token = os.getenv("HUGGINGFACEHUB_API_TOKEN") or os.getenv("HF_TOKEN")
-    
-    # GAIA files are usually placed in date-based subdirectories
-    prefixes = ["2023/validation/", "2023/test/", "2023/train/", ""]
-    
-    for prefix in prefixes:
-        try:
-            resolved_path = hf_hub_download(
-                repo_id="gaia-benchmark/GAIA",
-                filename=f"{prefix}{local_file_path}",
-                repo_type="dataset",
-                token=token
-            )
-            return resolved_path
-        except Exception:
-            continue
-            
-    logger.warning(f"Could not download file '{local_file_path}' for task_id {task_id}. Make sure you accepted GAIA terms on HF and set HF_TOKEN.")
-    return None
-        
-agent = BasicAgent()
-questions_url = f"{DEFAULT_API_URL}/questions"
-response = requests.get(questions_url, timeout=15)
-response.raise_for_status()
-questions_data = response.json()
-import time
-print(f"Running agent on {len(questions_data)} questions sequentially to avoid 429 errors...")
-for item in questions_data[:2]:
-    question_text = item.get("question")
-    if question_text is None:
-        continue
-    files_text = item.get("files")
-    task_id = item.get("task_id")
-    file_name = item.get("file_name")
-    
-    if file_name:
-        # Actually download the file to local cache and get absolute path
-        resolved_path = file_extract(file_name, task_id)
-        if resolved_path:
-            question_text += f"\n\n[Attached File Local Path: {resolved_path}]"
-        else:
-            question_text += f"\n\n[Attached File: {file_name} (Download Failed)]"
-            
-    print(f"Processing Task ID: {task_id}")
-    output = agent(question_text)
-    print("Q:", question_text)
-    print("A:", output)
-    print("-" * 40)
-    # Stagger requests to refill Token bucket and provide space for other concurrent tasks if any
-    time.sleep(5)
-
-
-
-
-# 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
-
-#     if profile:
-#         username= f"{profile.username}"
-#         print(f"User logged in: {username}")
-#     else:
-#         print("User not logged in.")
-#         return "Please Login to Hugging Face with the button.", None
-
-#     api_url = DEFAULT_API_URL
-#     questions_url = f"{api_url}/questions"
-#     submit_url = f"{api_url}/submit"
-
-#     # 1. Instantiate Agent ( modify this part to create your agent)
-#     try:
-#         agent = BasicAgent()
-#     except Exception as e:
-#         print(f"Error instantiating agent: {e}")
-#         return f"Error initializing agent: {e}", None
-#     # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-#     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-#     print(agent_code)
-
-#     # 2. Fetch Questions
-#     print(f"Fetching questions from: {questions_url}")
-#     try:
-#         response = requests.get(questions_url, timeout=15)
-#         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(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
-#     except Exception as e:
-#         print(f"An unexpected error occurred fetching questions: {e}")
-#         return f"An unexpected error occurred fetching questions: {e}", None
-
-#     # 3. Run your Agent
-#     results_log = []
-#     answers_payload = []
-#     # print(f"Running agent on {len(questions_data)} questions...")
-#     print(f"Running agent on {len(questions_data[:5])} questions temporarily...")
-#     for item in questions_data[:5]:
-#         task_id = item.get("task_id")
-#         question_text = item.get("question")
-#         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})
-#         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}"})
-
-#     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}
-#     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-#     print(status_update)
-
-#     # 5. Submit
-#     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
-#     try:
-#         response = requests.post(submit_url, json=submission_data, timeout=60)
-#         response.raise_for_status()
-#         result_data = response.json()
-#         final_status = (
-#             f"Submission Successful!\n"
-#             f"User: {result_data.get('username')}\n"
-#             f"Overall Score: {result_data.get('score', 'N/A')}% "
-#             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-#             f"Message: {result_data.get('message', 'No message received.')}"
-#         )
-#         print("Submission successful.")
-#         results_df = pd.DataFrame(results_log)
-#         return final_status, results_df
-#     except requests.exceptions.HTTPError as e:
-#         error_detail = f"Server responded with status {e.response.status_code}."
-#         try:
-#             error_json = e.response.json()
-#             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-#         except requests.exceptions.JSONDecodeError:
-#             error_detail += f" Response: {e.response.text[:500]}"
-#         status_message = f"Submission Failed: {error_detail}"
-#         print(status_message)
-#         results_df = pd.DataFrame(results_log)
-#         return status_message, results_df
-#     except requests.exceptions.Timeout:
-#         status_message = "Submission Failed: The request timed out."
-#         print(status_message)
-#         results_df = pd.DataFrame(results_log)
-#         return status_message, results_df
-#     except requests.exceptions.RequestException as e:
-#         status_message = f"Submission Failed: Network error - {e}"
-#         print(status_message)
-#         results_df = pd.DataFrame(results_log)
-#         return status_message, results_df
-#     except Exception as e:
-#         status_message = f"An unexpected error occurred during submission: {e}"
-#         print(status_message)
-#         results_df = pd.DataFrame(results_log)
-#         return status_message, results_df
-
-
-# # --- Build Gradio Interface using Blocks ---
-# with gr.Blocks() as demo:
-#     gr.Markdown("# Basic Agent Evaluation Runner")
-#     gr.Markdown(
-#         """
-#         **Instructions:**
-
-#         1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-#         2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-#         3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-#         ---
-#         **Disclaimers:**
-#         Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-#         This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-#         """
-#     )
-
-#     gr.LoginButton()
-
-#     run_button = gr.Button("Run Evaluation & Submit All Answers")
-
-#     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]
-#     )
-
-# if __name__ == "__main__":
-#     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
-
-#     if space_host_startup:
-#         print(f"✅ SPACE_HOST found: {space_host_startup}")
-#         print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-#     else:
-#         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-
-#     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")
-#     else:
-#         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
-#     print("-"*(60 + len(" App Starting ")) + "\n")
-
-#     print("Launching Gradio Interface for Basic Agent Evaluation...")
-#     demo.launch(debug=True, share=False)

check_q19.py

@@ -1,13 +0,0 @@
-import os
-import requests
-
-resp = requests.get("https://agents-course-unit4-scoring.hf.space/questions")
-questions = resp.json()
-
-# Check Q19 question content
-q19 = questions[18]
-print(f"Q19: {q19['question']}")
-print()
-print(f"'excel' in q19: {'excel' in q19['question'].lower()}")
-print(f"'sales' in q19: {'sales' in q19['question'].lower()}")
-print(f"'89706' in q19: {'89706' in q19['question']}")

check_q5.py

@@ -1,11 +0,0 @@
-import requests
-
-resp = requests.get('https://agents-course-unit4-scoring.hf.space/questions')
-questions = resp.json()
-
-q5 = questions[4]
-print(f"Q5: {q5['question']}")
-print()
-print(f"'featured article' in q5: {'featured article' in q5['question'].lower()}")
-print(f"'dinosaur' in q5: {'dinosaur' in q5['question'].lower()}")
-print(f"'FunkMonk' in q5: {'FunkMonk' in q5['question']}")

debug_check.py

@@ -1,35 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-graph = build_graph()
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()
-
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Check Q1, Q5, Q7
-for i in [0, 4, 6]:
-    q = questions[i]
-    task_id = q['task_id']
-    question = q['question']
-    ground_truth = answer_map.get(task_id, "NOT FOUND")
-    
-    result = graph.invoke({"messages": [HumanMessage(content=question)]})
-    answer = result['messages'][-1].content
-    
-    print(f"\n=== Q{i+1} ===")
-    print(f"Q: {question[:80]}...")
-    print(f"GT: {ground_truth}")
-    print(f"Ans: {answer[:50]}")

debug_files.py

@@ -1,32 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-graph = build_graph()
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()
-
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Show questions with files
-for i in [3, 9, 11, 13, 18]:
-    q = questions[i]
-    task_id = q['task_id']
-    question = q['question']
-    ground_truth = answer_map.get(task_id, "NOT FOUND")
-    file_name = q.get('file_name', '')
-    
-    print(f"\n=== Q{i+1} | File: {file_name} ===")
-    print(f"Q: {question[:100]}...")
-    print(f"GT: {ground_truth}")

debug_q19.py

@@ -1,61 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-def file_extract(local_file_path, task_id):
-    if not local_file_path:
-        return None
-    token = os.getenv("HUGGINGFACEHUB_API_TOKEN") or os.getenv("HF_TOKEN")
-    prefixes = ["2023/validation/", "2023/test/", "2023/train/", ""]
-    for prefix in prefixes:
-        try:
-            resolved_path = hf_hub_download(
-                repo_id="gaia-benchmark/GAIA",
-                filename=f"{prefix}{local_file_path}",
-                repo_type="dataset",
-                token=token
-            )
-            return resolved_path
-        except Exception:
-            continue
-    return None
-
-graph = build_graph()
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()
-
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Q19
-q = questions[18]
-task_id = q['task_id']
-question = q['question']
-file_name = q.get('file_name')
-ground_truth = answer_map.get(task_id, "NOT FOUND")
-
-# Add file path
-resolved_path = None
-if file_name:
-    resolved_path = file_extract(file_name, task_id)
-    if resolved_path:
-        question += f"\n\n[Attached File Local Path: {resolved_path}]"
-
-print(f"Q19 File: {file_name}")
-print(f"Resolved: {resolved_path}")
-print(f"Q19 Question: {question[:100]}...")
-
-result = graph.invoke({"messages": [HumanMessage(content=question)]})
-answer = result['messages'][-1].content
-print(f"GT: {ground_truth}")
-print(f"Ans: {answer[:80]}")

debug_q19_v2.py

@@ -1,25 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-graph = build_graph()
-resp = requests.get("https://agents-course-unit4-scoring.hf.space/questions")
-questions = resp.json()
-
-# Q19
-q = questions[18]
-question = q['question']
-print(f"Q19: {question}")
-print(f"Contains 'excel': {'excel' in question.lower()}")
-print(f"Contains 'food': {'food' in question.lower()}")
-print(f"Contains 'drinks': {'drinks' in question.lower()}")
-print()
-
-result = graph.invoke({"messages": [HumanMessage(content=question)]})
-print(f"Answer: {result['messages'][-1].content}")

debug_q1_q14.py

@@ -1,18 +0,0 @@
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-
-graph = build_graph()
-resp = requests.get('https://agents-course-unit4-scoring.hf.space/questions')
-questions = resp.json()
-
-# Q1
-q1 = questions[0]
-result = graph.invoke({'messages': [HumanMessage(content=q1['question'])]})
-print(f"Q1 answer: {result['messages'][-1].content}")
-print()
-
-# Q14
-q14 = questions[13]
-result = graph.invoke({'messages': [HumanMessage(content=q14['question'])]})
-print(f"Q14 answer: {result['messages'][-1].content}")

llm/__init__.py

@@ -0,0 +1,3 @@
+from llm.client import invoke_llm, PROVIDER_ORDER
+
+__all__ = ["invoke_llm", "PROVIDER_ORDER"]

llm/client.py

@@ -0,0 +1,66 @@
+import os
+from typing import List
+
+from langchain_core.messages import AIMessage
+from llm.providers import PROVIDERS
+
+PROVIDER_ORDER = os.getenv("LLM_PROVIDER_ORDER", "gemini_gemma, gemini, groq").split(",")
+
+_degraded_providers = {}
+
+
+def _get_next_provider():
+    """Get next available provider in priority order."""
+    for name in PROVIDER_ORDER:
+        if name not in _degraded_providers:
+            yield name
+
+
+def invoke_llm(messages: List, tools: List, fallback_count: int = 0) -> AIMessage:
+    """Invoke LLM with provider fallback.
+
+    Args:
+        messages: Chat messages to send to LLM
+        tools: List of tools to bind
+        fallback_count: Current retry attempt
+
+    Returns:
+        AIMessage response from successful provider
+    """
+    provider_name = None
+    provider = None
+
+    for name in _get_next_provider():
+        provider_name = name
+        provider = PROVIDERS.get(name)
+        if provider:
+            break
+
+    if not provider:
+        return AIMessage(content="ERROR: No available LLM providers")
+
+    try:
+        models = provider.get_models()
+        model_index = min(fallback_count // 3, len(models) - 1)
+        model_name = models[model_index]
+
+        print(f"Invoking {provider_name} with model {model_name}")
+        return provider.invoke(messages, tools, model_name)
+
+    except Exception as e:
+        error_msg = str(e).lower()
+
+        if "rate limit" in error_msg or "429" in error_msg:
+            print(f"{provider_name} rate limit hit. Waiting before retry...")
+            import time
+            wait_time = 10 * (fallback_count + 1)
+            time.sleep(wait_time)
+
+        print(f"{provider_name} failed: {e}. Marking as degraded.")
+        _degraded_providers[provider_name] = True
+
+        remaining = [n for n in PROVIDER_ORDER if n not in _degraded_providers]
+        if remaining:
+            return invoke_llm(messages, tools, fallback_count + 1)
+
+        return AIMessage(content=f"ERROR: All LLM providers failed: {e}")

llm/providers/__init__.py

@@ -0,0 +1,9 @@
+from llm.providers import gemini, gemini_gemma, groq
+
+PROVIDERS = {
+    "gemini": gemini,
+    "gemini_gemma": gemini_gemma,
+    "groq": groq,
+}
+
+__all__ = ["PROVIDERS", "gemini", "gemini_gemma", "groq"]

llm/providers/gemini.py

@@ -0,0 +1,13 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+def invoke(messages, tools, model_name: str = "gemini-2.0-flash"):
+    """Invoke Gemini models (free tier)."""
+    model = ChatGoogleGenerativeAI(model=model_name, temperature=0)
+    model_with_tools = model.bind_tools(tools)
+    return model_with_tools.invoke(messages)
+
+
+def get_models():
+    """List available free tier models (best first)."""
+    return ["gemini-2.0-flash", "gemini-2.5-flash", "gemini-1.5-flash"]

llm/providers/gemini_gemma.py

@@ -0,0 +1,13 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+def invoke(messages, tools, model_name: str = "gemma-2-27b-it"):
+    """Invoke Google Gemma models (free tier)."""
+    model = ChatGoogleGenerativeAI(model=model_name, temperature=0)
+    model_with_tools = model.bind_tools(tools)
+    return model_with_tools.invoke(messages)
+
+
+def get_models():
+    """List available free tier models."""
+    return ["gemma-2-27b-it", "gemma-2-9b-it"]

llm/providers/groq.py

@@ -0,0 +1,13 @@
+from langchain_groq import ChatGroq
+
+
+def invoke(messages, tools, model_name: str = "llama-3.3-70b-versatile"):
+    """Invoke Groq LLM."""
+    model = ChatGroq(model=model_name, temperature=0)
+    model_with_tools = model.bind_tools(tools)
+    return model_with_tools.invoke(messages)
+
+
+def get_models():
+    """List available Groq models for fallback."""
+    return ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"]

quick_test.py

@@ -1,42 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# Initialize agent
-graph = build_graph()
-
-# Fetch 1 question
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()[:1]
-
-# Load ground truth
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Test
-q = questions[0]
-task_id = q['task_id']
-question = q['question']
-ground_truth = answer_map.get(task_id, "NOT FOUND")
-
-print(f"Question: {question[:100]}...")
-print(f"Ground Truth: {ground_truth}")
-print("-" * 40)
-
-result = graph.invoke({"messages": [HumanMessage(content=question)]})
-answer = result['messages'][-1].content
-print(f"Agent Answer: {answer}")
-print("-" * 40)
-
-is_correct = answer.strip().lower() == str(ground_truth).strip().lower()
-print(f"Correct: {is_correct}")

quick_test2.py

@@ -1,17 +0,0 @@
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-
-graph = build_graph()
-resp = requests.get('https://agents-course-unit4-scoring.hf.space/questions')
-questions = resp.json()
-
-# Test Q7
-q7 = questions[6]
-result = graph.invoke({'messages': [HumanMessage(content=q7['question'])]})
-print(f'Q7 answer: {result["messages"][-1].content}')
-
-# Test Q19  
-q19 = questions[18]
-result = graph.invoke({'messages': [HumanMessage(content=q19['question'])]})
-print(f'Q19 answer: {result["messages"][-1].content}')

skills-lock.json

@@ -0,0 +1,77 @@
+{
+  "version": 1,
+  "skills": {
+    "caveman": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/caveman/SKILL.md",
+      "computedHash": "536908fcfcb232600a5875aa85f1fd50fd13305e9d67379bcd95f07c8c916f3f"
+    },
+    "diagnose": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/diagnose/SKILL.md",
+      "computedHash": "1c3c85517ac42116fe5f2bfb5150f7b3e38ad23808e40b33fbb01f1afb611983"
+    },
+    "grill-me": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/grill-me/SKILL.md",
+      "computedHash": "daf64ca15f4fa081a6747766db538e2dbd1131725ed4fcdd3d538dc62c7035ba"
+    },
+    "grill-with-docs": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/grill-with-docs/SKILL.md",
+      "computedHash": "e95d83038cb68774469932969b060438bc457973657269a479571321c93a9140"
+    },
+    "improve-codebase-architecture": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/improve-codebase-architecture/SKILL.md",
+      "computedHash": "2da1d23b8f53cfe67f2e0b68924ab9f4ec400bb6480de097007eeaeb517d1722"
+    },
+    "setup-matt-pocock-skills": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/setup-matt-pocock-skills/SKILL.md",
+      "computedHash": "ab6e8143f9237f970435d95e94a0f79703faf125a0b8c583b35ee7fe340eeefe"
+    },
+    "tdd": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/tdd/SKILL.md",
+      "computedHash": "78b31b2120c5fe7aced1cebfd4c7c94acb0037fd4f89c83c67584414aa4173bd"
+    },
+    "to-issues": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/to-issues/SKILL.md",
+      "computedHash": "7b35050573981106debeb743de355fb18b898660bd643b646aa61a43c3fe1cef"
+    },
+    "to-prd": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/to-prd/SKILL.md",
+      "computedHash": "b3ebbc8aad6e91d04aa1b5c0387ce556b32adc8d60d130d61f90a2b84a38addc"
+    },
+    "triage": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/triage/SKILL.md",
+      "computedHash": "56ff15b41bbebfa4cb329d96150d9b297c1d919ce30784d883b8755b4bfd8e7e"
+    },
+    "write-a-skill": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/productivity/write-a-skill/SKILL.md",
+      "computedHash": "3b58a16bde08f84ed490cd449ecdc40289216d660e070c485f53bc2d1ed2b843"
+    },
+    "zoom-out": {
+      "source": "mattpocock/skills",
+      "sourceType": "github",
+      "skillPath": "skills/engineering/zoom-out/SKILL.md",
+      "computedHash": "a8b8ed45609fdfa9f184d0c9f69326e43822a42eebea14db2792d777373de562"
+    }
+  }
+}

test_react.py

@@ -1,18 +0,0 @@
-from agent import build_graph
-from langchain_core.messages import HumanMessage
-
-def test_agent():
-    graph = build_graph()
-    # Simple test: math question that should trigger python_repl
-    question = "Calculate the square root of 123456789 and multiply it by 42. Provide the final answer."
-    print(f"Testing with question: {question}")
-    
-    messages = [HumanMessage(content=question)]
-    result = graph.invoke({"messages": messages})
-    
-    print("\n--- Final Answer ---")
-    print(result['messages'][-1].content)
-    print("--------------------")
-
-if __name__ == "__main__":
-    test_agent()

test_status.py

@@ -1,45 +0,0 @@
-import os
-import requests
-import re
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-def extract_answer(content) -> str:
-    if isinstance(content, str):
-        match = re.search(r'FINAL ANSWER:\s*(.+?)(?:\n|$)', content, re.IGNORECASE)
-        if match:
-            return match.group(1).strip()
-        return content.strip()
-    return str(content)
-
-graph = build_graph()
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()
-
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Test all questions to see current state
-for i in range(20):
-    q = questions[i]
-    task_id = q['task_id']
-    question = q['question']
-    ground_truth = answer_map.get(task_id, "NOT FOUND")
-    file_name = q.get('file_name', '')
-    
-    result = graph.invoke({"messages": [HumanMessage(content=question)]})
-    answer_raw = result['messages'][-1].content
-    answer = extract_answer(answer_raw)
-    
-    is_correct = answer.strip().lower() == str(ground_truth).strip().lower()
-    status = "OK" if is_correct else "FAIL"
-    print(f"[Q{i+1:2d}] {status} | GT: {str(ground_truth)[:20]} | Ans: {answer[:20]}")

tools/__init__.py

@@ -0,0 +1,21 @@
+from tools.web.search import web_search
+from tools.web.wiki import wiki_search
+from tools.web.browse import browse_url
+from tools.file.reader import read_file
+from tools.python import python_repl
+from tools.reverse import reverse_text
+from tools.youtube import get_youtube_transcript
+from tools.audio import transcribe_audio
+
+__all__ = [
+    web_search,
+    wiki_search,
+    browse_url,
+    read_file,
+    python_repl,
+    reverse_text,
+    get_youtube_transcript,
+    transcribe_audio,
+]
+
+tools_by_name = {t.name: t for t in __all__}

tools/audio.py

@@ -0,0 +1,13 @@
+from langchain_core.tools import tool
+
+
+@tool
+def transcribe_audio(path: str) -> str:
+    """Transcribe audio file to text."""
+    try:
+        import whisper
+        model = whisper.load_model("base")
+        result = model.transcribe(path)
+        return result["text"][:5000] or "NO_TRANSCRIPTION"
+    except Exception as e:
+        return f"AUDIO_TRANSCRIPTION_ERROR: {e}"

tools/file/__init__.py

@@ -0,0 +1,3 @@
+from tools.file.reader import read_file
+
+__all__ = [read_file]

tools/file/reader.py

@@ -0,0 +1,41 @@
+import os
+import fitz
+from langchain_community.document_loaders import UnstructuredFileLoader
+from langchain_community.document_loaders.image import UnstructuredImageLoader
+from langchain_core.tools import tool
+
+
+@tool
+def read_file(path: str) -> str:
+    """Read a local file using robust parsing for various document types.
+    For PDFs, it first tries PyMuPDF (fitz) for high-quality text extraction,
+    falling back to UnstructuredFileLoader. For images, it uses UnstructuredImageLoader.
+    The content will be truncated to 15000 characters.
+    """
+    if not path or not os.path.exists(path):
+        return "ERROR: File not found"
+    try:
+        ext = os.path.splitext(path)[1].lower()
+        if ext in {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"}:
+            loader = UnstructuredImageLoader(path)
+            docs = loader.load()
+            content = "\n\n".join([doc.page_content for doc in docs])
+        elif ext == ".pdf":
+            try:
+                doc = fitz.open(path)
+                content = "\n".join([page.get_text() for page in doc])
+                doc.close()
+                if not content.strip():
+                    raise ValueError("No text extracted with fitz")
+            except Exception:
+                loader = UnstructuredFileLoader(path)
+                docs = loader.load()
+                content = "\n\n".join([doc.page_content for doc in docs])
+        else:
+            loader = UnstructuredFileLoader(path)
+            docs = loader.load()
+            content = "\n\n".join([doc.page_content for doc in docs])
+
+        return content[:15000] if content else "EMPTY_FILE"
+    except Exception as e:
+        return f"ERROR: {e}"

tools/python.py

@@ -0,0 +1,22 @@
+import sys
+from io import StringIO
+from langchain_core.tools import tool
+
+
+@tool
+def python_repl(code: str) -> str:
+    """Execute python code and return the output. Use this for calculations, data analysis, or processing files.
+    The code should be a valid python script that prints the final result.
+    You can use libraries like pandas, numpy, PIL, etc.
+    Example: print(df.head()) or print(2 + 2)"""
+    try:
+        old_stdout = sys.stdout
+        redirected_output = StringIO()
+        sys.stdout = redirected_output
+        try:
+            exec(code, globals())
+        finally:
+            sys.stdout = old_stdout
+        return redirected_output.getvalue().strip() or "Code executed successfully (no output)."
+    except Exception as e:
+        return f"PYTHON_ERROR: {e}"

tools/reverse.py

@@ -0,0 +1,7 @@
+from langchain_core.tools import tool
+
+
+@tool
+def reverse_text(text: str) -> str:
+    """Reverse the given text."""
+    return text[::-1]

tools/web/__init__.py

@@ -0,0 +1,5 @@
+from tools.web.search import web_search
+from tools.web.wiki import wiki_search
+from tools.web.browse import browse_url
+
+__all__ = [web_search, wiki_search, browse_url]

tools/web/browse.py

@@ -0,0 +1,23 @@
+from langchain_core.tools import tool
+
+
+@tool
+def browse_url(url: str) -> str:
+    """Browse a URL and return its clean text content. Use this to read the full content of a webpage identified by web_search.
+    If the page content is too large, it will be truncated.
+    """
+    try:
+        import requests
+        from bs4 import BeautifulSoup
+        response = requests.get(url, timeout=10, headers={"User-Agent": "mozilla/5.0"})
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, 'html.parser')
+        for script in soup(['script', 'style', 'nav', 'header', 'footer', 'aside', 'form']):
+            script.extract()
+        text = soup.get_text()
+        lines = (line.strip() for line in text.splitlines())
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        text = '\n'.join(chunk for chunk in chunks if chunk)
+        return text[:15000]
+    except Exception as e:
+        return f"BROWSE_ERROR: {e}"

tools/web/search.py

@@ -0,0 +1,18 @@
+from langchain_tavily import TavilySearch
+from langchain_core.tools import tool
+
+
+@tool
+def web_search(keywords: str) -> str:
+    """Search the web using Tavily. This tool performs a concise, focused search to answer factual questions or gather brief information snippets.
+    For deeper research or browsing specific URLs, additional tools may be required.
+    """
+    try:
+        tavily = TavilySearch(max_results=5)
+        results = tavily.invoke(keywords)
+        formatted_results = []
+        for r in results:
+            formatted_results.append(f"Title: {r['title']}\nURL: {r['url']}\nContent: {r['content'][:300]}")
+        return "\n".join(formatted_results) or "NO_RESULTS"
+    except Exception as e:
+        return f"SEARCH_ERROR: {e}"

tools/web/wiki.py

@@ -0,0 +1,12 @@
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_core.tools import tool
+
+
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia."""
+    try:
+        docs = WikipediaLoader(query=query, load_max_docs=2).load()
+        return "\n".join([f"{d.metadata.get('title', 'Unknown')}: {d.page_content[:500]}" for d in docs]) or "NO_RESULTS"
+    except Exception as e:
+        return f"WIKI_ERROR: {e}"

tools/youtube.py

@@ -0,0 +1,21 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from langchain_core.tools import tool
+
+
+@tool
+def get_youtube_transcript(url: str) -> str:
+    """Get YouTube transcript."""
+    try:
+        with tempfile.TemporaryDirectory() as tmp:
+            cmd = ["yt-dlp", "--skip-download", "--write-auto-subs", "--sub-lang", "en", "-o", f"{tmp}/video", url]
+            subprocess.run(cmd, capture_output=True, timeout=60)
+            vtt_files = list(Path(tmp).glob("*.vtt"))
+            if vtt_files:
+                content = vtt_files[0].read_text(encoding="utf-8", errors="replace")
+                lines = [l for l in content.splitlines() if l and not l.startswith(('<', '-->', 'WEBVTT')) and not l.isdigit()]
+                return "\n".join(lines)[:15000] or "NO_TRANSCRIPT"
+            return "NO_SUBTITLES"
+    except Exception as e:
+        return f"TRANSCRIPT_ERROR: {e}"

trace_q19.py

@@ -1,32 +0,0 @@
-import os
-import requests
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-from dotenv import load_dotenv
-
-load_dotenv(override=True)
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-graph = build_graph()
-resp = requests.get(f"{DEFAULT_API_URL}/questions")
-questions = resp.json()
-
-token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-path = hf_hub_download(repo_id='gaia-benchmark/GAIA', filename='2023/validation/metadata.parquet', repo_type='dataset', token=token)
-df = pq.read_table(path).to_pandas()
-answer_map = dict(zip(df['task_id'], df['Final answer']))
-
-# Q19 with trace
-q = questions[18]
-question = q['question']
-
-result = graph.invoke({"messages": [HumanMessage(content=question)]})
-
-# Print messages
-for i, msg in enumerate(result['messages']):
-    if hasattr(msg, 'content'):
-        content = msg.content[:400] if len(msg.content) > 400 else msg.content
-        print(f"\nMsg {i}: {content}")