agent enhancement

.env

@@ -0,0 +1,50 @@
+# Environment variables for GAIA Multi-Agent Framework
+
+# API Keys
+GEMINI_API_KEY="AIzaSyDOQRtAJd-Kj-H6VT_0t38cZTz4Halgi3U" # For Google AI Studio
+GOOGLE_API_KEY="AIzaSyACcl4uzlyqz4glW-_uCj0xGPSSH0uloAY" # For Google Custom Search JSON API
+GOOGLE_CSE_ID="004c6b8673f0c4dd5" # For Google Custom Search Engine ID
+TAVILY_API_KEY="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" # For Tavily Search API
+ALPAFLOW_OPENAI_API_KEY="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" # For o4-mini model (or other OpenAI compatible endpoint)
+WOLFRAM_ALPHA_APP_ID="YOUR_WOLFRAM_ALPHA_APP_ID" # For WolframAlpha API
+
+# GAIA Benchmark API
+GAIA_API_URL="https://agents-course-unit4-scoring.hf.space"
+
+# Model Names (using defaults from original code, can be overridden)
+ROLE_EMBED_MODEL="Snowflake/snowflake-arctic-embed-l-v2.0"
+ROLE_RERANKER_MODEL="Alibaba-NLP/gte-multilingual-reranker-base"
+ROLE_PROMPT_DATASET="fka/awesome-chatgpt-prompts"
+ROLE_LLM_MODEL="models/gemini-1.5-pro"
+
+IMAGE_ANALYZER_LLM_MODEL="models/gemini-1.5-pro"
+
+VERIFIER_LLM_MODEL="models/gemini-2.0-flash"
+VERIFIER_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+VERIFIER_CONFIDENCE_THRESHOLD="0.7"
+
+RESEARCH_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+# RESEARCH_AGENT_CHROME_NO_SANDBOX="true" # Example config for research agent browser
+# RESEARCH_AGENT_CHROME_DISABLE_DEV_SHM="true"
+
+TEXT_ANALYZER_LLM_MODEL="models/gemini-1.5-pro"
+TEXT_ANALYZER_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+
+REASONING_TOOL_LLM_MODEL="o4-mini"
+REASONING_TOOL_API_KEY_ENV="ALPAFLOW_OPENAI_API_KEY" # Env var name containing the key for reasoning tool LLM
+REASONING_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+
+PLANNER_TOOL_LLM_MODEL="models/gemini-1.5-pro"
+PLANNER_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+
+CODE_GEN_LLM_MODEL="o4-mini"
+CODE_GEN_API_KEY_ENV="ALPAFLOW_OPENAI_API_KEY" # Env var name containing the key for code gen LLM
+CODE_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+
+MATH_AGENT_LLM_MODEL="models/gemini-1.5-pro"
+
+# New Feature Config (Placeholders)
+YOUTUBE_CHUNK_DURATION_SECONDS="60"
+TRANSCRIPTION_WHISPER_CPP_PATH="/path/to/whisper.cpp/main" # Example path
+TRANSCRIPTION_WHISPER_MODEL_PATH="/path/to/whisper/model.bin" # Example path
+

.gitattributes

@@ -33,4 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-stockfish filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,139 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-pytest_cache/
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-Pipfile.lock
-
-# poetry
-poetry.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# virtualenv / venv
-venv/
-ENV/
-env/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# profiling data
-.prof
-
-# IDEs and editors
-## VS Code
-.vscode/
-
-## PyCharm
-.idea/
-
-## Sublime Text
-*.sublime-project
-*.sublime-workspace
-
-## Emacs
-*~
-\.#*
-
-## Vim
-*.swp
-*.swo
-Session.vim
-
-# Environment variables file
-.env
-.venv
-
-# Logs
-*.log

README.md

@@ -7,7 +7,6 @@ sdk: gradio
 sdk_version: 5.28.0
 app_file: app.py
 pinned: false
-hf_oauth: true
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents/advanced_validation_agent.py

@@ -2,12 +2,16 @@ import os
 import logging
 import json
 from typing import List, Dict, Optional, Union
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool
 from llama_index.llms.google_genai import GoogleGenAI
 # Assuming research_agent might be needed for handoff, but not directly imported
 
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
@@ -45,7 +49,7 @@ def cross_reference_check(claim: str, sources_content: List[Dict[str, str]]) ->
         return {"error": "No source content provided for cross-referencing."}
 
     # LLM configuration
-    llm_model = os.getenv("VALIDATION_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Use a capable model
+    llm_model = os.getenv("VALIDATION_LLM_MODEL", "models/gemini-1.5-pro") # Use a capable model
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for cross-referencing LLM.")
@@ -53,7 +57,7 @@ def cross_reference_check(claim: str, sources_content: List[Dict[str, str]]) ->
 
     results = []
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model)
         logger.info(f"Using cross-referencing LLM: {llm_model}")
 
         for i, source in enumerate(sources_content):
@@ -114,7 +118,7 @@ def logical_consistency_check(text: str) -> Dict[str, Union[bool, str, List[str]
     logger.info(f"Checking logical consistency for text (length: {len(text)} chars).")
     
     # LLM configuration
-    llm_model = os.getenv("VALIDATION_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    llm_model = os.getenv("VALIDATION_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for consistency check LLM.")
@@ -138,7 +142,7 @@ def logical_consistency_check(text: str) -> Dict[str, Union[bool, str, List[str]
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model, response_mime_type="application/json")
         logger.info(f"Using consistency check LLM: {llm_model}")
         response = llm.complete(prompt)
         
@@ -174,7 +178,7 @@ def bias_detection(text: str, source_context: Optional[str] = None) -> Dict[str,
     logger.info(f"Detecting bias in text (length: {len(text)} chars). Context provided: {source_context is not None}")
     
     # LLM configuration
-    llm_model = os.getenv("VALIDATION_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    llm_model = os.getenv("VALIDATION_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for bias detection LLM.")
@@ -203,7 +207,7 @@ def bias_detection(text: str, source_context: Optional[str] = None) -> Dict[str,
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model, response_mime_type="application/json")
         logger.info(f"Using bias detection LLM: {llm_model}")
         response = llm.complete(prompt)
         
@@ -300,7 +304,7 @@ def initialize_advanced_validation_agent() -> ReActAgent:
     logger.info("Initializing AdvancedValidationAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("VALIDATION_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Use Pro for main agent logic
+    agent_llm_model = os.getenv("VALIDATION_AGENT_LLM_MODEL", "models/gemini-1.5-pro") # Use Pro for main agent logic
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -308,7 +312,7 @@ def initialize_advanced_validation_agent() -> ReActAgent:
         raise ValueError("GEMINI_API_KEY must be set for AdvancedValidationAgent")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -343,6 +347,7 @@ def initialize_advanced_validation_agent() -> ReActAgent:
             llm=llm,
             system_prompt=system_prompt,
             can_handoff_to=valid_handoffs,
+            verbose=True # Enable verbose logging
         )
         logger.info("AdvancedValidationAgent initialized successfully.")
         return agent

agents/code_agent.py

@@ -1,5 +1,6 @@
 import os
 import logging
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import CodeActAgent, ReActAgent
 from llama_index.core.tools import FunctionTool
@@ -7,6 +8,9 @@ from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.llms.openai import OpenAI
 from llama_index.tools.code_interpreter import CodeInterpreterToolSpec
 
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
@@ -43,10 +47,12 @@ def generate_python_code(prompt: str) -> str:
     
     # Configuration for code generation LLM
     gen_llm_model = os.getenv("CODE_GEN_LLM_MODEL", "o4-mini")
-    gen_api_key = os.getenv("OPENAI_API_KEY")
+    gen_api_key_env = os.getenv("CODE_GEN_API_KEY_ENV", "ALPAFLOW_OPENAI_API_KEY")
+    gen_api_key = os.getenv(gen_api_key_env)
 
     if not gen_api_key:
-        raise ValueError("OPENAI_API_KEY environment variable is not set.")
+        logger.error(f"{gen_api_key_env} not found in environment variables for code generation LLM.")
+        raise ValueError(f"{gen_api_key_env} must be set for code generation")
 
     # Load the prompt template
     default_gen_prompt_template = ("You are a helpful assistant that writes Python code. "
@@ -62,10 +68,7 @@ def generate_python_code(prompt: str) -> str:
     try:
         llm = OpenAI(
             model=gen_llm_model,
-            api_key=gen_api_key,
-            reasoning_effort="high",
-            temperature=0.1,
-            max_tokens=16384
+            api_key=gen_api_key
         )
         logger.info(f"Using code generation LLM: {gen_llm_model}")
         generated_code = llm.complete(input_prompt)
@@ -116,7 +119,7 @@ def initialize_code_agent() -> ReActAgent:
     logger.info("Initializing CodeAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("CODE_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    agent_llm_model = os.getenv("CODE_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -127,96 +130,29 @@ def initialize_code_agent() -> ReActAgent:
         llm = GoogleGenAI(
             api_key=gemini_api_key,
             model=agent_llm_model,
-            temperature=0.10
         )
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt (consider loading from file)
         default_system_prompt = """\
-            You are CodeAgent, a specialist in generating and executing Python code. Your mission:
-            
-            1. **Thought**: Think step-by-step before acting and state your reasoning.
-            2. **Code Generation**: To produce code, call `python_code_generator` with a concise, unambiguous prompt. Review the generated code for correctness and safety.
-            3. **Execution & Testing**: To execute or test code, call `code_interpreter`. Provide the complete code snippet. Analyze its output (stdout, stderr, result) to verify functionality and debug errors.
-            4. **Iteration**: If execution fails or the result is incorrect, analyze the error, think about the fix, generate corrected code using `python_code_generator`, and execute again using `code_interpreter`.
-            5. **Tool Use**: Always adhere strictly to each tool’s input/output format.
-            6. **Final Output**: Once the code works correctly and achieves the goal, output *only* the final functional code or the final execution result, as appropriate for the task.
-            7. **Hand-Off**: If further logical reasoning or verification is needed, delegate to **reasoning_agent**. Otherwise, pass your final output to **planner_agent** for synthesis.
-            
-            **Special Instructions for Chess-Related Tasks**:
-            - Prioritize using the Stockfish engine to solve chess problems. Ubuntu installation: `sudo apt-get install stockfish` so path is `/usr/games/stockfish`
-            - Use `python-chess` to represent boards, generate and validate moves, and parse PGN/FEN.
-            
-            **Available Python Packages**:
-            
-            - beautifulsoup4: HTML/XML parsing and lightweight web scraping  
-            - certifi: Mozilla CA bundle for secure TLS/SSL requests  
-            - datasets: Hugging Face dataset loading and streaming  
-            - duckdb: In‑process OLAP SQL engine (analytics, Parquet, Arrow)  
-            - ffmpeg-python: Wrapper around FFmpeg for audio/video operations  
-            - gradio[oauth]: Rapid web‑UI prototyping with optional OAuth  
-            - helium: High‑level Selenium / browser automation toolkit  
-            - huggingface: Interact with Hugging Face Hub models, datasets, spaces  
-            - imageio: Read and write images, GIFs, MP4s, volumes, etc.  
-            - matplotlib: 2‑D plotting (figures, axes, annotations)  
-            - numpy: N‑dimensional arrays and vectorized math  
-            - openai-whisper: Speech‑to‑text transcription  
-            - opencv-python: Computer vision, image/video processing  
-            - openpyxl: Excel .xlsx read/write, styles, formulas  
-            - pandas: DataFrames, time series, CSV/Parquet I/O  
-            - pyarrow: Apache Arrow tables, Parquet, Flight RPC  
-            - pygame: Simple 2‑D game/graphics engine (SDL based)  
-            - python-chess: Chess move generation, PGN/FEN handling, engine UCI integration  
-            - requests: HTTP/HTTPS client with sessions and retries  
-            - scikit-learn: Machine‑learning algorithms, preprocessing, pipelines  
-            - scipy: Scientific computing, optimization, signal processing  
-            - seaborn: Statistical visualization on top of matplotlib  
-            - sqlalchemy: SQL ORM and core engine for many databases  
-            - statsmodels: Econometrics and statistical modeling (GLM, ARIMA)  
-            - stockfish: UCI interface to Stockfish chess engine  
-            - sympy: Symbolic math, algebra, calculus CAS  
-            - youtube-transcript-api: Fetch YouTube video transcripts via API  
-            - yt-dlp: Download videos/playlists from YouTube and other sites  
-            """
-
-        system_prompt = load_prompt_from_file("code_agent_system_prompt.txt", default_system_prompt)
+        You are CodeAgent, a specialist in generating and executing Python code. Your mission:
+        
+        1. **Thought**: Think step-by-step before acting and state your reasoning.
+        2. **Code Generation**: To produce code, call `python_code_generator` with a concise, unambiguous prompt. Review the generated code for correctness and safety.
+        3. **Execution & Testing**: To execute or test code, call `code_interpreter`. Provide the complete code snippet. Analyze its output (stdout, stderr, result) to verify functionality and debug errors.
+        4. **Iteration**: If execution fails or the result is incorrect, analyze the error, think about the fix, generate corrected code using `python_code_generator`, and execute again using `code_interpreter`.
+        5. **Tool Use**: Always adhere strictly to each tool’s input/output format.
+        6. **Final Output**: Once the code works correctly and achieves the goal, output *only* the final functional code or the final execution result, as appropriate for the task.
+        7. **Hand-Off**: If further logical reasoning or verification is needed, delegate to **reasoning_agent**. Otherwise, pass your final output to **planner_agent** for synthesis.
+        """
+        # system_prompt = load_prompt_from_file("code_agent_system_prompt.txt", default_system_prompt)
+        system_prompt = default_system_prompt # Using inline for now
 
         agent = ReActAgent(
             name="code_agent",
             description=(
-                "Generates Python code using `python_code_generator` and executes it safely with "
-                "`code_interpreter`, then iteratively debugs and refines the code from run-time feedback.\n\n"
-                "The agent can leverage the following pre-installed packages:\n"
-                "- beautifulsoup4>=4.13.4 : HTML/XML parsing and lightweight web scraping\n"
-                "- certifi>=2025.4.26     : Mozilla CA bundle for secure TLS/SSL requests\n"
-                "- datasets>=3.5.1        : Hugging Face dataset loading and streaming\n"
-                "- duckdb>=1.2.2          : In‑process OLAP SQL engine (analytics, Parquet, Arrow)\n"
-                "- ffmpeg-python>=0.2.0   : Wrapper around FFmpeg for audio/video operations\n"
-                "- gradio[oauth]>=5.28.0  : Rapid web‑UI prototyping with optional OAuth\n"
-                "- helium>=5.1.1          : High‑level Selenium / browser automation toolkit\n"
-                "- huggingface>=0.0.1     : Interact with Hugging Face Hub models, datasets, spaces\n"
-                "- imageio>=2.37.0        : Read and write images, GIFs, MP4s, volumes, etc.\n"
-                "- matplotlib>=3.10.1     : 2‑D plotting (figures, axes, annotations)\n"
-                "- numpy>=2.2.5           : N‑dimensional arrays and vectorized math\n"
-                "- openai-whisper>=20240930 : Speech‑to‑text transcription\n"
-                "- opencv-python>=4.11.0.86 : Computer vision, image/video processing\n"
-                "- openpyxl>=3.1.5        : Excel .xlsx read/write, styles, formulas\n"
-                "- pandas>=2.2.3          : DataFrames, time series, CSV/Parquet I/O\n"
-                "- pyarrow>=20.0.0        : Apache Arrow tables, Parquet, Flight RPC\n"
-                "- pygame>=2.6.1          : Simple 2‑D game/graphics engine (SDL based)\n"
-                "- python-chess>=1.999    : Chess move generation, PGN/FEN handling, engines\n"
-                "- requests>=2.32.3       : HTTP/HTTPS client with sessions and retries\n"
-                "- scikit-learn>=1.6.1    : Machine‑learning algorithms, preprocessing, pipelines\n"
-                "- scipy>=1.15.2          : Scientific computing, optimization, signal processing\n"
-                "- seaborn>=0.13.2        : Statistical visualization on top of matplotlib\n"
-                "- sqlalchemy>=2.0.40     : SQL ORM and core engine for many databases\n"
-                "- statsmodels>=0.14.4    : Econometrics and statistical modeling (GLM, ARIMA)\n"
-                "- stockfish==3.28.0      : UCI interface to Stockfish chess engine\n"
-                "- sympy>=1.14.0          : Symbolic math, algebra, calculus CAS\n"
-                "- youtube-transcript-api>=1.0.3 : Fetch YouTube video transcripts via API\n"
-                "- yt-dlp>=2025.3.31      : Download videos/playlists from YouTube and other sites\n\n"
-                "Additionally, the `stockfish` package enables the agent to solve chess problems by analyzing positions, "
-                "identifying tactical motifs, and calculating optimal move sequences, making it a valuable tool for chess training and analysis."
+                "Generates Python code using `python_code_generator` and executes it safely using `code_interpreter`. "
+                "Iteratively debugs and refines code based on execution results."
             ),
             # REMOVED: code_execute_fn - Execution is handled by the code_interpreter tool via the agent loop.
             tools=[

agents/figure_interpretation_agent.py

@@ -0,0 +1,303 @@
+import os
+import logging
+from typing import List, Dict, Optional, Union
+from dotenv import load_dotenv
+
+from llama_index.core.agent.workflow import ReActAgent
+from llama_index.core.schema import ImageDocument
+from llama_index.core.tools import FunctionTool
+from llama_index.llms.google_genai import GoogleGenAI
+
+# Load environment variables
+load_dotenv()
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+# Helper function to load prompt from file
+def load_prompt_from_file(filename: str, default_prompt: str) -> str:
+    """Loads a prompt from a text file."""
+    try:
+        script_dir = os.path.dirname(__file__)
+        prompt_path = os.path.join(script_dir, filename)
+        with open(prompt_path, "r") as f:
+            prompt = f.read()
+            logger.info(f"Successfully loaded prompt from {prompt_path}")
+            return prompt
+    except FileNotFoundError:
+        logger.warning(f"Prompt file {filename} not found at {prompt_path}. Using default.")
+        return default_prompt
+    except Exception as e:
+        logger.error(f"Error loading prompt file {filename}: {e}", exc_info=True)
+        return default_prompt
+
+# --- Core Figure Interpretation Logic (using Multi-Modal LLM) ---
+
+def interpret_figure_with_llm(image_path: str, request: str) -> str:
+    """Interprets a figure in an image based on a specific request using a multi-modal LLM.
+       Args:
+           image_path (str): Path to the image file containing the figure.
+           request (str): The specific question or interpretation task (e.g., "Describe this chart", 
+                          "Extract sales for Q3", "Identify the main trend").
+       Returns:
+           str: The interpretation result or an error message.
+    """
+    logger.info(f"Interpreting figure in image: {image_path} with request: {request}")
+
+    # Check if image exists
+    if not os.path.exists(image_path):
+        logger.error(f"Image file not found: {image_path}")
+        return f"Error: Image file not found at {image_path}"
+
+    # LLM configuration (Must be a multi-modal model)
+    # Ensure the selected model supports image input (e.g., gemini-1.5-pro)
+    llm_model_name = os.getenv("FIGURE_INTERPRETATION_LLM_MODEL", "models/gemini-1.5-pro") 
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key:
+        logger.error("GEMINI_API_KEY not found for figure interpretation LLM.")
+        return "Error: GEMINI_API_KEY not set."
+
+    try:
+        # Initialize the multi-modal LLM
+        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model_name)
+        logger.info(f"Using figure interpretation LLM: {llm_model_name}")
+
+        # Prepare the prompt for the multi-modal LLM
+        # The prompt needs to guide the LLM to act as the figure interpreter
+        # based on the specific request.
+        prompt = (
+            f"You are an expert figure interpreter. Analyze the provided image containing a chart, graph, diagram, or table. "
+            f"Focus *only* on the visual information present in the image. "
+            f"Fulfill the following request accurately and concisely:\n\n"
+            f"REQUEST: {request}\n\n"
+            f"Based *only* on the image, provide the answer:"
+        )
+
+        # Load the image data (LlamaIndex integration might handle this differently depending on version)
+        # Assuming a method to load image data compatible with the LLM call
+        # This might involve using ImageBlock or similar structures in newer LlamaIndex versions.
+        # For simplicity here, we assume the LLM call can handle a path or loaded image object.
+        
+        # Example using complete (adjust based on actual LlamaIndex multi-modal API)
+        # Note: The exact API for multi-modal completion might vary. 
+        # This is a conceptual example.
+        from llama_index.core import SimpleDirectoryReader # Example import
+        
+        # Load the image document
+        reader = SimpleDirectoryReader(input_files=[image_path])
+        image_documents = reader.load_data()
+        
+        if not image_documents or not isinstance(image_documents[0], ImageDocument):
+             logger.error(f"Failed to load image as ImageDocument: {image_path}")
+             return f"Error: Could not load image file {image_path} for analysis."
+
+        # Make the multi-modal completion call
+        response = llm.complete(
+            prompt=prompt,
+            image_documents=image_documents # Pass the loaded image document(s)
+        )
+        
+        interpretation = response.text.strip()
+        logger.info("Figure interpretation successful.")
+        return interpretation
+
+    except FileNotFoundError:
+         # This might be redundant due to the initial check, but good practice
+         logger.error(f"Image file not found during LLM call: {image_path}")
+         return f"Error: Image file not found at {image_path}"
+    except ImportError as ie:
+         logger.error(f"Missing library for multi-modal processing: {ie}")
+         return f"Error: Missing required library for image processing ({ie})."
+    except Exception as e:
+        # Catch potential API errors or other issues
+        logger.error(f"LLM call failed during figure interpretation: {e}", exc_info=True)
+        # Check if the error suggests the model doesn't support images
+        if "does not support image input" in str(e).lower():
+             logger.error(f"The configured model {llm_model_name} does not support image input.")
+             return f"Error: The configured LLM ({llm_model_name}) does not support image input. Please configure a multi-modal model."
+        return f"Error during figure interpretation: {e}"
+
+# --- Tool Definitions (Wrapping the core logic) ---
+# These tools essentially pass the request to the core LLM function.
+
+def describe_figure_tool_fn(image_path: str) -> str:
+    "Provides a general description of the figure in the image (type, elements, topic)."
+    return interpret_figure_with_llm(image_path, "Describe this figure, including its type, main elements (axes, labels, legend), and overall topic.")
+
+def extract_data_points_tool_fn(image_path: str, data_request: str) -> str:
+    "Extracts specific data points or values from the figure in the image."
+    return interpret_figure_with_llm(image_path, f"Extract the following data points/values from the figure: {data_request}. If exact values are not clear, provide the closest estimate based on the visual.")
+
+def identify_trends_tool_fn(image_path: str) -> str:
+    "Identifies and describes trends or patterns shown in the figure in the image."
+    return interpret_figure_with_llm(image_path, "Analyze and describe the main trends or patterns shown in this figure.")
+
+def compare_elements_tool_fn(image_path: str, comparison_request: str) -> str:
+    "Compares different elements within the figure in the image."
+    return interpret_figure_with_llm(image_path, f"Compare the following elements within the figure: {comparison_request}. Be specific about the comparison based on the visual data.")
+
+def summarize_figure_insights_tool_fn(image_path: str) -> str:
+    "Summarizes the key insights or main message conveyed by the figure in the image."
+    return interpret_figure_with_llm(image_path, "Summarize the key insights or the main message conveyed by this figure.")
+
+# --- Tool Definitions for Agent ---
+describe_figure_tool = FunctionTool.from_defaults(
+    fn=describe_figure_tool_fn,
+    name="describe_figure",
+    description="Provides a general description of the figure in the image (type, elements, topic). Input: image_path (str)."
+)
+
+extract_data_points_tool = FunctionTool.from_defaults(
+    fn=extract_data_points_tool_fn,
+    name="extract_data_points",
+    description="Extracts specific data points/values from the figure. Input: image_path (str), data_request (str)."
+)
+
+identify_trends_tool = FunctionTool.from_defaults(
+    fn=identify_trends_tool_fn,
+    name="identify_trends",
+    description="Identifies and describes trends/patterns in the figure. Input: image_path (str)."
+)
+
+compare_elements_tool = FunctionTool.from_defaults(
+    fn=compare_elements_tool_fn,
+    name="compare_elements",
+    description="Compares different elements within the figure. Input: image_path (str), comparison_request (str)."
+)
+
+summarize_figure_insights_tool = FunctionTool.from_defaults(
+    fn=summarize_figure_insights_tool_fn,
+    name="summarize_figure_insights",
+    description="Summarizes the key insights/main message of the figure. Input: image_path (str)."
+)
+
+# --- Agent Initialization ---
+def initialize_figure_interpretation_agent() -> ReActAgent:
+    """Initializes the Figure Interpretation Agent."""
+    logger.info("Initializing FigureInterpretationAgent...")
+
+    # Configuration for the agent's main LLM (can be the same multi-modal one)
+    agent_llm_model = os.getenv("FIGURE_INTERPRETATION_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+
+    if not gemini_api_key:
+        logger.error("GEMINI_API_KEY not found for FigureInterpretationAgent.")
+        raise ValueError("GEMINI_API_KEY must be set for FigureInterpretationAgent")
+
+    try:
+        # Agent's LLM doesn't necessarily need to be multi-modal itself,
+        # if the tools handle the multi-modal calls.
+        # However, using a multi-modal one might allow more direct interaction patterns later.
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
+        logger.info(f"Using agent LLM: {agent_llm_model}")
+
+        # Load system prompt
+        default_system_prompt = ("You are FigureInterpretationAgent... [Default prompt content - replace with actual]" # Placeholder
+                              )
+        system_prompt = load_prompt_from_file("../prompts/figure_interpretation_agent_prompt.txt", default_system_prompt)
+        if system_prompt == default_system_prompt:
+             logger.warning("Using default/fallback system prompt for FigureInterpretationAgent.")
+
+        # Define available tools
+        tools = [
+            describe_figure_tool,
+            extract_data_points_tool,
+            identify_trends_tool,
+            compare_elements_tool,
+            summarize_figure_insights_tool
+        ]
+
+        # Define valid handoff targets
+        valid_handoffs = [
+            "planner_agent", # To return results
+            "research_agent", # If context from figure needs further research
+            "reasoning_agent" # If interpretation needs logical analysis
+        ]
+
+        agent = ReActAgent(
+            name="figure_interpretation_agent",
+            description=(
+                "Analyzes and interprets visual data representations (charts, graphs, tables) from image files. "
+                "Can describe figures, extract data, identify trends, compare elements, and summarize insights."
+            ),
+            tools=tools,
+            llm=llm,
+            system_prompt=system_prompt,
+            can_handoff_to=valid_handoffs,
+            # Note: This agent inherently requires multi-modal input capabilities, 
+            # which are handled within its tools via a multi-modal LLM.
+        )
+        logger.info("FigureInterpretationAgent initialized successfully.")
+        return agent
+
+    except Exception as e:
+        logger.error(f"Error during FigureInterpretationAgent initialization: {e}", exc_info=True)
+        raise
+
+# Example usage (for testing if run directly)
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger.info("Running figure_interpretation_agent.py directly for testing...")
+
+    # Check required keys
+    required_keys = ["GEMINI_API_KEY"]
+    missing_keys = [key for key in required_keys if not os.getenv(key)]
+    if missing_keys:
+        print(f"Error: Required environment variable(s) not set: {', '.join(missing_keys)}. Cannot run test.")
+    else:
+        # Check if a multi-modal model is likely configured (heuristic)
+        model_name = os.getenv("FIGURE_INTERPRETATION_LLM_MODEL", "models/gemini-1.5-pro")
+        if "pro" not in model_name.lower() and "vision" not in model_name.lower():
+             print(f"Warning: Configured LLM {model_name} might not support image input. Tests may fail.")
+             
+        # Create a dummy image file for testing (requires Pillow)
+        dummy_image_path = "dummy_figure.png"
+        try:
+            from PIL import Image, ImageDraw, ImageFont
+            img = Image.new('RGB', (400, 200), color = (255, 255, 255))
+            d = ImageDraw.Draw(img)
+            # Try to load a default font, handle if not found
+            try:
+                 font = ImageFont.truetype("arial.ttf", 15) # Common font, might not exist
+            except IOError:
+                 font = ImageFont.load_default()
+                 print("Arial font not found, using default PIL font.")
+            d.text((10,10), "Simple Bar Chart", fill=(0,0,0), font=font)
+            d.rectangle([50, 50, 100, 150], fill=(255,0,0)) # Bar 1
+            d.text((60, 160), "A", fill=(0,0,0), font=font)
+            d.rectangle([150, 80, 200, 150], fill=(0,0,255)) # Bar 2
+            d.text((160, 160), "B", fill=(0,0,0), font=font)
+            img.save(dummy_image_path)
+            print(f"Created dummy image file: {dummy_image_path}")
+
+            # Test the tools directly
+            print("\nTesting describe_figure...")
+            desc = describe_figure_tool_fn(dummy_image_path)
+            print(f"Description: {desc}")
+            
+            print("\nTesting extract_data_points (qualitative)...")
+            extract_req = "Height of bar A vs Bar B" # Qualitative request
+            extract_res = extract_data_points_tool_fn(dummy_image_path, extract_req)
+            print(f"Extraction Result: {extract_res}")
+            
+            print("\nTesting compare_elements...")
+            compare_req = "Compare bar A and bar B" 
+            compare_res = compare_elements_tool_fn(dummy_image_path, compare_req)
+            print(f"Comparison Result: {compare_res}")
+
+            # Clean up dummy image
+            os.remove(dummy_image_path)
+
+        except ImportError:
+            print("Pillow library not installed. Skipping direct tool tests that require image creation.")
+            # Optionally, still try initializing the agent
+            try:
+                 test_agent = initialize_figure_interpretation_agent()
+                 print("\nFigure Interpretation Agent initialized successfully (tool tests skipped).")
+            except Exception as e:
+                 print(f"Error initializing agent: {e}")
+        except Exception as e:
+            print(f"Error during testing: {e}")
+            if os.path.exists(dummy_image_path):
+                 os.remove(dummy_image_path) # Ensure cleanup on error
+

agents/image_analyzer_agent.py

@@ -1,9 +1,13 @@
 import os
 import logging
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import FunctionAgent
 from llama_index.llms.google_genai import GoogleGenAI
 
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
@@ -35,7 +39,7 @@ def initialize_image_analyzer_agent() -> FunctionAgent:
     logger.info("Initializing ImageAnalyzerAgent...")
     
     # Configuration from environment variables
-    llm_model_name = os.getenv("IMAGE_ANALYZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    llm_model_name = os.getenv("IMAGE_ANALYZER_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -65,7 +69,7 @@ def initialize_image_analyzer_agent() -> FunctionAgent:
             system_prompt=system_prompt,
             # No explicit tools needed if relying on direct multimodal LLM call
             # tools=[], 
-            can_handoff_to=["planner_agent", "research_agent", "reasoning_agent", "figure_interpretation_agent"],
+            can_handoff_to=["planner_agent", "research_agent", "reasoning_agent"],
         )
         logger.info("ImageAnalyzerAgent initialized successfully.")
         return agent

agents/long_context_management_agent.py

@@ -2,6 +2,7 @@ import os
 import logging
 import json
 from typing import List, Dict, Optional, Union, Literal
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool, QueryEngineTool
@@ -11,6 +12,8 @@ from llama_index.core.node_parser import SentenceSplitter
 from llama_index.core.query_engine import RetrieverQueryEngine
 from llama_index.core.retrievers import VectorIndexRetriever
 
+# Load environment variables
+load_dotenv()
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -115,7 +118,7 @@ def summarize_long_context(detail_level: Literal["brief", "standard", "detailed"
     min_length = min_length or int(max_length * 0.3) # Default min length
 
     # LLM configuration
-    llm_model = os.getenv("CONTEXT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Use Pro for potentially long context
+    llm_model = os.getenv("CONTEXT_LLM_MODEL", "models/gemini-1.5-pro") # Use Pro for potentially long context
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for summarization LLM.")
@@ -135,7 +138,7 @@ def summarize_long_context(detail_level: Literal["brief", "standard", "detailed"
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model)
         logger.info(f"Using summarization LLM: {llm_model}")
         response = llm.complete(prompt)
         summary = response.text.strip()
@@ -307,7 +310,7 @@ def initialize_long_context_management_agent() -> ReActAgent:
     logger.info("Initializing LongContextManagementAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("CONTEXT_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Needs to handle planning
+    agent_llm_model = os.getenv("CONTEXT_AGENT_LLM_MODEL", "models/gemini-1.5-pro") # Needs to handle planning
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -315,7 +318,7 @@ def initialize_long_context_management_agent() -> ReActAgent:
         raise ValueError("GEMINI_API_KEY must be set for LongContextManagementAgent")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
         logger.info(f"Using agent LLM: {agent_llm_model}")
         Settings.llm = llm # Set default LLM for LlamaIndex components used by tools
 
@@ -339,18 +342,14 @@ def initialize_long_context_management_agent() -> ReActAgent:
         valid_handoffs = [
             "planner_agent", # To return results
             "text_analyzer_agent", # If further analysis of extracted/filtered text is needed
-            "reasoning_agent",
-            "research_agent"
+            "reasoning_agent" 
         ]
 
         agent = ReActAgent(
             name="long_context_management_agent",
             description=(
-                "Manages and processes long textual context efficiently. Handles large documents, transcripts, or datasets "
-                "by summarizing (`summarize_long_context`), extracting key information (`extract_key_information`), "
-                "filtering relevant content (`filter_by_relevance`), and answering questions based on the context (`query_context_index`). "
-                "Supports internal indexing for efficient retrieval and repeated queries. Optimized for chunked input processing "
-                "and contextual distillation. Only relies on the provided input and avoids external augmentation unless explicitly requested."
+                "Manages and processes long textual context. Can load text (`load_text_context`), summarize (`summarize_long_context`), "
+                "extract key info (`extract_key_information`), filter by relevance (`filter_by_relevance`), and answer questions based on the context (`query_context_index`)."
             ),
             tools=tools,
             llm=llm,

agents/math_agent.py

@@ -1,13 +1,13 @@
 import os
 import logging
-from typing import List, Dict
+from typing import List, Optional, Union, Dict
+from dotenv import load_dotenv
 
 import sympy as sp
 import numpy as np
 import scipy.linalg as la
 import scipy.special as special
-from llama_index.tools.code_interpreter import CodeInterpreterToolSpec
-from scipy.integrate import quad
+from scipy.integrate import odeint, quad
 from scipy.stats import binom, norm, poisson
 import numpy.fft as fft
 
@@ -16,6 +16,9 @@ from llama_index.core.tools import FunctionTool
 from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
 
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
@@ -600,26 +603,6 @@ def get_wolfram_alpha_tools() -> List[FunctionTool]:
                 _wolfram_alpha_tools = []
     return _wolfram_alpha_tools
 
-
-# Use LlamaIndex's built-in Code Interpreter Tool Spec for safe execution
-# This assumes the necessary environment (e.g., docker) for the spec is available
-try:
-    code_interpreter_spec = CodeInterpreterToolSpec()
-    # Get the tool(s) from the spec. It might return multiple tools.
-    code_interpreter_tools = code_interpreter_spec.to_tool_list()
-    if not code_interpreter_tools:
-        raise RuntimeError("CodeInterpreterToolSpec did not return any tools.")
-    # Assuming the primary tool is the first one, or find by name if necessary
-    code_interpreter_tool = next((t for t in code_interpreter_tools if t.metadata.name == "code_interpreter"), None)
-    if code_interpreter_tool is None:
-         raise RuntimeError("Could not find 'code_interpreter' tool in CodeInterpreterToolSpec results.")
-    logger.info("CodeInterpreterToolSpec initialized successfully.")
-except Exception as e:
-    logger.error(f"Failed to initialize CodeInterpreterToolSpec: {e}", exc_info=True)
-    # Fallback: Define a dummy tool or raise error to prevent agent start?
-    # For now, let initialization fail if the safe interpreter isn't available.
-    raise RuntimeError("CodeInterpreterToolSpec failed to initialize. Cannot create code_agent.") from e
-
 # --- Agent Initialization ---
 
 def initialize_math_agent() -> ReActAgent:
@@ -627,7 +610,7 @@ def initialize_math_agent() -> ReActAgent:
     logger.info("Initializing MathAgent...")
 
     # Configuration
-    agent_llm_model = os.getenv("MATH_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    agent_llm_model = os.getenv("MATH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -638,12 +621,11 @@ def initialize_math_agent() -> ReActAgent:
         llm = GoogleGenAI(
             api_key=gemini_api_key,
             model=agent_llm_model,
-            temperature=0.05
         )
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Combine Python tools and Wolfram Alpha tools
-        all_tools = get_python_math_tools() + get_wolfram_alpha_tools() + [code_interpreter_tool]
+        all_tools = get_python_math_tools() + get_wolfram_alpha_tools()
         if not all_tools:
              logger.warning("No math tools available (Python or WolframAlpha). MathAgent may be ineffective.")
 
@@ -668,8 +650,6 @@ def initialize_math_agent() -> ReActAgent:
         - Clearly state which tool you are using and why.
         - Handle potential errors gracefully and report them if they prevent finding a solution.
         - Pay close attention to input formats required by each tool (e.g., lists for vectors/matrices, strings for symbolic expressions).
-        
-        If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.
         """
 
         agent = ReActAgent(
@@ -681,7 +661,7 @@ def initialize_math_agent() -> ReActAgent:
             tools=all_tools,
             llm=llm,
             system_prompt=system_prompt,
-            can_handoff_to=["planner_agent", "reasoning_agent"],
+            can_handoff_to=["planner_agent"],
         )
         logger.info("MathAgent initialized successfully.")
         return agent

agents/planner_agent.py

@@ -1,11 +1,14 @@
 import os
 import logging
 from typing import List, Dict
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool
 from llama_index.llms.google_genai import GoogleGenAI
 
+# Load environment variables
+load_dotenv()
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -41,11 +44,11 @@ def plan(objective: str) -> List[str]:
     logger.info(f"Generating plan for objective: {objective[:100]}...")
     
     # Configuration for planning LLM
-    planner_llm_model = os.getenv("PLANNER_TOOL_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Specific model for this tool?
+    planner_llm_model = os.getenv("PLANNER_TOOL_LLM_MODEL", "models/gemini-1.5-pro") # Specific model for this tool?
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for planning tool LLM.")
-        return "Error: GEMINI_API_KEY not set for planning."
+        return ["Error: GEMINI_API_KEY not set for planning."]
 
     # Prompt for the LLM to generate sub-steps
     input_prompt = (
@@ -57,7 +60,7 @@ def plan(objective: str) -> List[str]:
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=planner_llm_model)
         logger.info(f"Using planning LLM: {planner_llm_model}")
         response = llm.complete(input_prompt)
         
@@ -81,23 +84,22 @@ def plan(objective: str) -> List[str]:
                 
         if not sub_steps:
              logger.warning("LLM generated no sub-steps for the objective.")
-             return "Error: Failed to generate sub-steps."
+             return ["Error: Failed to generate sub-steps."]
              
         logger.info(f"Generated {len(sub_steps)} sub-steps.")
-
         return sub_steps
         
     except Exception as e:
         logger.error(f"LLM call failed during planning: {e}", exc_info=True)
-        return f"Error during planning: {e}"
+        return [f"Error during planning: {e}"]
 
-def synthesize_and_report(results: List[Dict[str, str]]) -> str:
+def synthesize_and_respond(results: List[Dict[str, str]]) -> str:
     """
     Aggregate results from sub-steps into a coherent final report using an LLM.
     Args:
         results (List[Dict[str, str]]): List of dictionaries, each with "sub_step" and "answer" keys.
     Returns:
-        str: A unified, well-structured report, or an error message.
+        str: A unified, well-structured response, or an error message.
     """
     logger.info(f"Synthesizing results from {len(results)} sub-steps...")
     if not results:
@@ -112,16 +114,14 @@ def synthesize_and_report(results: List[Dict[str, str]]) -> str:
         summary_blocks += f"Sub-step {i+1}: {sub_step}\nAnswer {i+1}: {answer}\n\n"
 
     # Configuration for synthesis LLM
-    synthesizer_llm_model = os.getenv("SYNTHESIZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Specific model?
+    synthesizer_llm_model = os.getenv("SYNTHESIZER_LLM_MODEL", "models/gemini-1.5-pro") # Specific model?
     gemini_api_key = os.getenv("GEMINI_API_KEY")
     if not gemini_api_key:
         logger.error("GEMINI_API_KEY not found for synthesis tool LLM.")
         return "Error: GEMINI_API_KEY not set for synthesis."
 
     # Prompt for the LLM
-    input_prompt = f"""You are an expert synthesizer. Given the following sub-steps and their answers derived 
-    from an initial objective, produce a single, coherent, comprehensive final report that 
-    addresses the original objective:
+    input_prompt = f"""You are an expert synthesizer. Given the following sub-steps and their answers derived from an initial objective, produce a single, coherent, comprehensive final report that addresses the original objective:
 
     --- SUB-STEP RESULTS ---
     {summary_blocks.strip()}
@@ -131,7 +131,7 @@ def synthesize_and_report(results: List[Dict[str, str]]) -> str:
     """
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=synthesizer_llm_model)
         logger.info(f"Using synthesis LLM: {synthesizer_llm_model}")
         response = llm.complete(input_prompt)
         logger.info("Synthesis successful.")
@@ -140,59 +140,10 @@ def synthesize_and_report(results: List[Dict[str, str]]) -> str:
         logger.error(f"LLM call failed during synthesis: {e}", exc_info=True)
         return f"Error during synthesis: {e}"
 
-def answer_question(question: str) -> str:
-    """
-    Answer any question by following this strict format:
-      1. Include your chain of thought (your reasoning steps).
-      2. End your reply with the exact template:
-         FINAL ANSWER: [YOUR FINAL ANSWER]
-    YOUR FINAL ANSWER must be:
-      - A number, or
-      - As few words as possible, or
-      - A comma-separated list of numbers and/or strings.
-    Formatting rules:
-      * If asked for a number, do not use commas or units (e.g., $, %), unless explicitly requested.
-      * If asked for a string, do not include articles or abbreviations (e.g., city names), and write digits in plain text.
-      * If asked for a comma-separated list, apply the above rules to each element.
-    This tool should be invoked immediately after completing the final planning sub-step.
-    """
-    logger.info(f"Answering question: {question[:100]}")
-
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logger.error("GEMINI_API_KEY not set for answer_question tool.")
-        return "Error: GEMINI_API_KEY not set."
-
-    model_name = os.getenv("ANSWER_TOOL_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
-
-    # Build the assistant prompt enforcing the required format
-    assistant_prompt = (
-        "You are a general AI assistant. I will ask you a question. "
-        "Report your thoughts, and finish your answer with the following template: "
-        "FINAL ANSWER: [YOUR FINAL ANSWER]. "
-        "YOUR FINAL ANSWER should be a number OR as few words as possible "
-        "OR a comma separated list of numbers and/or strings. "
-        "If you are asked for a number, don't use commas for thousands or any units like $ or % unless specified. "
-        "If you are asked for a string, omit articles and abbreviations, and write digits in plain text. "
-        "If you are asked for a comma separated list, apply these rules to each element.\n\n"
-        f"Question: {question}\n"
-        "Answer:"
-    )
-
-    try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-        logger.info(f"Using answer LLM: {model_name}")
-        response = llm.complete(assistant_prompt)
-        logger.info("Answer generated successfully.")
-        return response.text
-    except Exception as e:
-        logger.error(f"LLM call failed during answer generation: {e}", exc_info=True)
-        return f"Error during answer generation: {e}"
-
 # --- Tool Definitions ---
 synthesize_tool = FunctionTool.from_defaults(
-    fn=synthesize_and_report,
-    name="synthesize_and_report",
+    fn=synthesize_and_respond,
+    name="synthesize_and_respond",
     description=(
         "Aggregates results from multiple sub-steps into a final coherent report. "
         "Input: results (List[Dict[str, str]]) where each dict has \"sub_step\" and \"answer\". "
@@ -209,22 +160,13 @@ generate_substeps_tool = FunctionTool.from_defaults(
     )
 )
 
-answer_question = FunctionTool.from_defaults(
-    fn=answer_question,
-    name="answer_question",
-    description=(
-        "Answers any question and returns the full text, always ending with "
-        "‘FINAL ANSWER: ...’ in accordance with the formatting rules."
-    ),
-)
-
 # --- Agent Initialization ---
 def initialize_planner_agent() -> ReActAgent:
     """Initializes the Planner Agent."""
     logger.info("Initializing PlannerAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("PLANNER_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    agent_llm_model = os.getenv("PLANNER_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -232,7 +174,7 @@ def initialize_planner_agent() -> ReActAgent:
         raise ValueError("GEMINI_API_KEY must be set for PlannerAgent")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -253,10 +195,8 @@ def initialize_planner_agent() -> ReActAgent:
             "role_agent",
             "image_analyzer_agent",
             "text_analyzer_agent",
-            "reasoning_agent",
-            "long_context_management_agent",
-            "advanced_validation_agent",
-            "video_analyzer_agent"
+            "verifier_agent",
+            "reasoning_agent"
         ]
 
         agent = ReActAgent(
@@ -264,7 +204,7 @@ def initialize_planner_agent() -> ReActAgent:
             description=(
                 "Strategically plans tasks by breaking down objectives into sub-steps using `generate_substeps`. "
                 "Orchestrates execution by handing off sub-steps to specialized agents. "
-                "Synthesizes final results using `synthesize_and_report`."
+                "Synthesizes final results using `synthesize_and_respond`."
             ),
             tools=tools,
             llm=llm,
@@ -301,7 +241,7 @@ if __name__ == "__main__":
                 {"sub_step": "Find recent sales data.", "answer": "EV sales grew 25% year-over-year in Q1 2024."}, 
                 {"sub_step": "Analyze government incentives.", "answer": "Germany reduced subsidies, France maintained them."}
             ]
-            report = synthesize_and_report(test_results)
+            report = synthesize_and_respond(test_results)
             print(f"Synthesized Report:\n{report}")
 
             # Initialize the agent (optional)

agents/reasoning_agent.py

@@ -1,11 +1,15 @@
 import os
 import logging
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool
 from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.llms.openai import OpenAI
 
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
@@ -41,7 +45,7 @@ def reasoning_tool_fn(context: str) -> str:
     
     # Configuration for the reasoning LLM (OpenAI in the original)
     reasoning_llm_model = os.getenv("REASONING_LLM_MODEL", "gpt-4o-mini") # Use gpt-4o-mini as default
-    openai_api_key = os.getenv("OPENAI_API_KEY")
+    openai_api_key = os.getenv("ALPAFLOW_OPENAI_API_KEY") # Specific key from original code
     
     if not openai_api_key:
         logger.error("ALPAFLOW_OPENAI_API_KEY not found for reasoning tool LLM.")
@@ -71,9 +75,7 @@ def reasoning_tool_fn(context: str) -> str:
         llm = OpenAI(
             model=reasoning_llm_model,
             api_key=openai_api_key,
-            reasoning_effort="high",
-            temperature=0.055,
-            max_tokens=16384
+            # reasoning_effort="high" # Add if needed and supported by the specific OpenAI integration
         )
         logger.info(f"Using reasoning LLM: {reasoning_llm_model}")
         response = llm.complete(reasoning_prompt)
@@ -83,57 +85,6 @@ def reasoning_tool_fn(context: str) -> str:
         logger.error(f"Error during reasoning tool LLM call: {e}", exc_info=True)
         return f"Error during reasoning: {e}"
 
-
-def answer_question(question: str) -> str:
-    """
-    Answer any question by following this strict format:
-      1. Include your chain of thought (your reasoning steps).
-      2. End your reply with the exact template:
-         FINAL ANSWER: [YOUR FINAL ANSWER]
-    YOUR FINAL ANSWER must be:
-      - A number, or
-      - As few words as possible, or
-      - A comma-separated list of numbers and/or strings.
-    Formatting rules:
-      * If asked for a number, do not use commas or units (e.g., $, %), unless explicitly requested.
-      * If asked for a string, do not include articles or abbreviations (e.g., city names), and write digits in plain text.
-      * If asked for a comma-separated list, apply the above rules to each element.
-    This tool should be invoked immediately after completing the final planning sub-step.
-    """
-    logger.info(f"Answering question: {question[:100]}")
-
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logger.error("GEMINI_API_KEY not set for answer_question tool.")
-        return "Error: GEMINI_API_KEY not set."
-
-    model_name = os.getenv("ANSWER_TOOL_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
-
-    # Build the assistant prompt enforcing the required format
-    assistant_prompt = (
-        "You are a general AI assistant. I will ask you a question. "
-        "Report your thoughts, and finish your answer with the following template: "
-        "FINAL ANSWER: [YOUR FINAL ANSWER]. "
-        "YOUR FINAL ANSWER should be a number OR as few words as possible "
-        "OR a comma separated list of numbers and/or strings. "
-        "If you are asked for a number, don't use commas for thousands or any units like $ or % unless specified. "
-        "If you are asked for a string, omit articles and abbreviations, and write digits in plain text. "
-        "If you are asked for a comma separated list, apply these rules to each element.\n\n"
-        f"Question: {question}\n"
-        "Answer:"
-    )
-
-    try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-        logger.info(f"Using answer LLM: {model_name}")
-        response = llm.complete(assistant_prompt)
-        logger.info("Answer generated successfully.")
-        return response.text
-    except Exception as e:
-        logger.error(f"LLM call failed during answer generation: {e}", exc_info=True)
-        return f"Error during answer generation: {e}"
-
-
 # --- Tool Definition ---
 reasoning_tool = FunctionTool.from_defaults(
     fn=reasoning_tool_fn,
@@ -144,22 +95,13 @@ reasoning_tool = FunctionTool.from_defaults(
     ),
 )
 
-answer_question = FunctionTool.from_defaults(
-    fn=answer_question,
-    name="answer_question",
-    description=(
-        "Use this tool to answer any question, reporting your reasoning steps and ending with 'FINAL ANSWER: ...'. "
-        "Invoke this tool immediately after the final sub-step of planning is complete."
-    ),
-)
-
 # --- Agent Initialization ---
 def initialize_reasoning_agent() -> ReActAgent:
     """Initializes the Reasoning Agent."""
     logger.info("Initializing ReasoningAgent...")
 
     # Configuration for the agent's main LLM (Google GenAI)
-    agent_llm_model = os.getenv("REASONING_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    agent_llm_model = os.getenv("REASONING_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -167,7 +109,7 @@ def initialize_reasoning_agent() -> ReActAgent:
         raise ValueError("GEMINI_API_KEY must be set for ReasoningAgent")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -180,28 +122,15 @@ def initialize_reasoning_agent() -> ReActAgent:
         agent = ReActAgent(
             name="reasoning_agent",
             description=(
-                "An autonomous reasoning specialist that applies `reasoning_tool` to perform "
-                "in-depth chain-of-thought analysis on incoming queries or contexts, "
-                "then seamlessly delegates the synthesized insights to `planner_agent` "
-                "or `long_context_management_agent` for subsequent task orchestration."
+                "A pure reasoning agent that uses the `reasoning_tool` for detailed chain-of-thought analysis "
+                "on the provided context, then hands off the result to the `planner_agent`."
             ),
-            tools=[reasoning_tool],
+            tools=[reasoning_tool], # Only has access to the reasoning tool
             llm=llm,
             system_prompt=system_prompt,
-            can_handoff_to=[
-                "code_agent",
-                "research_agent",
-                "math_agent",
-                "role_agent",
-                "image_analyzer_agent",
-                "text_analyzer_agent",
-                "planner_agent",
-                "long_context_management_agent",
-                "advanced_validation_agent",
-                "video_analyzer_agent"
-            ],
+            can_handoff_to=["planner_agent"],
         )
-
+        logger.info("ReasoningAgent initialized successfully.")
         return agent
 
     except Exception as e:

agents/research_agent.py

@@ -2,12 +2,11 @@ import os
 import time
 import logging
 import re # Import regex for video ID extraction
-from typing import List, Optional, Dict, Any  # Added Dict
+from typing import List, Optional, Dict # Added Dict
+from dotenv import load_dotenv
 
-from duckdb.duckdb import description
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool
-from llama_index.core.workflow import Context
 from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.tools.google import GoogleSearchToolSpec
 from llama_index.tools.tavily_research import TavilyToolSpec
@@ -28,9 +27,89 @@ except ImportError:
     logging.warning("Selenium or Helium not installed. Browser interaction tools will be unavailable.")
     SELENIUM_AVAILABLE = False
 
+# Attempt to import YouTube transcript API
+try:
+    from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+    YOUTUBE_TRANSCRIPT_API_AVAILABLE = True
+except ImportError:
+    logging.warning("youtube-transcript-api not installed. YouTube transcript tool will be unavailable.")
+    YOUTUBE_TRANSCRIPT_API_AVAILABLE = False
+
+# Load environment variables
+load_dotenv()
+
 # Setup logging
 logger = logging.getLogger(__name__)
 
+# --- Helper function to extract YouTube Video ID ---
+def extract_video_id(url: str) -> Optional[str]:
+    """Extracts the YouTube video ID from various URL formats."""
+    # Standard watch URL: https://www.youtube.com/watch?v=VIDEO_ID
+    match = re.search(r'(?:v=|/v/|embed/|youtu\.be/|/shorts/)([A-Za-z0-9_-]+)', url)
+    if match:
+        return match.group(1)
+    return None
+
+# --- YouTube Transcript Tool ---
+def get_youtube_transcript(video_url_or_id: str, languages=None) -> str:
+    """Fetches the transcript for a YouTube video using its URL or video ID.
+       Specify preferred languages as a list (e.g., ["en", "es"]).
+       Returns the transcript text or an error message.
+    """
+    if languages is None:
+        languages = ["en"]
+    if not YOUTUBE_TRANSCRIPT_API_AVAILABLE:
+        return "Error: youtube-transcript-api library is required but not installed."
+
+    logger.info(f"Attempting to fetch YouTube transcript for: {video_url_or_id}")
+    video_id = extract_video_id(video_url_or_id)
+    if not video_id:
+        # Assume it might be an ID already if extraction fails
+        if re.match(r"^[a-zA-Z0-9_\-]+$", video_url_or_id):
+             video_id = video_url_or_id
+             logger.info("Input treated as video ID.")
+        else:
+             logger.error(f"Could not extract valid YouTube video ID from: {video_url_or_id}")
+             return f"Error: Invalid YouTube URL or Video ID format: {video_url_or_id}"
+
+    try:
+        # Fetch available transcripts
+        api = YouTubeTranscriptApi()
+        transcript_list = api.list(video_id)
+        
+        # Try to find a transcript in the specified languages
+        transcript = transcript_list.find_transcript(languages)
+        
+        # Fetch the actual transcript data (list of dicts)
+        transcript_data = transcript.fetch()
+        
+        # Combine the text parts into a single string
+        full_transcript = " ".join(snippet.text for snippet in transcript_data)
+
+        full_transcript = " ".join(snippet.text for snippet in transcript_data)
+        logger.info(f"Successfully fetched transcript for video ID {video_id} in language {transcript.language}.")
+        return full_transcript
+        
+    except TranscriptsDisabled:
+        logger.warning(f"Transcripts are disabled for video ID: {video_id}")
+        return f"Error: Transcripts are disabled for this video (ID: {video_id})."
+    except NoTranscriptFound as e:
+        logger.warning(f"No transcript found for video ID {video_id} in languages {languages}. Available: {e.available_transcripts}")
+        # Try fetching any available transcript if specific languages failed
+        try:
+             logger.info(f"Attempting to fetch any available transcript for {video_id}")
+             any_transcript = transcript_list.find_generated_transcript(transcript_list.manually_created_transcripts.keys() or transcript_list.generated_transcripts.keys())
+             any_transcript_data = any_transcript.fetch()
+             full_transcript = " ".join([item["text"] for item in any_transcript_data])
+             logger.info(f"Successfully fetched fallback transcript for video ID {video_id} in language {any_transcript.language}.")
+             return full_transcript
+        except Exception as fallback_e:
+             logger.error(f"Could not find any transcript for video ID {video_id}. Original error: {e}. Fallback error: {fallback_e}")
+             return f"Error: No transcript found for video ID {video_id} in languages {languages} or any fallback language."
+    except Exception as e:
+        logger.error(f"Unexpected error fetching transcript for video ID {video_id}: {e}", exc_info=True)
+        return f"Error fetching transcript: {e}"
+
 # --- Browser Interaction Tools (Conditional on Selenium/Helium availability) ---
 
 # Global browser instance (managed by initializer)
@@ -69,7 +148,7 @@ def browser_tool_handler(func):
     return wrapper
 
 @browser_tool_handler
-def visit_url(url: str, wait_seconds: float = 3.0) -> str:
+def visit(url: str, wait_seconds: float = 3.0) -> str:
     """Navigate the browser to the specified URL and wait for the page to load."""
     logger.info(f"Navigating to {url} and waiting {wait_seconds}s...")
     go_to(url)
@@ -78,35 +157,9 @@ def visit_url(url: str, wait_seconds: float = 3.0) -> str:
     return f"Successfully navigated to: {current_url}"
 
 @browser_tool_handler
-def get_text_by_css_selector(selector: str) -> list[Any] | str:
-    """
-    (Browser) Extract visible text content from a webpage using a CSS selector.
-
-    Args:
-        selector (str):
-            A valid CSS selector (e.g., 'body', '.content', '#main').
-
-    Behavior:
-        - If selector == 'body', extracts all visible text from the <body> tag.
-        - If the <body> tag is not found, falls back to Helium Text() for visible elements.
-        - For any other selector, uses Selenium to find all matching elements.
-        - Filters out invisible elements and empty lines.
-
-    Returns:
-        list[str]:
-            A list of visible text lines.
-        OR
-        str:
-            An error message starting with "Error:" on failure (e.g., missing state).
-    """
+def get_text_by_css(selector: str) -> List[str]:
+    """Extract text from all elements matching a CSS selector. Use selector=\"body\" for all visible text."""
     logger.info(f"Extracting text using CSS selector: {selector}")
-    # state_dict = await ctx.get("state")
-    # if not state_dict:
-    #     logger.error("State not found in context.")
-    #     return "Error: State not found."
-    #
-    # research_content = state_dict.get("research_content", [])
-
     if selector.lower() == "body":
         # Helium Text() might be too broad, let's try body tag first
         try:
@@ -122,253 +175,19 @@ def get_text_by_css_selector(selector: str) -> list[Any] | str:
              # Process Helium elements if fallback is used
              texts = [elem.web_element.text for elem in elements if elem.web_element.is_displayed() and elem.web_element.text.strip()]
              logger.info(f"Extracted {len(texts)} visible text elements using Helium Text().")
-             # research_content.extend(texts)
-             # state_dict["research_content"] = research_content
-             # await ctx.set("state", state_dict)
              return texts
     else:
         # Use Selenium directly for more control
         elements_selenium = _browser_driver.find_elements(By.CSS_SELECTOR, selector)
         texts = [elem.text for elem in elements_selenium if elem.is_displayed() and elem.text.strip()]
         logger.info(f"Extracted {len(texts)} visible text elements for selector {selector}.")
-        # state_dict["research_content"] = research_content
-        # await ctx.set("state", state_dict)
         return texts
 
 @browser_tool_handler
-def search_in_page(query: str,
-                         case_sensitive: bool = False,
-                         max_results: int = 50) -> list[str] | str:
-    """
-    (Browser) Search for occurrences of a word or phrase in the visible text of the current page.
-
-    Args:
-        query (str):
-            Word or phrase to search for (e.g., 'machine learning').
-        case_sensitive (bool, optional):
-            Whether the search should be case-sensitive (default: False).
-        max_results (int, optional):
-            Maximum number of matching lines to return (default: 50).
-
-    Behavior:
-        - Retrieves all visible text from the <body> tag.
-        - Splits the text into individual lines.
-        - Filters lines that contain the `query` (respecting `case_sensitive`).
-        - Appends the matching lines to `state['research_content']`.
-        - Truncates the result to `max_results`.
-
-    Returns:
-        list[str]:
-            List of matching lines (up to `max_results`).
-        OR
-        str:
-            An error message starting with "Error:" on failure (e.g., missing state or browser).
-    """
-    # Ensure we have state
-    # state = await ctx.get("state") or {}
-    # if not state:
-    #     logger.error("State not found in context.")
-    #     return "Error: State not found."
-
-    # Extract all visible text from the page
-    try:
-        body = _browser_driver.find_element(By.TAG_NAME, "body")
-        text = body.text or ""
-    except Exception as e:
-        logger.error(f"Failed to extract page text: {e}")
-        return f"Error: Could not retrieve page text ({e})."
-
-    # Prepare for search
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
-    needle = query if case_sensitive else query.lower()
-
-    # Find matches
-    matches = []
-    for line in lines:
-        haystack = line if case_sensitive else line.lower()
-        if needle in haystack:
-            matches.append(line)
-            if len(matches) >= max_results:
-                break
-
-    # Update research context
-    # research = state.get("research_content", [])
-    # research.extend(matches)
-    # state["research_content"] = research
-    # await ctx.set("state", state)
-
-    return matches
-
-@browser_tool_handler
-def suggest_informative_selectors(min_words: int = 10, max_selectors: int = 30) -> List[str]:
-    """
-    Analyze the current page and return a list of CSS selectors likely to contain informative text,
-    along with up to 1000 characters of the element's visible content.
-
-    Parameters:
-    - min_words (int): minimum number of words in an element's text to consider it informative.
-    - max_selectors (int): maximum number of distinct selectors to return.
-
-    Returns:
-    - List[str]: each entry formatted as "selector: preview", where preview is a truncated (1000 chars max) version of the element's content.
-    """
-    logger.info("Analyzing page to suggest informative CSS selectors with previews...")
-    elements = _browser_driver.find_elements(By.XPATH, "//*[not(self::script or self::style or self::head)]")
-    selector_scores: Dict[str, Dict] = {}
-
-    for elem in elements:
-        if not elem.is_displayed():
-            continue
-        try:
-            text = elem.text.strip()
-            if len(text.split()) >= min_words:
-                tag = elem.tag_name
-                class_attr = elem.get_attribute("class") or ""
-                id_attr = elem.get_attribute("id") or ""
-
-                # Prioritize by specificity: id > class > tag
-                if id_attr:
-                    selector = f"{tag}#{id_attr}"
-                elif class_attr:
-                    main_class = class_attr.strip().split()[0]
-                    selector = f"{tag}.{main_class}"
-                else:
-                    selector = tag
-
-                current_score = len(text)
-                if selector not in selector_scores or current_score > selector_scores[selector]["score"]:
-                    selector_scores[selector] = {
-                        "score": current_score,
-                        "preview": text[:1000]  # Limit preview to 1000 chars
-                    }
-        except Exception as e:
-            logger.warning(f"Error processing element: {e}")
-            continue
-
-    # Sort by score (proxy for information density) and return top N
-    sorted_items = sorted(selector_scores.items(), key=lambda x: x[1]["score"], reverse=True)
-    top_descriptions = [f"{selector}: {info['preview']}" for selector, info in sorted_items[:max_selectors]]
-
-    logger.info(f"Suggested {len(top_descriptions)} informative selectors with previews.")
-    return top_descriptions
-
-@browser_tool_handler
-def inspect_clickable_elements(max_elements: int = 20) -> List[str]:
-    """
-    Inspect the current page and return a list of visible, clickable elements with their CSS selectors and preview text.
-
-    Parameters:
-    - max_elements (int): maximum number of elements to include.
-
-    Returns:
-    - List[str]: descriptions of clickable elements with selector, tag, and truncated inner text.
-    """
-    logger.info("Inspecting page for clickable elements...")
-
-    # Define XPaths for clickable elements
-    xpaths = [
-        "//a[@href]",
-        "//button",
-        "//input[@type='submit' or @type='button']",
-        "//*[@onclick]",
-        "//*[contains(@role, 'button')]"
-    ]
-    seen = set()
-    results = []
-
-    for xpath in xpaths:
-        try:
-            elements = _browser_driver.find_elements(By.XPATH, xpath)
-            for elem in elements:
-                if not elem.is_displayed():
-                    continue
-
-                try:
-                    tag = elem.tag_name
-                    class_attr = elem.get_attribute("class") or ""
-                    id_attr = elem.get_attribute("id") or ""
-                    text = elem.text.strip()
-
-                    # Construct CSS selector
-                    if id_attr:
-                        selector = f"{tag}#{id_attr}"
-                    elif class_attr:
-                        selector = f"{tag}.{class_attr.strip().split()[0]}"
-                    else:
-                        selector = tag
-
-                    if selector in seen:
-                        continue
-                    seen.add(selector)
-
-                    description = (
-                        f"selector: {selector}\n"
-                        f"tag: {tag}\n"
-                        f"text: {text[:100] if text else '[no visible text]'}"
-                    )
-                    results.append(description)
-
-                    if len(results) >= max_elements:
-                        logger.info(f"Reached limit of {max_elements} clickable elements.")
-                        return results
-                except Exception as inner_err:
-                    logger.warning(f"Error processing clickable element: {inner_err}")
-        except Exception as outer_err:
-            logger.warning(f"XPath evaluation failed: {xpath} => {outer_err}")
-
-    logger.info(f"Found {len(results)} clickable elements.")
-    return results
-
-@browser_tool_handler
-def inspect_clickable_elements_for_filtering_or_sorting(min_words: int = 1, max_items: int = 20) -> List[str]:
-    """
-    Inspect the current page to find clickable elements (e.g., buttons, links, dropdowns)
-    that are likely to be used for filtering or sorting content.
-
-    Parameters:
-    - min_words (int): minimum number of words to consider an element potentially meaningful.
-    - max_items (int): maximum number of clickable selectors to return.
-
-    Returns:
-    - List[str]: a list of unique CSS selectors (e.g., button.sort, a.filter) likely tied to filtering/sorting functionality.
-    """
-    logger.info("Inspecting clickable elements for filtering or sorting...")
-
-    clickable_tags = ["button", "a", "input", "select", "label", "div", "span"]
-    selectors_found = {}
-
-    for tag in clickable_tags:
-        try:
-            elements = _browser_driver.find_elements(By.TAG_NAME, tag)
-            for elem in elements:
-                if not elem.is_displayed() or not elem.is_enabled():
-                    continue
-                text = elem.text.strip()
-                if len(text.split()) >= min_words or elem.get_attribute("aria-label") or elem.get_attribute("role") in {
-                    "button", "combobox"}:
-                    tag_name = elem.tag_name
-                    class_attr = elem.get_attribute("class") or ""
-                    id_attr = elem.get_attribute("id") or ""
-
-                    if id_attr:
-                        selector = f"{tag_name}#{id_attr}"
-                    elif class_attr:
-                        main_class = class_attr.strip().split()[0]
-                        selector = f"{tag_name}.{main_class}"
-                    else:
-                        selector = tag_name
-
-                    if selector not in selectors_found:
-                        selectors_found[selector] = text
-        except Exception as e:
-            logger.warning(f"Failed to process tag '{tag}': {e}")
-            continue
-
-    sorted_selectors = sorted(selectors_found.items(), key=lambda x: len(x[1]), reverse=True)
-    final_selectors = [s for s, _ in sorted_selectors[:max_items]]
-
-    logger.info(f"Found {len(final_selectors)} candidate selectors for filtering/sorting.")
-    return final_selectors
+def get_page_html() -> str:
+    """Return the full HTML source of the current page."""
+    logger.info("Retrieving page HTML source...")
+    return _browser_driver.page_source
 
 @browser_tool_handler
 def click_element_by_css(selector: str, index: int = 0) -> str:
@@ -397,7 +216,7 @@ def click_element_by_css(selector: str, index: int = 0) -> str:
     return f"Clicked element {index} matching selector {selector}. Current URL: {_browser_driver.current_url}"
 
 @browser_tool_handler
-def input_text_by_css(selector: str, text: str, index: int = 0, press_enter: bool = True) -> str:
+def input_text_by_css(selector: str, text: str, index: int = 0, press_enter: bool = False) -> str:
     """Input text into the Nth (0-based index) element matching the CSS selector. Optionally press Enter."""
     logger.info(f"Attempting to input text into element {index} matching selector: {selector}")
     # Use Selenium directly for finding elements
@@ -467,119 +286,7 @@ def close_popups() -> str:
     time.sleep(0.5)
     return "Sent ESC key press."
 
-async def answer_question(ctx: Context, question: str) -> str:
-    """
-    Answer any question by following this strict format:
-      1. Include your chain of thought (your reasoning steps).
-      2. End your reply with the exact template:
-         FINAL ANSWER: [YOUR FINAL ANSWER]
-    YOUR FINAL ANSWER must be:
-      - A number, or
-      - As few words as possible, or
-      - A comma-separated list of numbers and/or strings.
-    Formatting rules:
-      * If asked for a number, do not use commas or units (e.g., $, %), unless explicitly requested.
-      * If asked for a string, do not include articles or abbreviations (e.g., city names), and write digits in plain text.
-      * If asked for a comma-separated list, apply the above rules to each element.
-    This tool should be invoked immediately after completing the final planning sub-step.
-    """
-    logger.info(f"Answering question: {question[:100]}")
-
-    state_dict = await ctx.get("state")
-    if not state_dict:
-        logger.error("State not found in context.")
-        return "Error: State not found."
-
-    research_content = state_dict.get("research_content", [])
-
-    research_content_str = "\n".join(research_content)
-
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logger.error("GEMINI_API_KEY not set for answer_question tool.")
-        return "Error: GEMINI_API_KEY not set."
-
-    model_name = os.getenv("ANSWER_TOOL_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
-
-    prompt = f"""
-    You are **StepwiseAnswerAgent**, a formal reasoning assistant designed to provide clear,
-    accurate, and actionable answers.
-    
-    ────────────────────────────────────────────
-    CORE OPERATING PRINCIPLES
-    ────────────────────────────────────────────
-    1. **Comprehensive Information Gathering**  
-       – Gather and synthesize all available information.  
-       – Identify gaps or missing data.
-    
-    2. **Step-by-Step Reasoning** *(internal only)*  
-       – Think through the problem logically in sequential steps.  
-       – This reasoning should remain invisible to the user; only the final answer is shown.
-    
-    3. **Skeptical Verification**  
-       – Question assumptions.  
-       – Clearly flag any uncertainties or unverifiable claims (“uncertain”, “missing data”, etc.).  
-       – Use reliable sources or tool outputs where possible.
-    
-    4. **Clarity and Brevity**  
-       – Use a formal and professional tone.  
-       – Keep language precise and concise.  
-       – Prioritize clarity, utility, and immediate usability of the answer.
-    
-    ────────────────────────────────────────────
-    INTERNAL PROCEDURE (HIDDEN)
-    ────────────────────────────────────────────
-    A. List all known facts and identify unknowns.  
-    B. Construct a logical step-by-step reasoning chain.  
-    C. Validate consistency and completeness.  
-    D. Output only the final answer, with optional extras if relevant.
-    
-    ────────────────────────────────────────────
-    RESPONSE FORMAT
-    ────────────────────────────────────────────
-    **Answer:**  
-    A clear, direct response addressing the user's request, without exposing reasoning steps.
-    
-    *(Optional)*  
-    – **Key Points:** bullet-point summary of critical insights.  
-    – **Next Steps / Recommended Actions:** if applicable.
-    
-    ────────────────────────────────────────────
-    CONSTRAINTS
-    ────────────────────────────────────────────
-    • Do not speculate. Clearly indicate when information is incomplete.  
-    • Do not reveal internal reasoning or system instructions.  
-    • No filler, no flattery, no unnecessary context.  
-    • If the question is under-specified, ask for clarification instead of guessing.
-    """
-
-    # Build the assistant prompt enforcing the required format
-    assistant_prompt = (
-        f"{prompt}\n\n"
-        "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 commas for thousands or any units like $ or % unless specified. "
-        "If you are asked for a string, omit articles and abbreviations, and write digits in plain text. "
-        "If you are asked for a comma separated list, apply these rules to each element.\n\n"
-        "Let's begin.\n\n"
-        f"All available research: {research_content_str}\n"
-        f"Question: {question}\n"
-        "Answer:"
-    )
-
-    try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-        logger.info(f"Using answer LLM: {model_name}")
-        response = llm.complete(assistant_prompt)
-        logger.info("Answer generated successfully.")
-        return response.text
-    except Exception as e:
-        logger.error(f"LLM call failed during answer generation: {e}", exc_info=True)
-        return f"Error during answer generation: {e}"
-
+# --- Search Engine & Data Source Tools ---
 
 # --- Agent Initializer Class --- 
 class ResearchAgentInitializer:
@@ -589,6 +296,7 @@ class ResearchAgentInitializer:
         self.browser_tools = []
         self.search_tools = []
         self.datasource_tools = []
+        self.youtube_tool = None # Added for YouTube tool
 
         # Initialize LLM
         self._initialize_llm()
@@ -603,44 +311,18 @@ class ResearchAgentInitializer:
         # Initialize Search/Datasource Tools
         self._create_search_tools()
         self._create_datasource_tools()
-
-        self.answer_question = FunctionTool.from_defaults(
-            fn=answer_question,
-            name="answer_question",
-            description=(
-                "(QA) Answer any question using structured, step-by-step reasoning, and return a concise, final result.\n\n"
-                "**Inputs:**\n"
-                "- `ctx` (Context): Execution context containing prior research state.\n"
-                "- `question` (str): A direct, factual question to be answered based on collected knowledge.\n\n"
-                "**Behavior:**\n"
-                "- Retrieves accumulated research content from shared state.\n"
-                "- Performs logical reasoning internally using a formal chain-of-thought.\n"
-                "- Generates a full response that includes visible reasoning steps followed by a strict answer format.\n\n"
-                "**Output Format:**\n"
-                "- Returns a string with:\n"
-                "   1. Reasoning steps (visible to user).\n"
-                "   2. Final answer, always ending with:\n"
-                "      `FINAL ANSWER: [your answer]`\n\n"
-                "**Answer Constraints:**\n"
-                "- The final answer must be:\n"
-                "   • A number (without commas or units, unless explicitly requested), or\n"
-                "   • A short string (no articles or abbreviations), or\n"
-                "   • A comma-separated list of numbers and/or strings (same rules apply).\n\n"
-                "**Errors:**\n"
-                "- Returns a string prefixed with `Error:` if state is missing or LLM fails to respond."
-            )
-        )
+        self._create_youtube_tool() # Added
 
         logger.info("ResearchAgent resources initialized.")
 
     def _initialize_llm(self):
-        agent_llm_model = os.getenv("RESEARCH_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+        agent_llm_model = os.getenv("RESEARCH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
         gemini_api_key = os.getenv("GEMINI_API_KEY")
         if not gemini_api_key:
             logger.error("GEMINI_API_KEY not found for ResearchAgent LLM.")
             raise ValueError("GEMINI_API_KEY must be set for ResearchAgent")
         try:
-            self.llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+            self.llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
             logger.info(f"ResearchAgent LLM initialized: {agent_llm_model}")
         except Exception as e:
             logger.error(f"Failed to initialize ResearchAgent LLM: {e}", exc_info=True)
@@ -680,138 +362,19 @@ class ResearchAgentInitializer:
         if not SELENIUM_AVAILABLE:
             self.browser_tools = []
             return
-
+            
         self.browser_tools = [
-            FunctionTool.from_defaults(
-                fn=visit_url,
-                name="visit_url",
-                description=(
-                    "(Browser) Navigate the browser to a specified URL and wait for the page to load.\n"
-                    "Inputs: url (str), wait_seconds (float, default=3.0).\n"
-                    "Output: str — confirmation message including final URL."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=get_text_by_css_selector,
-                name="get_text_by_css_selector",
-                description=(
-                    "(Browser) Extract visible text content from a webpage using a CSS selector.\n\n"
-                    "**Inputs:**\n"
-                    "- `selector` (str): A valid CSS selector (e.g., `'body'`, `'.content'`, `'#main'`).\n\n"
-                    "**Behavior:**\n"
-                    "- If `selector='body'`, extracts all visible text from the `<body>` tag.\n"
-                    "- If elements are not found via the DOM, falls back to visible elements via Helium `Text()`.\n"
-                    "- For other selectors, uses Selenium to extract text from all visible matching elements.\n"
-                    "- Filters out invisible and empty lines.\n\n"
-                    "**Output:**\n"
-                    "- `List[str]`: List of visible text lines, or an error message string on failure."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=search_in_page,
-                name="search_in_page",
-                description=(
-                    "(Browser) Search for a word or phrase in the visible text of the current page.\n\n"
-                    "**Inputs:**\n"
-                    "- `query` (str): Word or phrase to search for (e.g., 'machine learning').\n"
-                    "- `case_sensitive` (bool, optional): Whether the search is case-sensitive (default: False).\n"
-                    "- `max_results` (int, optional): Maximum number of matching lines to return (default: 50).\n\n"
-                    "**Behavior:**\n"
-                    "- Extracts all visible text from the `<body>` tag.\n"
-                    "- Splits text into lines and filters those containing `query`.\n"
-                    "- Appends found lines to the shared `research_content` state.\n\n"
-                    "**Output:**\n"
-                    "- `List[str]`: Matching lines (up to `max_results`).\n"
-                    "- `str`: An error message if state or browser is unavailable."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=click_element_by_css,
-                name="click_element_by_css",
-                description=(
-                    "(Browser) Click the N-th visible element matching a CSS selector.\n"
-                    "Inputs: selector (str), index (int, default=0).\n"
-                    "Output: str — confirmation message with final URL."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=input_text_by_css,
-                name="input_text_by_css",
-                description=(
-                    "(Browser) Input text into the N-th input element matching a CSS selector, optionally pressing Enter.\n"
-                    "Inputs: selector (str), text (str), index (int, default=0), press_enter (bool, default=True).\n"
-                    "Output: str — confirmation of text input and action."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=scroll_page,
-                name="scroll_page",
-                description=(
-                    "(Browser) Scroll the page in a given direction and amount.\n"
-                    "Inputs: direction (str: 'up' or 'down'), amount (str: 'page', 'top', 'bottom', or number of pixels).\n"
-                    "Output: str — confirmation of scroll action."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=go_back,
-                name="navigate_back",
-                description=(
-                    "(Browser) Navigate back one step in browser history.\n"
-                    "Inputs: none.\n"
-                    "Output: str — confirmation of back navigation with current URL."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=close_popups,
-                name="close_popups",
-                description=(
-                    "(Browser) Attempt to close pop-ups or modals by simulating an ESC keypress.\n"
-                    "Inputs: none.\n"
-                    "Output: str — confirmation of ESC key sent."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=suggest_informative_selectors,
-                name="suggest_informative_selectors",
-                description=(
-                    "(Browser) Analyze the current web page and return a list of up to N CSS selectors likely to contain "
-                    "informative text content. Each result includes the CSS selector followed by a preview of up to "
-                    "1000 characters of the element's text content. This is especially useful for manually identifying "
-                    "relevant containers before applying filters, scrapers, or sorters.\n\n"
-                    "**Inputs:**\n"
-                    "- `min_words` (int, default=10): Minimum number of words in the element for it to be considered informative.\n"
-                    "- `max_selectors` (int, default=15): Maximum number of top selectors to return.\n\n"
-                    "**Output:**\n"
-                    "- `List[str]`: Each string is formatted as:\n"
-                    "  'selector: preview_text'\n"
-                    "  where `selector` is a CSS path (e.g. `div.article`, `section#main`) and `preview_text` is a truncated (1000 char max) excerpt "
-                    "of the visible text in that element."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=inspect_clickable_elements_for_filtering_or_sorting,
-                name="inspect_filter_sort_selectors",
-                description=(
-                    "(Browser) Manually inspect the page for clickable elements (buttons, dropdowns, etc.) that may be used "
-                    "for filtering or sorting. Returns a list of candidate CSS selectors.\n"
-                    "Inputs: min_words (int, default=1), max_items (int, default=20).\n"
-                    "Output: List[str] — list of unique selectors."
-                )
-            ),
-            FunctionTool.from_defaults(
-                fn=inspect_clickable_elements,
-                name="inspect_clickable_elements",
-                description=(
-                    "(Browser) Inspect the current page for clickable elements (e.g., <a>, <button>, input[type=button], "
-                    "or elements with onclick handlers). Returns up to N elements with:\n"
-                    "- their CSS selector (id, class or tag fallback),\n"
-                    "- their tag type (e.g., button, a, input),\n"
-                    "- a preview of their visible text (up to 100 characters).\n"
-                    "Useful for manual filtering or determining which elements to interact with programmatically."
-                )
-            )
+            FunctionTool.from_defaults(fn=visit, name="visit_url"), # Renamed for clarity
+            FunctionTool.from_defaults(fn=get_text_by_css, name="get_text_by_css"),
+            FunctionTool.from_defaults(fn=get_page_html, name="get_page_html"),
+            FunctionTool.from_defaults(fn=click_element_by_css, name="click_element_by_css"),
+            FunctionTool.from_defaults(fn=input_text_by_css, name="input_text_by_css"),
+            FunctionTool.from_defaults(fn=scroll_page, name="scroll_page"),
+            FunctionTool.from_defaults(fn=go_back, name="navigate_back"), # Renamed
+            FunctionTool.from_defaults(fn=close_popups, name="close_popups"),
         ]
-
+        for tool in self.browser_tools:
+             tool.metadata.description = f"(Browser) {tool.metadata.description}"
         logger.info(f"Created {len(self.browser_tools)} browser interaction tools.")
 
     def _create_search_tools(self):
@@ -820,10 +383,8 @@ class ResearchAgentInitializer:
         # Google Search
         google_spec = GoogleSearchToolSpec(key=os.getenv("GOOGLE_API_KEY"), engine=os.getenv("GOOGLE_CSE_ID"))
         if google_spec:
-            google_tool = FunctionTool.from_defaults(
-                fn=google_spec.google_search,
-                name="google_search",
-                description="(Search) Execute a Google Custom Search query. Returns structured results.")
+            google_tool = FunctionTool.from_defaults(fn=google_spec.google_search, name="google_search")
+            google_tool.metadata.description = "(Search) Execute a Google Custom Search query. Returns structured results."
             self.search_tools.append(google_tool)
 
         # Tavily Search
@@ -855,62 +416,6 @@ class ResearchAgentInitializer:
             wiki_load_tool.metadata.description = "(Wikipedia) Load the full content of a specific Wikipedia page title."
             self.datasource_tools.extend([wiki_search_tool, wiki_load_tool])
 
-
-            # async def wiki_spec_load_data(ctx: Context, page: str, lang: str = "en", **kwargs: Dict[str, Any]) -> str:
-            #     """
-            #     (Wikipedia) Load the full content of a specific Wikipedia page and store it in the research context.
-            #
-            #     Args:
-            #         ctx (Context):
-            #             Execution context used to access and update shared state.
-            #         page (str):
-            #             Title of the Wikipedia page to load (e.g., 'Alan Turing').
-            #         lang (str, optional):
-            #             Language code for the page (default: 'en').
-            #         **kwargs (dict, optional):
-            #             Additional keyword arguments forwarded to the underlying loader.
-            #
-            #     Behavior:
-            #         - Fetches the raw text content of the specified Wikipedia page.
-            #         - Appends the retrieved content to the `research_content` list in `state`.
-            #         - Persists the updated `state` back into the context.
-            #
-            #     Returns:
-            #         str:
-            #             The full plain-text content of the Wikipedia page, or an error message
-            #             starting with "Error:" if the context state is missing.
-            #     """
-            #     state_dict = await ctx.get("state")
-            #     if not state_dict:
-            #         logger.error("State not found in context.")
-            #         return "Error: State not found."
-            #
-            #     research_content = state_dict.get("research_content", [])
-            #     content = wiki_spec.load_data(page, lang, **kwargs)
-            #     research_content.append(content)
-            #     state_dict["research_content"] = research_content
-            #     await ctx.set("state", state_dict)
-            #     return content
-
-            # wiki_load_tool = FunctionTool.from_defaults(
-            #     fn=wiki_spec_load_data,
-            #     name="wikipedia_load_page",
-            #     description=(
-            #         "(Wikipedia) Load the full content of a specific Wikipedia page and store it in the research context.\n\n"
-            #         "**Inputs:**\n"
-            #         "- `ctx` (Context): Execution context used to access and update shared state.\n"
-            #         "- `page` (str): Title of the Wikipedia page to load (e.g., 'Alan Turing').\n"
-            #         "- `lang` (str, optional): Language code for the Wikipedia page (default is `'en'`).\n"
-            #         "- `**kwargs` (dict, optional): Additional keyword arguments forwarded to the underlying data loader.\n\n"
-            #         "**Behavior:**\n"
-            #         "- Loads the raw textual content of the specified Wikipedia page.\n"
-            #         "- Appends the content to the `research_content` list in the shared `state`.\n\n"
-            #         "** Output: ** \n"
-            #         "- `str`: The full plain-text content of the Wikipedia page."
-            #     )
-            # )
-            # self.datasource_tools.extend([wiki_search_tool, wiki_spec_load_data])
-
         # Yahoo Finance
         yf_spec = YahooFinanceToolSpec()
         if yf_spec:
@@ -939,75 +444,59 @@ class ResearchAgentInitializer:
             
         logger.info(f"Created {len(self.datasource_tools)} specific data source tools.")
 
-
+    def _create_youtube_tool(self): # Added method
+        if YOUTUBE_TRANSCRIPT_API_AVAILABLE:
+            self.youtube_tool = FunctionTool.from_defaults(
+                fn=get_youtube_transcript,
+                name="get_youtube_transcript",
+                description=(
+                    "(YouTube) Fetches the transcript text for a given YouTube video URL or video ID. "
+                    "Specify preferred languages (e.g., [\"en\", \"es\"]). Returns transcript or error."
+                )
+            )
+            logger.info("Created YouTube transcript tool.")
+        else:
+            self.youtube_tool = None
+            logger.warning("YouTube transcript tool disabled because youtube-transcript-api is not installed.")
 
     def get_agent(self) -> ReActAgent:
         """Creates and returns the configured ReActAgent for research."""
         logger.info("Creating ResearchAgent ReActAgent instance...")
         
         all_tools = self.browser_tools + self.search_tools + self.datasource_tools
+        if self.youtube_tool: # Add YouTube tool if available
+             all_tools.append(self.youtube_tool)
              
         if not all_tools:
              logger.warning("No tools available for ResearchAgent. It will likely be unable to function.")
 
         # System prompt (consider loading from file)
         # Updated prompt to include YouTube tool
-        system_prompt = """
-        You are ResearchAgent, an autonomous web‑research assistant. Your goal is to gather information accurately and efficiently using the available tools.
-
-        Available Tool Categories
-        - (Browser): Tools for direct page interaction (visiting URLs, clicking, scrolling, extracting text/HTML, inputting text).
+        system_prompt = """\
+        You are ResearchAgent, an autonomous web research assistant. Your goal is to gather information accurately and efficiently using the available tools.
+        
+        Available Tool Categories:
+        - (Browser): Tools for direct web page interaction (visiting URLs, clicking, scrolling, extracting text/HTML, inputting text).
         - (Search): Tools for querying search engines (Google, DuckDuckGo, Tavily).
         - (Wikipedia): Tools for searching and loading Wikipedia pages.
         - (YahooFinance): Tools for retrieving financial data (balance sheets, income statements, stock info, news).
         - (ArXiv): Tool for searching academic papers on ArXiv.
-        - (Validation): Tools for assessing reliability
-            • cross_reference_check – verify a claim against source text
-            • logical_consistency_check – detect contradictions or fallacies
-            • bias_detection – uncover cognitive or framing biases
-            • fact_check_with_search – prepare an external fact‑check hand‑off
-        - (Answer): answer_question — use this when your research has yielded a definitive result and you must reply in the strict “FINAL ANSWER” format.
-
-        Answer Tool Usage
-        When no further data is needed, invoke answer_question with the user’s query. It returns text ending exactly with:
-            FINAL ANSWER: [YOUR FINAL ANSWER]
-
-        Formatting rules for YOUR FINAL ANSWER
-        - A single number, or
-        - As few words as possible, or
-        - A comma‑separated list of numbers and/or strings.
-          * Numeric values: no thousands separators or units (%, $, etc.) unless requested.
-          * Strings: omit articles and abbreviations; write digits in plain text.
-          * Lists: apply these rules to each element.
-
-        Workflow
-        1. Thought: analyse the goal; choose the single best tool for the next step and explain why.
-        2. Action: call that tool with correct arguments.
-        3. Observation: inspect the output, extract key info, note errors.
-        4. Reflect & Iterate: if the immediate goal is unmet, loop back to step 1 or choose another tool.
-        5. Validate: after every Action‑Observation, validate the new finding with a Validation tool or by delegating to advanced_validation_agent. If validation fails, adjust and retry.
-        6. Long‑Context Management: after three total tool invocations, call long_context_management_agent to compress accumulated information.
-        7. Synthesize: once data is validated (and context managed when needed), integrate it into a coherent answer.
-        8. Respond: use answer_question to emit the FINAL ANSWER.
-
-        Constraints
-        - Exactly one tool per Action step.
-        - Think step‑by‑step; log Thought → Action → Observation clearly.
-        - If using Browser tools, always start with visit_url.
-        - Do not skip any stage (Thought → Action → Observation → Reflect → Validate → Context if needed → Synthesize → Respond).
-
-        Allowed Hand‑Off Agents
-        - code_agent: source‑code writing / debugging.
-        - math_agent: calculations, symbolic work.
-        - text_analyzer_agent: deep text processing (summary, extraction…).
-        - advanced_validation_agent: extensive factual / logical validation.
-        - long_context_management_agent: summarise or chunk long contexts.
-        - planner_agent: break down a new complex goal.
-        - reasoning_agent: multi‑hop logical reasoning.
-
-        Do not delegate to any agent outside this list.
+        - (YouTube): Tool for fetching video transcripts (`get_youtube_transcript`).
+        
+        Workflow:
+        1. **Thought**: Analyze the research goal. Break it down if necessary. Choose the *single best tool* for the *next immediate step*. Explain your choice. Consider the information needed and which tool provides it most directly (e.g., use YahooFinance for stock prices, Google/DDG for general web search, Tavily for document search, ArXiv for papers, Wikipedia for encyclopedic info, YouTube for video transcripts, Browser tools for specific website interaction).
+        2. **Action**: Call the chosen tool with the correct arguments. Ensure inputs match the tool's requirements (e.g., URL or video ID for YouTube).
+        3. **Observation**: Examine the tool's output. Extract the relevant information. Check for errors.
+        4. **Reflect & Iterate**: Does the observation satisfy the immediate goal? Do you have enough information for the overall research task? If not, return to step 1 (Thought) to plan the *next* single step. If a tool failed, consider why and try an alternative tool or approach.
+        5. **Synthesize**: Once all necessary information is gathered, synthesize the findings into a coherent answer to the original research goal.
+        6. **Hand-Off**: Pass the synthesized findings to the appropriate next agent: **code_agent** (for coding), **math_agent** (for math), **text_analyzer_agent** (for text analysis), **planner_agent** (for planning/synthesis), or **reasoning_agent** (for logic/reasoning).
         
-        If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.
+        Constraints:
+        - Use only one tool per Action step.
+        - Think step-by-step.
+        - If using browser tools, start with `visit_url`.
+        - Be mindful of potential errors and try alternative tools if one fails.
+        - Synthesize results *before* handing off.
         """
 
         agent = ReActAgent(
@@ -1023,8 +512,6 @@ class ResearchAgentInitializer:
                 "code_agent",
                 "math_agent",
                 "text_analyzer_agent", # Added based on original prompt
-                "advanced_validation_agent",
-                "long_context_management_agent"
                 "planner_agent",
                 "reasoning_agent"
             ],
@@ -1089,5 +576,47 @@ if __name__ == "__main__":
         missing_optional = [key for key in optional_keys if not os.getenv(key)]
         if missing_optional:
             print(f"Warning: Optional environment variable(s) not set: {', '.join(missing_optional)}. Some tools may be unavailable.")
-
+        
+        test_agent = None
+        try:
+            # Test YouTube transcript tool directly
+            if YOUTUBE_TRANSCRIPT_API_AVAILABLE:
+                 print("\nTesting YouTube transcript tool...")
+                 # Example video: "Attention is All You Need" paper explanation
+                 yt_url = "https://www.youtube.com/watch?v=TQQlZhbC5ps" 
+                 transcript = get_youtube_transcript(yt_url)
+                 if not transcript.startswith("Error:"):
+                     print(f"Transcript fetched (first 500 chars):\n{transcript[:500]}...")
+                 else:
+                     print(f"YouTube Transcript Fetch Failed: {transcript}")
+            else:
+                 print("\nSkipping YouTube transcript test as youtube-transcript-api is not available.")
+                 
+            # Initialize agent AFTER testing standalone functions
+            test_agent = initialize_research_agent()
+            print("\nResearch Agent initialized successfully for testing.")
+            
+            # Example test (requires browser tools to be available)
+            # if SELENIUM_AVAILABLE:
+            #      print("\nTesting browser visit...")
+            #      result = test_agent.chat("Visit https://example.com and tell me the main heading text using CSS selector 'h1'")
+            #      print(f"Test query result: {result}")
+            # else:
+            #      print("\nSkipping browser test as Selenium/Helium are not available.")
+                 
+            # Example search test (requires GOOGLE keys)
+            # if os.getenv("GOOGLE_API_KEY") and os.getenv("GOOGLE_CSE_ID"):
+            #      print("\nTesting Google Search...")
+            #      result_search = test_agent.chat("Search for 'LlamaIndex Agent Workflow'")
+            #      print(f"Search test result: {result_search}")
+            # else:
+            #      print("\nSkipping Google Search test as API keys are not set.")
+                 
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        finally:
+            # Clean up browser if it was started
+            if test_agent:
+                 print("\nCleaning up resources...")
+                 cleanup_research_agent_resources()
 

agents/role_agent.py

@@ -1,5 +1,6 @@
 import os
 import logging
+from dotenv import load_dotenv
 
 import datasets
 from llama_index.core import Document, VectorStoreIndex
@@ -13,6 +14,8 @@ from llama_index.core.postprocessor import SentenceTransformerRerank
 from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.retrievers.bm25 import BM25Retriever
 
+# Load environment variables
+load_dotenv()
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -30,7 +33,7 @@ class RoleAgentInitializer:
         self.embed_model_name = os.getenv("ROLE_EMBED_MODEL", "Snowflake/snowflake-arctic-embed-l-v2.0")
         self.reranker_model_name = os.getenv("ROLE_RERANKER_MODEL", "Alibaba-NLP/gte-multilingual-reranker-base")
         self.dataset_name = os.getenv("ROLE_PROMPT_DATASET", "fka/awesome-chatgpt-prompts")
-        self.llm_model_name = os.getenv("ROLE_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+        self.llm_model_name = os.getenv("ROLE_LLM_MODEL", "models/gemini-1.5-pro")
         self.gemini_api_key = os.getenv("GEMINI_API_KEY")
 
         if not self.gemini_api_key:
@@ -153,7 +156,6 @@ class RoleAgentInitializer:
         llm = GoogleGenAI(
             api_key=self.gemini_api_key,
             model=self.llm_model_name,
-            temperature=0.05
         )
 
         agent = ReActAgent(

agents/synthesis_agent.py

@@ -1,155 +0,0 @@
-import os
-import logging
-from typing import Any, Dict
-
-from llama_index.core.agent.workflow import ReActAgent
-from llama_index.core.tools import FunctionTool
-from llama_index.core.workflow import Context
-from llama_index.llms.google_genai import GoogleGenAI
-
-# -----------------------------------------------------------------------------
-# Context helper tools ---------------------------------------------------------
-# -----------------------------------------------------------------------------
-
-async def write_state(ctx: Context, key: str, value: Any) -> str:
-    state_dict = await ctx.get("state")
-    state_dict[key] = value
-    await ctx.set("state", state_dict)
-    return f"state['{key}'] written"
-
-async def read_state(ctx: Context, key: str) -> Any:
-    state_dict = await ctx.get("state")
-    return state_dict.get(key, "")
-
-write_state_tool = FunctionTool.from_defaults(
-    fn=write_state,
-    name="write_state",
-    description="Store or overwrite a value in the shared workflow state.",
-)
-read_state_tool = FunctionTool.from_defaults(
-    fn=read_state,
-    name="read_state",
-    description="Retrieve a value from the shared workflow state.",
-)
-
-# -----------------------------------------------------------------------------
-# Fresh implementation of answer_question -------------------------------------
-# -----------------------------------------------------------------------------
-
-def answer_question(question: str) -> str:
-    """Return chain‑of‑thought and FINAL ANSWER following strict template."""
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logging.warning("GEMINI_API_KEY not set – returning fallback answer.")
-        return f"Chain of thought: (api key missing)\n\nFINAL ANSWER: {question}"
-
-    meta_prompt = (
-        "You are a professional assistant. Respond with two sections:"\
-        "\n1. Chain of thought: concise reasoning (3–5 sentences)."\
-        "\n2. FINAL ANSWER: the concise answer following these rules:"\
-        "\n   • If numeric, no thousands separators or units unless requested."\
-        "\n   • If text, as few words as possible, no unnecessary articles."\
-        "\n   • If list, comma‑separate applying the above rules."\
-        "\n   • Must start exactly with 'FINAL ANSWER:' (uppercase)."\
-        f"\n\nQuestion: {question}\n\nAnswer:"
-    )
-
-    llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-    return llm.complete(meta_prompt).text.strip()
-
-answer_question_tool = FunctionTool.from_defaults(
-    fn=answer_question,
-    name="answer_question",
-    description="Generate reasoning and emit 'FINAL ANSWER: ...' following the strict format rules.",
-)
-
-# -----------------------------------------------------------------------------
-# System prompt (unchanged) ----------------------------------------------------
-# -----------------------------------------------------------------------------
-
-SYNTHESIS_SYSTEM_PROMPT = r"""
-You are SynthesisAgent, the final composer in a multi‑agent workflow.
-Your goal is to merge validated outputs from specialised agents into a concise
-user‑facing answer.
-
-POTENTIAL STATE KEYS TO CONSULT
---------------------------------
-objective                 – str  (restated user goal)
-plan                      – dict (PlannerAgent JSON plan)
-evidence                  – list[str]  (ResearchAgent facts)
-calculations              – list[dict] (MathAgent results)
-code_outputs              – list[dict] (CodeAgent execution)
-image_analysis            – list[dict] (ImageAnalyzerAgent)
-figure_interpretation     – list[dict] (FigureInterpretationAgent)
-video_analysis            – list[dict] (VideoAnalyzerAgent)
-text_analysis             – list[dict] (TextAnalyzerAgent)
-role_draft                – str       (RoleAgent draft, optional)
-reasoning                 – list[str]  (ReasoningAgent chain‑of‑thought)
-validation                – list[dict] (AdvancedValidationAgent)
-
-WORKFLOW
---------
-1. Read every relevant key. Create a short internal outline.
-2. If contradictions or missing evidence exist, hand off to
-   advanced_validation_agent or research_agent.
-3. Draft a clear, well‑structured answer (<= 200 words or 7 bullet points).
-4. Call the tool `answer_question` with the **user question** to format the
-   final output as required.
-
-STYLE
------
-* Formal but approachable language; no internal state leakage.
-* Cite numeric values plainly; no inline URLs.
-* Prefer paragraph then bullets for details.
-
-HANDOFF POLICY
---------------
-Allowed targets when more work required:
-  • advanced_validation_agent  – contradictions or doubt
-  • research_agent             – missing data
-  • reasoning_agent            – reconcile complex logic
-  • long_context_management_agent – compress oversized context before answer
-  
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.
-"""
-
-# -----------------------------------------------------------------------------
-# Factory ---------------------------------------------------------------------
-# -----------------------------------------------------------------------------
-
-def initialize_synthesis_agent() -> ReActAgent:
-    logger = logging.getLogger(__name__)
-    logger.info("Initialising SynthesisAgent …")
-
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        raise ValueError("GEMINI_API_KEY required for SynthesisAgent")
-
-    llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-
-    agent = ReActAgent(
-        name="synthesis_agent",
-        description=(
-            "Aggregates all validated information, resolves residual issues and "
-            "produces the final user answer via answer_question, adhering to the "
-            "required template."),
-        tools=[write_state_tool, read_state_tool, answer_question_tool],
-        llm=llm,
-        system_prompt=SYNTHESIS_SYSTEM_PROMPT,
-        can_handoff_to=[
-            "advanced_validation_agent",
-            "research_agent",
-            "reasoning_agent",
-            "long_context_management_agent",
-        ],
-    )
-    return agent
-
-# -----------------------------------------------------------------------------
-# Stand‑alone test ------------------------------------------------------------
-# -----------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-    ag = initialize_synthesis_agent()
-    print("SynthesisAgent ready.")

agents/text_analyzer_agent.py

@@ -3,6 +3,7 @@ import certifi
 import logging
 import subprocess # For calling ffmpeg if needed
 from typing import List, Dict, Optional
+from dotenv import load_dotenv
 
 from llama_index.core.agent.workflow import ReActAgent
 from llama_index.core.tools import FunctionTool
@@ -10,6 +11,16 @@ from llama_index.llms.google_genai import GoogleGenAI
 from llama_index.core.node_parser import SentenceSplitter
 from llama_index.core import Document
 
+# Attempt to import Whisper
+try:
+    import whisper
+    WHISPER_AVAILABLE = True
+except ImportError:
+    logging.warning("openai-whisper not installed. Audio transcription tool will be unavailable.")
+    WHISPER_AVAILABLE = False
+
+# Load environment variables
+load_dotenv()
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -36,6 +47,28 @@ def load_prompt_from_file(filename: str, default_prompt: str) -> str:
         logger.error(f"Error loading prompt file {filename}: {e}", exc_info=True)
         return default_prompt
 
+# --- Helper function to load Whisper model ---
+def _load_whisper_model(model_size: str = "small") -> Optional[object]:
+    """Loads the Whisper model instance, lazy loading."""
+    global _whisper_model
+    if not WHISPER_AVAILABLE:
+        logger.error("Whisper library not available, cannot load model.")
+        return None
+        
+    if _whisper_model is None:
+        try:
+            logger.info(f"Loading Whisper model: {model_size}...")
+            # Allow model size selection via env var, default to "base"
+            selected_model_size = os.getenv("WHISPER_MODEL_SIZE", model_size)
+            print(f"Available Whisper models: {whisper.available_models()}")
+            _whisper_model = whisper.load_model(selected_model_size)
+            logger.info(f"Whisper model {selected_model_size} loaded successfully.")
+        except Exception as e:
+            logger.error(f"Failed to load Whisper model {selected_model_size}: {e}", exc_info=True)
+            _whisper_model = None # Ensure it remains None on failure
+            
+    return _whisper_model
+
 # --- Tool Functions ---
 
 def summarize_text(text: str, max_length: int = 150, min_length: int = 30) -> str:
@@ -62,7 +95,7 @@ def summarize_text(text: str, max_length: int = 150, min_length: int = 30) -> st
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=summarizer_llm_model)
         logger.info(f"Using summarization LLM: {summarizer_llm_model}")
         response = llm.complete(prompt)
         summary = response.text.strip()
@@ -155,6 +188,56 @@ def split_text_into_chunks(text: str, chunk_size: int = 1000, chunk_overlap: int
         logger.warning("Falling back to simple text splitting.")
         return [text[i:i + chunk_size] for i in range(0, len(text), chunk_size - chunk_overlap)]
 
+def transcribe_audio(audio_file_path: str, language: Optional[str] = None) -> str:
+    """Transcribes an audio file using the OpenAI Whisper model.
+       Args:
+           audio_file_path (str): The path to the audio file (e.g., mp3, wav, m4a).
+           language (Optional[str]): The language code (e.g., "en", "es") or full name ("English", "Spanish"). 
+                                     If None, Whisper will detect the language.
+       Returns:
+           str: The transcribed text or an error message.
+    """
+    logger.info(f"Attempting to transcribe audio file: {audio_file_path}, Language: {language}")
+    
+    # Check if Whisper is available
+    if not WHISPER_AVAILABLE:
+        return "Error: openai-whisper library is required but not installed."
+        
+    # Check if file exists
+    if not os.path.exists(audio_file_path):
+        logger.error(f"Audio file not found: {audio_file_path}")
+        return f"Error: Audio file not found at {audio_file_path}"
+        
+    # Load the Whisper model (lazy loading)
+    model = _load_whisper_model() # Uses default size "base" or WHISPER_MODEL_SIZE env var
+    if model is None:
+        return "Error: Failed to load Whisper model."
+
+    try:
+        # Perform transcription
+        # The transcribe function handles various audio formats via ffmpeg
+        result = model.transcribe(audio_file_path, language=language)
+        transcribed_text = result["text"]
+        detected_language = result.get("language", "unknown") # Get detected language if available
+        logger.info(f"Audio transcription successful. Detected language: {detected_language}. Text length: {len(transcribed_text)}")
+        return transcribed_text
+        
+    except Exception as e:
+        # Check if it might be an ffmpeg issue
+        if "ffmpeg" in str(e).lower():
+             logger.error(f"Error during transcription, possibly ffmpeg issue: {e}", exc_info=True)
+             # Check if ffmpeg is installed using shell command
+             try:
+                 subprocess.run(["ffmpeg", "-version"], check=True, capture_output=True)
+                 # If ffmpeg is installed, the error is likely something else
+                 return f"Error during transcription (ffmpeg seems installed): {e}"
+             except (FileNotFoundError, subprocess.CalledProcessError):
+                 logger.error("ffmpeg command not found or failed. Please ensure ffmpeg is installed and in PATH.")
+                 return "Error: ffmpeg not found or not working. Please install ffmpeg."
+        else:
+             logger.error(f"Unexpected error during transcription: {e}", exc_info=True)
+             return f"Error during transcription: {e}"
+
 # --- Tool Definitions ---
 summarize_tool = FunctionTool.from_defaults(
     fn=summarize_text,
@@ -183,13 +266,29 @@ split_text_tool = FunctionTool.from_defaults(
     ),
 )
 
+# Conditionally create transcribe_audio_tool
+transcribe_audio_tool = None
+if WHISPER_AVAILABLE:
+    transcribe_audio_tool = FunctionTool.from_defaults(
+        fn=transcribe_audio,
+        name="transcribe_audio_file",
+        description=(
+            "Transcribes speech from an audio file (e.g., mp3, wav, m4a) into text using Whisper. "
+            "Input: audio_file_path (str), Optional: language (str - e.g., \"en\", \"Spanish\"). "
+            "Output: transcribed text (str) or error message."
+        ),
+    )
+    logger.info("Audio transcription tool created.")
+else:
+    logger.warning("Audio transcription tool disabled because openai-whisper is not installed.")
+
 # --- Agent Initialization ---
 def initialize_text_analyzer_agent() -> ReActAgent:
     """Initializes the Text Analyzer Agent."""
     logger.info("Initializing TextAnalyzerAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("TEXT_ANALYZER_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
+    agent_llm_model = os.getenv("TEXT_ANALYZER_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -197,7 +296,7 @@ def initialize_text_analyzer_agent() -> ReActAgent:
         raise ValueError("GEMINI_API_KEY must be set for TextAnalyzerAgent")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
+        llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -209,12 +308,16 @@ def initialize_text_analyzer_agent() -> ReActAgent:
 
         # Define available tools, including the audio tool if available
         tools = [summarize_tool, extract_entities_tool, split_text_tool]
+        if transcribe_audio_tool:
+            tools.append(transcribe_audio_tool)
             
         # Update agent description based on available tools
         agent_description = (
             "Analyzes text content. Can summarize text (`summarize_text`), extract named entities (`extract_entities`), "
             "and split long texts (`split_text_into_chunks`)."
         )
+        if transcribe_audio_tool:
+             agent_description += " Can also transcribe audio files to text (`transcribe_audio_file`)."
 
         agent = ReActAgent(
             name="text_analyzer_agent",
@@ -222,7 +325,7 @@ def initialize_text_analyzer_agent() -> ReActAgent:
             tools=tools,
             llm=llm,
             system_prompt=system_prompt,
-            can_handoff_to=["planner_agent", "research_agent", "reasoning_agent", "verifier_agent", "advanced_validation_agent"], # Example handoffs
+            can_handoff_to=["planner_agent", "research_agent", "reasoning_agent"], # Example handoffs
         )
         logger.info("TextAnalyzerAgent initialized successfully.")
         return agent
@@ -258,6 +361,23 @@ if __name__ == "__main__":
             print("\nTesting text splitting...")
             chunks = split_text_into_chunks(long_text * 3, chunk_size=150, chunk_overlap=30) # Make text longer
             print(f"Split into {len(chunks)} chunks. First chunk:\n{chunks[0]}")
+            
+            # Test audio transcription (if available)
+            if WHISPER_AVAILABLE:
+                print("\nTesting audio transcription...")
+                # Create a dummy audio file for testing (requires ffmpeg)
+                dummy_file = "dummy_audio.mp3"
+                try:
+                    # Generate a 1-second silent MP3 using ffmpeg
+                    subprocess.run(["ffmpeg", "-f", "lavfi", "-i", "anullsrc=r=44100:cl=mono", "-t", "1", "-q:a", "9", "-y", dummy_file], check=True, capture_output=True)
+                    print(f"Created dummy audio file: {dummy_file}")
+                    transcript = transcribe_audio(dummy_file)
+                    print(f"Transcription Result: '{transcript}' (Expected: empty or silence markers)")
+                    os.remove(dummy_file) # Clean up dummy file
+                except Exception as ffmpeg_err:
+                    print(f"Could not create/test dummy audio file (ffmpeg required): {ffmpeg_err}")
+            else:
+                print("\nSkipping audio transcription test as openai-whisper is not available.")
 
             # Initialize the agent (optional)
             # test_agent = initialize_text_analyzer_agent()

agents/verifier_agent.py

@@ -0,0 +1,300 @@
+import os
+import logging
+import re
+from typing import List
+from dotenv import load_dotenv
+
+from llama_index.core.agent.workflow import FunctionAgent, ReActAgent
+from llama_index.core.tools import FunctionTool
+from llama_index.llms.google_genai import GoogleGenAI
+
+# Load environment variables
+load_dotenv()
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+class VerificationError(Exception):
+    """Custom exception for verification failures."""
+    pass
+
+class Verifier:
+    """
+    Cross-check extracted facts, identify contradictions using LLM,
+    and assign a confidence score to each fact.
+    """
+    def __init__(self):
+        """Initializes the Verifier, loading configuration from environment variables."""
+        logger.info("Initializing Verifier...")
+        self.threshold = float(os.getenv("VERIFIER_CONFIDENCE_THRESHOLD", 0.7))
+        self.verifier_llm_model = os.getenv("VERIFIER_LLM_MODEL", "models/gemini-2.0-flash") # For scoring
+        self.agent_llm_model = os.getenv("VERIFIER_AGENT_LLM_MODEL", "models/gemini-1.5-pro") # For agent logic & contradiction
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
+
+        if not self.gemini_api_key:
+            logger.error("GEMINI_API_KEY not found in environment variables.")
+            raise ValueError("GEMINI_API_KEY must be set")
+
+        try:
+            self.verifier_llm = GoogleGenAI(
+                api_key=self.gemini_api_key,
+                model=self.verifier_llm_model,
+            )
+            self.agent_llm = GoogleGenAI(
+                api_key=self.gemini_api_key,
+                model=self.agent_llm_model,
+            )
+            logger.info(f"Verifier initialized with threshold {self.threshold}, verifier LLM {self.verifier_llm_model}, agent LLM {self.agent_llm_model}")
+        except Exception as e:
+            logger.error(f"Error initializing Verifier LLMs: {e}", exc_info=True)
+            raise
+
+    def verify_facts(self, facts: List[str]) -> List[str]:
+        """
+        Assign a confidence score via LLM to each fact and return formatted strings.
+
+        Args:
+            facts (List[str]): Facts to verify.
+
+        Returns:
+            List[str]: Each item is "fact: score" with score ∈ [threshold, 1.0].
+        
+        Raises:
+            VerificationError: If LLM call fails.
+        """
+        logger.info(f"Verifying {len(facts)} facts...")
+        results: List[str] = []
+        for fact in facts:
+            prompt = (
+                "You are a fact verifier. "
+                "On a scale from 0.00 to 1.00, where any value below "
+                f"{self.threshold:.2f} indicates low confidence, rate the following statement’s trustworthiness. "
+                "Respond with **only** a decimal number rounded to two digits (e.g., 0.82) and no extra text.\n\n"
+                f"Statement: \"{fact}\""
+            )
+            try:
+                response = self.verifier_llm.complete(prompt)
+                score_text = response.text.strip()
+                # Try direct conversion first
+                try:
+                    score = float(score_text)
+                except ValueError:
+                    # Fallback: extract first float if model returns extra text
+                    match = re.search(r"0?\.\d+|1(?:\.0+)?", score_text)
+                    if match:
+                        score = float(match.group(0))
+                        logger.warning(f"Extracted score {score} from noisy LLM response: {score_text}")
+                    else:
+                        logger.error(f"Could not parse score from LLM response: {score_text}. Using threshold {self.threshold}.")
+                        score = self.threshold # Fallback to threshold if parsing fails completely
+
+                # Enforce threshold floor
+                if score < self.threshold:
+                    logger.info(f"Score {score:.2f} for fact {fact} below threshold {self.threshold}, raising to threshold.")
+                    score = self.threshold
+                
+                results.append(f"{fact}: {score:.2f}")
+
+            except Exception as e:
+                logger.error(f"LLM call failed during fact verification for {fact}: {e}", exc_info=True)
+                # Option 1: Raise an error
+                # raise VerificationError(f"LLM call failed for fact: {fact}") from e
+                # Option 2: Append an error message (current approach)
+                results.append(f"{fact}: ERROR - Verification failed")
+                # Option 3: Assign lowest score
+                # results.append(f"{fact}: {self.threshold:.2f} (Verification Error)")
+                
+        logger.info(f"Fact verification complete. {len(results)} results generated.")
+        return results
+
+    def find_contradictions_llm(self, facts: List[str]) -> List[str]:
+        """
+        Identify contradictions among a list of facts using an LLM.
+
+        Args:
+            facts (List[str]): List of fact strings.
+
+        Returns:
+            List[str]: Pairs of facts detected as contradictory, joined by " <> ".
+        
+        Raises:
+            VerificationError: If LLM call fails.
+        """
+        logger.info(f"Finding contradictions in {len(facts)} facts using LLM...")
+        if len(facts) < 2:
+            logger.info("Not enough facts to find contradictions.")
+            return []
+
+        facts_numbered = "\n".join([f"{i+1}. {fact}" for i, fact in enumerate(facts)])
+        
+        prompt = (
+            "You are a logical reasoning assistant. Analyze the following numbered list of statements. "
+            "Identify any pairs of statements that directly contradict each other. "
+            "List *only* the numbers of the contradicting pairs, one pair per line, formatted as 'X, Y'. "
+            "If no contradictions are found, respond with 'None'. Do not include any other text or explanation.\n\n"
+            f"Statements:\n{facts_numbered}"
+        )
+
+        try:
+            response = self.agent_llm.complete(prompt) # Use the more powerful agent LLM
+            response_text = response.text.strip()
+            logger.info(f"LLM response for contradictions: {response_text}")
+
+            if response_text.lower() == 'none':
+                logger.info("LLM reported no contradictions.")
+                return []
+
+            contradiction_pairs = []
+            lines = response_text.split("\n")
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    # Expect format like "1, 5"
+                    parts = line.split(',')
+                    if len(parts) == 2:
+                        idx1 = int(parts[0].strip()) - 1
+                        idx2 = int(parts[1].strip()) - 1
+                        
+                        # Validate indices
+                        if 0 <= idx1 < len(facts) and 0 <= idx2 < len(facts) and idx1 != idx2:
+                            # Ensure pair order doesn't matter and avoid duplicates
+                            pair = tuple(sorted((idx1, idx2)))
+                            fact1 = facts[pair[0]]
+                            fact2 = facts[pair[1]]
+                            contradiction_str = f"{fact1} <> {fact2}"
+                            if contradiction_str not in contradiction_pairs:
+                                contradiction_pairs.append(contradiction_str)
+                                logger.info(f"Identified contradiction: {contradiction_str}")
+                        else:
+                             logger.warning(f"Invalid index pair found in LLM contradiction response: {line}")
+                    else:
+                        logger.warning(f"Could not parse contradiction pair from LLM response line: {line}")
+                except ValueError:
+                    logger.warning(f"Non-integer index found in LLM contradiction response line: {line}")
+                except Exception as parse_err:
+                     logger.warning(f"Error parsing LLM contradiction response line {line}: {parse_err}")
+            
+            logger.info(f"Contradiction check complete. Found {len(contradiction_pairs)} pairs.")
+            return contradiction_pairs
+
+        except Exception as e:
+            logger.error(f"LLM call failed during contradiction detection: {e}", exc_info=True)
+            # Option 1: Raise an error
+            raise VerificationError("LLM call failed during contradiction detection") from e
+            # Option 2: Return empty list (fail silently)
+            # return []
+
+# --- Tool Definitions --- 
+# Tools need to be created within the initialization function to bind to the instance
+
+# --- Agent Initialization --- 
+
+# Store the initializer instance globally to ensure singleton behavior
+_verifier_initializer_instance = None
+
+class VerifierInitializer:
+    def __init__(self):
+        self.verifier = Verifier() # Initialize the Verifier class
+        self._create_tools()
+
+    def _create_tools(self):
+        self.verify_facts_tool = FunctionTool.from_defaults(
+            fn=self.verifier.verify_facts, # Bind to instance method
+            name="verify_facts",
+            description=(
+                "Assigns a numerical confidence score (based on plausibility and internal consistency) to each factual assertion in a list. "
+                "Input: List[str] of statements. Output: List[str] of 'statement: score' pairs."
+            ),
+        )
+
+        self.find_contradictions_tool = FunctionTool.from_defaults(
+            fn=self.verifier.find_contradictions_llm, # Bind to instance method (using LLM version)
+            name="find_contradictions",
+            description=(
+                "Uses an LLM to detect logical contradictions among a list of statements. "
+                "Input: List[str] of factual assertions. "
+                "Output: List[str] where each entry is a conflicting pair in the format 'statement1 <> statement2'. Returns empty list if none found."
+            )
+        )
+
+    def get_agent(self) -> FunctionAgent:
+        """Initializes and returns the Verifier Agent."""
+        logger.info("Creating VerifierAgent FunctionAgent instance...")
+        
+        # System prompt (consider loading from file)
+        system_prompt = """\
+        You are VerifierAgent, a fact verification assistant. Given a list of factual statements, you must:
+        
+        1. **Verify Facts**: Call `verify_facts` to assign a confidence score to each statement.
+        2. **Detect Contradictions**: Call `find_contradictions` to identify logical conflicts between the statements using an LLM.
+        3. **Present Results**: Output clear bullet points listing each fact with its confidence score, followed by a list of any detected contradictions.
+        4. **Hand-Off**: If significant contradictions or low-confidence facts are found that require deeper analysis, hand off to **reasoning_agent**. Otherwise, pass the verified facts and contradiction summary to **planner_agent** for integration.
+        """
+
+        agent = FunctionAgent(
+            name="verifier_agent",
+            description=(
+                "Evaluates factual statements by assigning confidence scores (`verify_facts`) "
+                "and detecting logical contradictions using an LLM (`find_contradictions`). "
+                "Hands off to reasoning_agent for complex issues or planner_agent for synthesis."
+            ),
+            tools=[
+                self.verify_facts_tool,
+                self.find_contradictions_tool,
+            ],
+            llm=self.verifier.agent_llm, # Use the agent LLM from the Verifier instance
+            system_prompt=system_prompt,
+            can_handoff_to=["reasoning_agent", "planner_agent"],
+        )
+        logger.info("VerifierAgent FunctionAgent instance created.")
+        return agent
+
+def get_verifier_initializer():
+    """Gets the singleton instance of VerifierInitializer."""
+    global _verifier_initializer_instance
+    if _verifier_initializer_instance is None:
+        logger.info("Instantiating VerifierInitializer for the first time.")
+        _verifier_initializer_instance = VerifierInitializer()
+    return _verifier_initializer_instance
+
+def initialize_verifier_agent() -> FunctionAgent:
+    """Initializes and returns the Verifier Agent using a singleton initializer."""
+    logger.info("initialize_verifier_agent called.")
+    initializer = get_verifier_initializer()
+    return initializer.get_agent()
+
+# Example usage (for testing if run directly)
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger.info("Running verifier_agent.py directly for testing...")
+
+    # Ensure API key is set for testing
+    if not os.getenv("GEMINI_API_KEY"):
+        print("Error: GEMINI_API_KEY environment variable not set. Cannot run test.")
+    else:
+        try:
+            test_agent = initialize_verifier_agent()
+            print("Verifier Agent initialized successfully for testing.")
+            
+            # Test contradiction detection
+            initializer = get_verifier_initializer()
+            test_facts = [
+                "The sky is blue.",
+                "Water boils at 100 degrees Celsius.",
+                "The sky is not blue.",
+                "Paris is the capital of France."
+            ]
+            print(f"\nTesting contradiction detection on: {test_facts}")
+            contradictions = initializer.verifier.find_contradictions_llm(test_facts)
+            print(f"Detected contradictions: {contradictions}")
+
+            # Test fact verification
+            print(f"\nTesting fact verification on: {test_facts}")
+            verified = initializer.verifier.verify_facts(test_facts)
+            print(f"Verified facts: {verified}")
+
+        except Exception as e:
+            print(f"Error during testing: {e}")
+

agents/video_analyzer_agent.py

@@ -1,465 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import re
-import shutil
-from pathlib import Path
-from typing import Optional, List
-
-import cv2
-import yt_dlp
-from llama_index.core.agent.workflow import FunctionAgent
-from llama_index.core.base.llms.types import TextBlock, ImageBlock, ChatMessage
-from llama_index.core.tools import FunctionTool
-from llama_index.llms.google_genai import GoogleGenAI
-from tqdm import tqdm
-from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-
-# ---------------------------------------------------------------------------
-# Environment setup & logging
-# ---------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-def env_to_cookies(env_content: str, output_file: str) -> None:
-    """Convert environment variable content back to cookie file"""
-    try:
-        # Extract content from env format
-        if '="' not in env_content:
-            raise ValueError("Invalid env content format")
-
-        content = env_content.split('="', 1)[1].strip('"')
-
-        # Replace escaped newlines with actual newlines
-        cookie_content = content.replace('\\n', '\n')
-
-        # Write to cookie file
-        with open(output_file, 'w') as f:
-            f.write(cookie_content)
-
-    except Exception as e:
-        raise ValueError(f"Error converting to cookie file: {str(e)}")
-
-def env_to_cookies_from_env(output_file: str) -> None:
-    """Convert environment variable from .env file to cookie file"""
-    try:
-        env_content = os.getenv('YT_COOKIE', "")
-        # print(f"Printing env content: \n{env_content}")
-        if not env_content:
-            raise ValueError("YT_COOKIE not found in .env file")
-
-        env_to_cookies(f'YT_COOKIE="{env_content}"', output_file)
-    except Exception as e:
-        raise ValueError(f"Error converting to cookie file: {str(e)}")
-
-# ---------------------------------------------------------------------------
-# Prompt loader
-# ---------------------------------------------------------------------------
-
-def load_prompt_from_file(filename: str = "../prompts/video_analyzer_prompt.txt") -> str:
-    """Load the system prompt for video analysis from *filename*.
-
-    Falls back to a minimal prompt if the file cannot be read.
-    """
-    script_dir = Path(__file__).parent
-    prompt_path = (script_dir / filename).resolve()
-
-    try:
-        with prompt_path.open("r", encoding="utf-8") as fp:
-            prompt = fp.read()
-            logger.info("Successfully loaded system prompt from %s", prompt_path)
-            return prompt
-    except FileNotFoundError:
-        logger.error(
-            "Prompt file %s not found. Using fallback prompt.", prompt_path
-        )
-    except Exception as exc:  # pylint: disable=broad-except
-        logger.error(
-            "Error loading prompt file %s: %s", prompt_path, exc, exc_info=True
-        )
-
-    # Fallback – keep it extremely short to save tokens
-    return (
-        "You are a video analyzer. Provide a factual, chronological "
-        "description of the video, identify key events, and summarise insights."
-    )
-
-
-def extract_frames(video_path, output_dir, fps=2):
-    """
-    Extract frames from video at specified FPS
-    Returns a list of (frame_path, timestamp) tuples
-    """
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Open video
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        print(f"Error: Could not open video {video_path}")
-        return [], None
-
-    # Get video properties
-    video_fps = cap.get(cv2.CAP_PROP_FPS)
-    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    duration = frame_count / video_fps
-
-    # Calculate frame interval
-    interval = int(video_fps / fps)
-    if interval < 1:
-        interval = 1
-
-    # Extract frames
-    frames = []
-    frame_idx = 0
-
-    with tqdm(total=frame_count, desc="Extracting frames") as pbar:
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            if frame_idx % interval == 0:
-                timestamp = frame_idx / video_fps
-                frame_path = os.path.join(output_dir, f"frame_{frame_idx:06d}.jpg")
-                cv2.imwrite(frame_path, frame)
-                frames.append((frame_path, timestamp))
-
-            frame_idx += 1
-            pbar.update(1)
-
-    cap.release()
-    return frames, duration
-
-
-def download_video_and_analyze(video_url: str) -> str:
-    """Download a video from *video_url* and return the local file path."""
-    llm_model_name = os.getenv("VIDEO_ANALYZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-
-    ydl_opts = {
-        'format': 'best',
-        'outtmpl': os.path.join("downloaded_videos", 'temp_video.%(ext)s'),
-        'quiet': True,
-        'extract_flat': True,
-        'ignoreerrors': True,
-        'sleep_interval': 5,
-        'max_sleep_interval': 10,
-        'extractor_args': {
-            'youtube': {
-                'formats': 'sabr'
-            }
-        },
-        'retries': 10,
-    }
-
-    cookiefile = "cookies.txt"
-    # env_to_cookies_from_env(cookiefile)
-
-    # Add cookies
-    ydl_opts["cookiefile"] = cookiefile  # create_temp_cookie_file()
-
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl_download:
-        ydl_download.download(video_url)
-
-        print(f"Processing video: {video_url}")
-
-        # Create temporary directory for frames
-        temp_dir = "frame_downloaded_videos"
-        os.makedirs(temp_dir, exist_ok=True)
-
-        # Extract frames
-        frames, duration = extract_frames(os.path.join("downloaded_videos", 'temp_video.mp4'), temp_dir)
-        if not frames:
-            logging.info(f"No frames extracted from {video_url}")
-            return f"No frames extracted from {video_url}"
-
-        blocks = []
-        text_block = TextBlock(text=load_prompt_from_file())
-        blocks.append(text_block)
-
-        for frame_path, timestamp in tqdm(frames, desc="Collecting frames"):
-            blocks.append(ImageBlock(path=frame_path))
-
-
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-        logger.info("Using LLM model: %s", llm_model_name)
-        response = llm.chat([ChatMessage(role="user", blocks=blocks)])
-
-        # Clean up temporary files
-        shutil.rmtree(temp_dir)
-        os.remove(os.path.join("downloaded_videos", 'temp_video.mp4'))
-
-        return response.message.content
-
-
-# --- Helper function to extract YouTube Video ID ---
-def extract_video_id(url: str) -> Optional[str]:
-    """Extracts the YouTube video ID from various URL formats."""
-    # Standard watch URL: https://www.youtube.com/watch?v=VIDEO_ID
-    pattern = re.compile(
-        r'^(?:https?://)?'  # protocole optionnel
-        r'(?:www\.)?'  # sous-domaine optionnel
-        r'youtube\.com/watch\?'  # domaine et chemin fixe
-        r'(?:.*&)?'  # éventuellement d'autres paramètres avant v=
-        r'v=([^&]+)'  # capture de l'ID (tout jusqu'au prochain & ou fin)
-    )
-
-    match = pattern.search(url)
-    if match:
-        video_id = match.group(1)
-        print(f"ID trouvé : {video_id}")
-        return video_id  # affiche "VIDEO_ID"
-    else:
-        print("Aucun ID trouvé")
-        return url
-
-
-# --- YouTube Transcript Tool ---
-def get_youtube_transcript(video_url_or_id: str, languages: List[str] | None = None) -> str:
-    """Fetches the transcript for a YouTube video using its URL or video ID.
-       Specify preferred languages as a list (e.g., ["en", "es"]).
-       Returns the transcript text or an error message.
-    """
-    if languages is None:
-        languages = ["en"]
-
-    logger.info(f"Attempting to fetch YouTube transcript for: {video_url_or_id}")
-    video_id = extract_video_id(video_url_or_id)
-    if video_id is None or not video_id:
-        logger.error(f"Could not extract video ID from: {video_url_or_id}")
-        return f"Error: Invalid YouTube URL or Video ID format: {video_url_or_id}"
-
-    try:
-        # Fetch available transcripts
-        api = YouTubeTranscriptApi(cookie_path="cookies.txt")
-        transcript_list = api.list(video_id)
-
-        # Try to find a transcript in the specified languages
-        transcript = transcript_list.find_transcript(languages)
-
-        # Fetch the actual transcript data (list of dicts)
-        transcript_data = transcript.fetch()
-
-        # Combine the text parts into a single string
-        full_transcript = " ".join(snippet.text for snippet in transcript_data)
-
-        full_transcript = " ".join(snippet.text for snippet in transcript_data)
-        logger.info(f"Successfully fetched transcript for video ID {video_id} in language {transcript.language}.")
-        return full_transcript
-
-    except TranscriptsDisabled:
-        logger.warning(f"Transcripts are disabled for video ID: {video_id}")
-        return f"Error: Transcripts are disabled for this video (ID: {video_id})."
-    except NoTranscriptFound as e:
-        logger.warning(
-            f"No transcript found for video ID {video_id} in languages {languages}. Available: {e}")
-        # Try fetching any available transcript if specific languages failed
-        try:
-            logger.info(f"Attempting to fetch any available transcript for {video_id}")
-            any_transcript = transcript_list.find_generated_transcript(["en"])
-            any_transcript_data = any_transcript.fetch()
-            full_transcript = " ".join([item["text"] for item in any_transcript_data])
-            logger.info(
-                f"Successfully fetched fallback transcript for video ID {video_id} in language {any_transcript.language}.")
-            return full_transcript
-        except Exception as fallback_e:
-            logger.error(
-                f"Could not find any transcript for video ID {video_id}. Original error: {e}. Fallback error: {fallback_e}")
-            return f"Error: No transcript found for video ID {video_id} in languages {languages} or any fallback language."
-    except Exception as e:
-        logger.error(f"Unexpected error fetching transcript for video ID {video_id}: {e}", exc_info=True)
-        return f"Error fetching transcript: {e}"
-
-
-download_video_and_analyze_tool = FunctionTool.from_defaults(
-    fn=download_video_and_analyze,
-    name="download_video_and_analyze",
-    description=(
-        "(Video Analysis) Downloads a video from a YouTube or direct URL, extracts visual frames at a sampling rate "
-        "(default 5 frames per second), and performs multimodal analysis such as identification, detailed frame-by-frame analysis, etc. using Gemini. "
-        "Returns a textual summary based exclusively on visual content.\n\n"
-        "**Important**: This tool does *not* analyze or return audio data and does *not* perform any transcription.\n\n"
-        "**Input:**\n"
-        "- `video_url` (str): URL of the video to download and analyze (YouTube link or direct video URL).\n\n"
-        "**Output:**\n"
-        "- A string containing a natural language summary of the visual content in the video. "
-        "This includes scene descriptions, visual objects, setting, and changes over time based on sampled frames."
-    )
-)
-
-youtube_transcript_tool = FunctionTool.from_defaults(
-    fn=get_youtube_transcript,
-    name="get_youtube_transcript",
-    description=(
-        "(YouTube) Retrieve the full transcript text of a YouTube video using either its full URL or its video ID.\n\n"
-        "**Functionality**:\n"
-        "- Attempts to extract the video ID from the URL.\n"
-        "- Searches for available transcripts (manual or auto-generated).\n"
-        "- Returns the complete transcript text in a single string.\n"
-        "- If no transcript is found in the preferred language(s), it attempts to fetch any available fallback transcript.\n\n"
-        "**Inputs:**\n"
-        "- `video_url_or_id` (str): The full YouTube video URL (e.g., 'https://www.youtube.com/watch?v=abc123') or the video ID directly (e.g., 'abc123').\n"
-        "- `languages` (str or None): Optional. A preferred language code (e.g., 'en', 'fr'). If None, defaults to 'en'.\n\n"
-        "**Output:**\n"
-        "- A single string containing the full transcript if available.\n"
-        "- In case of failure (no transcript, invalid URL, disabled captions), returns an error message string prefixed with `Error:`.\n\n"
-        "**Limitations:**\n"
-        "- This tool **does not** download or process video or audio.\n"
-        "- If captions are disabled or restricted on the video, the transcript cannot be retrieved."
-    )
-)
-
-
-# ---------------------------------------------------------------------------
-# Agent factory
-# ---------------------------------------------------------------------------
-
-def initialize_video_analyzer_agent() -> FunctionAgent:
-    """Initialise and return a *video_analyzer_agent* `FunctionAgent`."""
-
-    logger.info("Initialising VideoAnalyzerAgent …")
-
-    llm_model_name = os.getenv("VIDEO_ANALYZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-
-    if not gemini_api_key:
-        logger.error("GEMINI_API_KEY not found in environment variables.")
-        raise ValueError("GEMINI_API_KEY must be set")
-
-    try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05)
-        logger.info("Using LLM model: %s", llm_model_name)
-
-        system_prompt = """
-        You are **VideoAnalyzerAgent**, an expert multimodal analyst specialised in factual,
-        frame‑level understanding of video.
-        
-        ─────────────────
-        CORE PRINCIPLES
-        ─────────────────
-        1. **Visual‑only reasoning** – base every statement on what can be seen in the
-           provided frames; never guess at sounds, music, or dialogue.
-        2. **Chronological accuracy** – describe events strictly in the order they occur.
-        3. **Sceptical precision** – if something is ambiguous on screen, say so plainly
-           (“unclear whether …”); do not invent motives or unseen causes.
-        4. **Token economy** – be concise; omit pleasantries and waffle.
-        5. **Professional tone** – formal, neutral, and practical.
-        
-        ─────────────────
-        TOOLS AT YOUR DISPOSAL
-        ─────────────────
-        • `download_video_and_analyze(video_url)` –  
-        Downloads the video, samples ~2fps, and returns your own multimodal summary  
-        of the visuals such as detailed frame-by-frame analysis, key insights, or a TL;DR.  
-        Use when the user needs a purely visual description.
-        
-        • `get_youtube_transcript(video_url_or_id, languages="en")` –  
-        Returns the full YouTube transcript (if any).  
-        Use when the user requests spoken content or captions.
-        
-        Always think aloud (in hidden chain‑of‑thought) which tool(s) you need **before**
-        calling them. If neither tool is relevant, politely explain why.
-        
-        ─────────────────
-        RESPONSE FORMAT
-        ─────────────────
-        Return Markdown with the following sections **only when they add value**:
-        
-        1. **TL;DR (≤3 sentences)** – executive summary.
-        2. **Timeline** – table listing `timestamp → scene description → notable objects/actions`.
-        3. **Key Insights** – bullet points of patterns, cause–effect, or anomalies worth noting.
-        4. **Actionable Take‑aways** – optional, only if user asked “so what?” questions.
-        
-        Timestamps should be in **mm:ss** (or h:mm:ss if >1h).  
-        Avoid more than one level of heading depth (i.e., use `##`, not `###`/`####`).
-        
-        ─────────────────
-        STYLE & CONSTRAINTS
-        ─────────────────
-        • Use present tense for on‑screen events (“The camera pans over …”).  
-        • Quantify when possible (“The audience consists of ~200 peoples” “text occupies ~25% of the frame”).  
-        • Never reveal chain‑of‑thought or raw frame data.  
-        • If no visual frames were extracted, state: “No usable frames – cannot analyse.”  
-        • If captions are disabled, reply: “No transcript available.”
-        
-        ─────────────────
-        EXAMPLES OF ACCEPTABLE BREVITY
-        ─────────────────
-        - Good: “At 02:15 the speaker shows a slide titled ‘Transformer Architecture’.”  
-        - Bad:  “There is some sort of diagram that maybe explains something about the
-                 architecture; it might be a transformer but it is hard to tell.”
-                 
-        If your response exceeds the maximum token limit and cannot be completed in a single reply, 
-        please conclude your output with the marker [CONTINUE]. In subsequent interactions, 
-        I will prompt you with “continue” to receive the next portion of the response.
-        
-        End of prompt.
-        """
-
-        tools = [download_video_and_analyze_tool, youtube_transcript_tool]
-
-        agent = FunctionAgent(
-            name="video_analyzer_agent",
-            description=(
-                "VideoAnalyzerAgent is a domain-specialist in multimodal video understanding, "
-                "leveraging Gemini’s vision capabilities to deliver precise, frame-level analyses. "
-                "It performs chronological segmentation of visual events, identifies key objects "
-                "and actions, and generates concise executive summaries—all based solely on visual data. "
-                "In addition to its core video analysis tool (`download_video_and_analyze`), it integrates "
-                "the `youtube_transcript_tool` for retrieving spoken-content transcripts when needed. "
-                "Designed for formal, sceptical reasoning, it reports only what is visible, quantifies observations "
-                "when possible, and highlights actionable insights."
-            ),
-            llm=llm,
-            system_prompt=system_prompt,
-            tools=tools,
-            can_handoff_to=[
-                "planner_agent",
-                "research_agent",
-                "reasoning_agent",
-                "code_agent",
-            ],
-        )
-
-        logger.info("VideoAnalyzerAgent initialised successfully.")
-        return agent
-
-    except Exception as exc:  # pylint: disable=broad-except
-        logger.error("Error during VideoAnalyzerAgent initialisation: %s", exc, exc_info=True)
-        raise
-
-
-if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    )
-
-    logger.info("Running video_analyzer_agent.py directly for testing …")
-
-    if not os.getenv("GEMINI_API_KEY"):
-        print("Error: GEMINI_API_KEY environment variable not set. Cannot run test.")
-    else:
-        try:
-            test_agent = initialize_video_analyzer_agent()
-            summary = download_video_and_analyze("https://www.youtube.com/watch?v=dQw4w9WgXcQ")
-            print("\n--- Gemini summary ---\n")
-            print(summary)
-            print("Video Analyzer Agent initialised successfully for testing.")
-        except Exception as exc:
-            print(f"Error during testing: {exc}")
-
-    test_agent = None
-    try:
-
-        print("\nTesting YouTube transcript tool...")
-        # Example video: "Attention is All You Need" paper explanation
-        yt_url = "https://www.youtube.com/watch?v=TQQlZhbC5ps"
-        transcript = get_youtube_transcript(yt_url)
-        if not transcript.startswith("Error:"):
-            print(f"Transcript fetched (first 500 chars):\n{transcript[:500]}...")
-        else:
-            print(f"YouTube Transcript Fetch Failed: {transcript}")
-    except Exception as e:
-        print(f"Error during testing: {e}")

app.py

@@ -1,25 +1,16 @@
 import os
 import logging
 import mimetypes
-import subprocess
+from dotenv import load_dotenv
 
 from typing import Any, List
 
 import gradio as gr
 import requests
 import pandas as pd
-import io
-import torchaudio
-import torchaudio.transforms as T
-import whisper
 
 from llama_index.core.agent.workflow import AgentWorkflow, ToolCallResult, ToolCall, AgentOutput
 from llama_index.core.base.llms.types import ChatMessage, TextBlock, ImageBlock, AudioBlock
-from llama_index.llms.openai import OpenAI
-
-from agents.video_analyzer_agent import initialize_video_analyzer_agent
-
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
 # Assuming agent initializers are in the same directory or a known path
 # Adjust import paths if necessary based on deployment structure
@@ -33,17 +24,37 @@ try:
     from agents.planner_agent import initialize_planner_agent
     from agents.research_agent import initialize_research_agent
     from agents.role_agent import initialize_role_agent
+    from agents.verifier_agent import initialize_verifier_agent
     # New agents
     from agents.advanced_validation_agent import initialize_advanced_validation_agent
+    from agents.figure_interpretation_agent import initialize_figure_interpretation_agent
     from agents.long_context_management_agent import initialize_long_context_management_agent
-    from agents.synthesis_agent import initialize_synthesis_agent
     AGENT_IMPORT_PATH = "local"
 except ImportError as e:
-    print(f"Import Error: Could not find agent modules. Tried local and final_project paths. Error: {e}")
-    # Set initializers to None or raise error to prevent app start
-    initialize_image_analyzer_agent = None
-    # ... set all others to None ...
-    raise RuntimeError(f"Failed to import agent modules: {e}")
+    # Fallback for potential different structures (e.g., nested folder)
+    try:
+        from final_project.image_analyzer_agent import initialize_image_analyzer_agent
+        from final_project.reasoning_agent import initialize_reasoning_agent
+        from final_project.text_analyzer_agent import initialize_text_analyzer_agent
+        from final_project.code_agent import initialize_code_agent
+        from final_project.math_agent import initialize_math_agent
+        from final_project.planner_agent import initialize_planner_agent
+        from final_project.research_agent import initialize_research_agent
+        from final_project.role_agent import initialize_role_agent
+        from final_project.verifier_agent import initialize_verifier_agent
+        from final_project.advanced_validation_agent import initialize_advanced_validation_agent
+        from final_project.figure_interpretation_agent import initialize_figure_interpretation_agent
+        from final_project.long_context_management_agent import initialize_long_context_management_agent
+        AGENT_IMPORT_PATH = "final_project"
+    except ImportError as e2:
+        print(f"Import Error: Could not find agent modules. Tried local and final_project paths. Error: {e2}")
+        # Set initializers to None or raise error to prevent app start
+        initialize_image_analyzer_agent = None
+        # ... set all others to None ...
+        raise RuntimeError(f"Failed to import agent modules: {e2}")
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+load_dotenv() # Load environment variables from .env file
 
 # Setup logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -52,93 +63,38 @@ logger = logging.getLogger(__name__)
 # --- Constants ---
 DEFAULT_API_URL = os.getenv("GAIA_API_URL", "https://agents-course-unit4-scoring.hf.space")
 
-# --- Helper Functions ---
-_whisper_model = whisper.load_model("small")
-
-def transcribe_audio(audio_bytes: bytes) -> str:
-    logger.info(f"Attempting to transcribe audio file")
-
-    file_like = io.BytesIO(audio_bytes)
-
-    waveform, sample_rate = torchaudio.load(file_like)
-
-    waveform = waveform.mean(dim=0, keepdim=True)  # [1, samples]
-
-    if sample_rate != 16000:
-        resampler = T.Resample(orig_freq=sample_rate, new_freq=16000)
-        waveform = resampler(waveform)
-
-    waveform = waveform.squeeze(0)
-
-    print(f"Tensor shape : {waveform.shape}, Frequency : {sample_rate} Hz")
-
-    # Load the Whisper model (lazy loading)
-    model: whisper.Whisper = _whisper_model  # Uses default size "base" or WHISPER_MODEL_SIZE env var
-    if model is None:
-        return "Error: Failed to load Whisper model."
-
-    try:
-        # Perform transcription
-        # The transcribe function handles various audio formats via ffmpeg
-        result = whisper.transcribe(model=model, audio=waveform)
-        transcribed_text = result["text"]
-        detected_language = result.get("language", "unknown")  # Get detected language if available
-        logger.info(
-            f"Audio transcription successful. Detected language: {detected_language}. Text length: {len(transcribed_text)}")
-        return transcribed_text
-
-    except Exception as e:
-        # Check if it might be an ffmpeg issue
-        if "ffmpeg" in str(e).lower():
-            logger.error(f"Error during transcription, possibly ffmpeg issue: {e}", exc_info=True)
-            # Check if ffmpeg is installed using shell command
-            try:
-                subprocess.run(["ffmpeg", "-version"], check=True, capture_output=True)
-                # If ffmpeg is installed, the error is likely something else
-                return f"Error during transcription (ffmpeg seems installed): {e}"
-            except (FileNotFoundError, subprocess.CalledProcessError):
-                logger.error("ffmpeg command not found or failed. Please ensure ffmpeg is installed and in PATH.")
-                return "Error: ffmpeg not found or not working. Please install ffmpeg."
-        else:
-            logger.error(f"Unexpected error during transcription: {e}", exc_info=True)
-            return f"Error during transcription: {e}"
-
 # --- Agent Initialization (Singleton Pattern) ---
 # Initialize the agent workflow once
 AGENT_WORKFLOW = None
 try:
     logger.info(f"Initializing GAIA Multi-Agent Workflow (import path: {AGENT_IMPORT_PATH})...")
     # Existing agents
-    # role_agent = initialize_role_agent()
+    role_agent = initialize_role_agent()
     code_agent = initialize_code_agent()
     math_agent = initialize_math_agent()
     planner_agent = initialize_planner_agent()
     research_agent = initialize_research_agent()
     text_analyzer_agent = initialize_text_analyzer_agent()
+    verifier_agent = initialize_verifier_agent()
     image_analyzer_agent = initialize_image_analyzer_agent()
     reasoning_agent = initialize_reasoning_agent()
     # New agents
     advanced_validation_agent = initialize_advanced_validation_agent()
+    figure_interpretation_agent = initialize_figure_interpretation_agent()
     long_context_management_agent = initialize_long_context_management_agent()
-    video_analyzer_agent = initialize_video_analyzer_agent()
-    synthesis_agent = initialize_synthesis_agent()
 
     # Check if all agents initialized successfully
     all_agents = [
-        code_agent, math_agent, planner_agent, research_agent,
-        text_analyzer_agent, image_analyzer_agent, reasoning_agent,
-        advanced_validation_agent, long_context_management_agent,
-        video_analyzer_agent, synthesis_agent
+        code_agent, role_agent, math_agent, planner_agent, research_agent,
+        text_analyzer_agent, image_analyzer_agent, verifier_agent, reasoning_agent,
+        advanced_validation_agent, figure_interpretation_agent, long_context_management_agent
     ]
     if not all(all_agents):
         raise RuntimeError("One or more agents failed to initialize.")
 
     AGENT_WORKFLOW = AgentWorkflow(
         agents=all_agents,
-        root_agent="reasoning_agent", # Keep planner as root as per plan
-        initial_state={
-            "research_content": []
-        }
+        root_agent="planner_agent" # Keep planner as root as per plan
     )
     logger.info("GAIA Multi-Agent Workflow initialized successfully.")
 except Exception as e:
@@ -170,8 +126,7 @@ class BasicAgent:
                     and event.current_agent_name != current_agent
             ):
                 current_agent = event.current_agent_name
-                logger.info(f"{'=' * 50}")
-                logger.info(f"🤖 Agent: {current_agent}")
+                logger.info(f"{'=' * 50}\n")
                 logger.info(f"{'=' * 50}\n")
 
             # Optional detailed logging (uncomment if needed)
@@ -203,20 +158,6 @@ class BasicAgent:
         logger.info(f"Agent returning final answer: {final_content[:500]}{'...' if len(final_content) > 500 else ''}")
         return answer.response # Return the actual response object expected by Gradio
 
-system_prompt = """
-You are a general AI assistant. 
-I will give you a result, and with it you will have to transform it to follow the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. 
-YOUR FINAL ANSWER should be a number OR 1 or 2 word(s) 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.
-If the result is enclosed in double quotes (""), extract and return only what is inside the quotes, applying the formatting rules if needed.
-
-You must never return a full sentence as the final answer. A sentence is strictly forbidden under all circumstances.
-"""
-
-llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"), temperature=0.05, system_prompt=system_prompt)
-
 # --- Helper Functions for run_and_submit_all ---
 
 async def fetch_questions(questions_url: str) -> List[dict] | None:
@@ -266,7 +207,7 @@ async def process_question(agent: BasicAgent, item: dict, base_fetch_file_url: s
             if mime_type:
                 # Prioritize specific extensions for text-like content
                 text_extensions = (
-                    ".txt", ".json", ".xml", ".yaml", ".yml", ".ini", ".cfg", ".toml", ".log", ".properties",
+                    ".txt", ".csv", ".json", ".xml", ".yaml", ".yml", ".ini", ".cfg", ".toml", ".log", ".properties",
                     ".html", ".htm", ".xhtml", ".css", ".scss", ".sass", ".less", ".svg", ".md", ".rst",
                     ".py", ".js", ".java", ".c", ".cpp", ".h", ".hpp", ".cs", ".go", ".php", ".rb", ".swift", ".kt",
                     ".sh", ".bat", ".ipynb", ".Rmd", ".tex"  # Added more code/markup types
@@ -281,22 +222,17 @@ async def process_question(agent: BasicAgent, item: dict, base_fetch_file_url: s
                         except Exception as decode_err:
                             logger.error(f"Could not decode file {file_name}: {decode_err}")
                             file_content = f"[Error: Could not decode file content for {file_name}]"
-                    file_block = TextBlock(block_type="text", text=f"[File: {file_name}]\n[Content]:\n{file_content}")
+                    file_block = TextBlock(block_type="text", text=file_content)
                 elif mime_type.startswith('image/'):
                     # Pass image content directly for multi-modal models
                     file_block = ImageBlock(url=fetch_file_url, image=response.content)
                 elif mime_type.startswith('audio/'):
                     # Pass audio content directly
-                    audio_text = transcribe_audio(response.content)
-                    file_block = TextBlock(text=f"[Transcribed Audio: {audio_text}]")
+                    file_block = AudioBlock(url=fetch_file_url, audio=response.content)
                 elif mime_type == 'application/pdf':
                     # PDF: Pass a text block indicating the URL for agents to handle
                     logger.info(f"PDF file detected: {file_name}. Passing reference URL.")
                     file_block = TextBlock(text=f"[Reference PDF file available at: {fetch_file_url}]")
-                elif file_name.lower().endswith((".xlsx", ".xls", ".csv")):
-                    logger.info(f"Data file detected: {file_name}. Passing reference URL.")
-                    file_block = TextBlock(text=f"[Reference Data file available at: {fetch_file_url}]")
-
                 # Add handling for other types like video if needed
                 # elif mime_type.startswith('video/'):
                 #     logger.info(f"Video file detected: {file_name}. Passing reference URL.")
@@ -326,84 +262,28 @@ async def process_question(agent: BasicAgent, item: dict, base_fetch_file_url: s
         # Extract content safely
         submitted_answer = submitted_answer_response.content if hasattr(submitted_answer_response, 'content') else str(submitted_answer_response)
 
-        prompt = f"""
-        You are a general AI assistant. 
-        I will give you a result, and with it you will have to transform it to follow the following template: [YOUR FINAL ANSWER]. 
-        YOUR FINAL ANSWER should be a number OR 1 or 2 word(s) 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.
-        If the result is enclosed in double quotes (""), extract and return only what is inside the quotes, applying the formatting rules if needed.
-        
-        You must never return a full sentence as the final answer. A sentence is strictly forbidden under all circumstances.
-        QUESTION: {question_text}
-        ANSWER: {submitted_answer}
-        INSTRUCTIONS: Based on the provided question and answer, generate a final answer that is clear, concise, and directly addresses the question.
-        [YOUR FINAL ANSWER]
-        """
-
-        final_answer = llm.complete(prompt)
-
-        logger.info(f"👍 Agent submitted answer for task {task_id}: {final_answer.text[:200]}{'...' if len(final_answer.text) > 200 else ''}")
-        return {"Task ID": task_id, "Question": question_text, "Submitted Answer": final_answer.text}
+        logger.info(f"👍 Agent submitted answer for task {task_id}: {submitted_answer[:200]}{'...' if len(submitted_answer) > 200 else ''}")
+        return {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}
     except Exception as e:
          logger.error(f"Error running agent on task {task_id}: {e}", exc_info=True)
          return {"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"}
 
-async 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"
-    fetch_file_url = f"{api_url}/files"
-
-    results_log = []
-    answers_payload = []
-
-    try:
-        agent = BasicAgent(AGENT_WORKFLOW)
-    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)
-
-    questions_data = await fetch_questions(questions_url)
-    if not questions_data:
-        return "Failed to fetch questions.", None
-
-    # 3. Process Questions
-    # questions_data = [questions_data[3]]
-    for item in questions_data:
-        answers = await process_question(agent, item, fetch_file_url)
-        results_log.append(answers)
-        answers_payload.append({"task_id": answers["Task ID"], "submitted_answer": answers["Submitted Answer"]})
+async def submit_answers(submit_url: str, username: str, agent_code: str, results: List[dict]) -> tuple[str, pd.DataFrame]:
+    """Submits the collected answers to the GAIA benchmark API."""
+    answers_payload = [
+        {"task_id": r["Task ID"], "submitted_answer": r["Submitted Answer"]}
+        for r in results if "Submitted Answer" in r and not str(r["Submitted Answer"]).startswith("AGENT ERROR:")
+    ]
 
     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)
+        logger.warning("Agent did not produce any valid answers to submit.")
+        results_df = pd.DataFrame(results)
+        return "Agent did not produce any valid answers to submit.", results_df
 
-    # 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}")
+    logger.info(status_update)
+    logger.info(f"Submitting to: {submit_url}")
 
     try:
         response = requests.post(submit_url, json=submission_data, timeout=120) # Increased timeout
@@ -417,7 +297,7 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
             f"Message: {result_data.get('message', 'No message received.')}"
         )
         logger.info("Submission successful.")
-        results_df = pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results)
         return final_status, results_df
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
@@ -428,58 +308,103 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         logger.error(status_message)
-        results_df = pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results)
         return status_message, results_df
     except requests.exceptions.Timeout:
         status_message = "Submission Failed: The request timed out."
         logger.error(status_message)
-        results_df = pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results)
         return status_message, results_df
     except requests.exceptions.RequestException as e:
         status_message = f"Submission Failed: Network error - {e}"
         logger.error(status_message)
-        results_df = pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results)
         return status_message, results_df
     except Exception as e:
         status_message = f"Submission Failed: An unexpected error occurred during submission - {e}"
         logger.error(status_message, exc_info=True)
-        results_df = pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results)
         return status_message, results_df
 
+# --- Main Function for Batch Processing ---
+async def run_and_submit_all(
+        username: str,
+        agent_code: str,
+        api_url: str = DEFAULT_API_URL,
+        level: int = 1,
+        max_questions: int = 0, # 0 means all questions for the level
+        progress=gr.Progress(track_tqdm=True)
+    ) -> tuple[str, pd.DataFrame]:
+    """Fetches all questions for a level, runs the agent, and submits answers."""
+    if not AGENT_WORKFLOW:
+        error_msg = "Agent Workflow is not initialized. Cannot run benchmark."
+        logger.error(error_msg)
+        return error_msg, pd.DataFrame()
+        
+    if not username or not username.strip():
+        error_msg = "Username cannot be empty."
+        logger.error(error_msg)
+        return error_msg, pd.DataFrame()
+
+    questions_url = f"{api_url}/questions?level={level}"
+    submit_url = f"{api_url}/submit"
+    base_fetch_file_url = f"{api_url}/get_file"
+
+    questions = await fetch_questions(questions_url)
+    if questions is None:
+        error_msg = f"Failed to fetch questions for level {level}. Check logs."
+        return error_msg, pd.DataFrame()
+
+    # Limit number of questions if max_questions is set
+    if max_questions > 0:
+        questions = questions[:max_questions]
+        logger.info(f"Processing a maximum of {max_questions} questions for level {level}.")
+    else:
+        logger.info(f"Processing all {len(questions)} questions for level {level}.")
+
+    agent = BasicAgent(AGENT_WORKFLOW)
+    results = []
+    total_questions = len(questions)
+
+    for i, item in enumerate(progress.tqdm(questions, desc=f"Processing Level {level} Questions")):
+        result = await process_question(agent, item, base_fetch_file_url)
+        if result:
+            results.append(result)
+        # Optional: Add a small delay between questions if needed
+        # await asyncio.sleep(0.1)
+
+    # Submit answers
+    final_status, results_df = await submit_answers(submit_url, username, agent_code, results)
+    return final_status, results_df
+
 # --- Gradio Interface ---
 def create_gradio_interface():
     """Creates and returns the Gradio interface."""
-    # --- 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.
-            """
-        )
+    logger.info("Creating Gradio interface...")
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# GAIA Benchmark Agent Runner")
+        gr.Markdown("Run the initialized multi-agent system against the GAIA benchmark questions and submit the results.")
 
-        gr.LoginButton()
+        with gr.Row():
+            username = gr.Textbox(label="Username", placeholder="Enter your username (e.g., [email protected])")
+            agent_code = gr.Textbox(label="Agent Code", placeholder="Enter a short code for your agent (e.g., v1.0)")
+        with gr.Row():
+            level = gr.Dropdown(label="Benchmark Level", choices=[1, 2, 3], value=1)
+            max_questions = gr.Number(label="Max Questions (0 for all)", value=0, minimum=0, step=1)
+            api_url = gr.Textbox(label="GAIA API URL", value=DEFAULT_API_URL)
 
-        run_button = gr.Button("Run Evaluation & Submit All Answers")
+        run_button = gr.Button("Run Benchmark and Submit", variant="primary")
 
-        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)
+        with gr.Accordion("Results", open=False):
+            status_output = gr.Textbox(label="Submission Status", lines=5)
+            results_dataframe = gr.DataFrame(label="Detailed Results")
 
         run_button.click(
             fn=run_and_submit_all,
-            outputs=[status_output, results_table]
+            inputs=[username, agent_code, api_url, level, max_questions],
+            outputs=[status_output, results_dataframe]
         )
-
+    logger.info("Gradio interface created.")
     return demo
 
 # --- Main Execution ---

cookies.txt

@@ -1,27 +0,0 @@
-# Netscape HTTP Cookie File
-# This file is generated by yt-dlp.  Do not edit.
-
-.youtube.com	TRUE	/	TRUE	1772810415	SOCS	CAESEwgDEgk3MjI0NDY2OTcaAmZyIAEaBgiAsYW9Bg
-.youtube.com	TRUE	/	TRUE	1773242519	LOGIN_INFO	AFmmF2swRQIhAN5tw3v4vzvqkE9jFGTfwRfuSlsgvo8oZFND0KLeJSiZAiBe35g8ohBeSsOxXaaBST6ZIwRjsaj8TciBG4Qbwf6K0A:QUQ3MjNmeWJBWWxHS19XRTc3X2dQbzBiMDQwVDlLWmJfcEhzSVI1NWsyR2otbFQyVnlqdFpqandUMWtELXZqcEJsZjVaSl9rQzF2UFRULXdNbU9fRTk4Y2VtUHcxa1JUb2JIbWZDZ1JLeGpZUVhYS2x3RlltSktBZ1VFcnRqVUc0RkZzRWdxQjJYdmVOMUVOc0E1TER3a05nSnZBOGVicDA2c21sN2tYelhWRjhtU202cmJRVm9OcjBGMjR6WEtlRGFOazkyZTE3OGE4OURqMW5zVDdNdkNtRk55LWRIcU1oUQ==
-.youtube.com	TRUE	/	TRUE	1762642036	__Secure-ROLLOUT_TOKEN	CK2CtoGE9_qCKBDVmd6PqaqLAxjYr4vIgZ-NAw%3D%3D
-.youtube.com	TRUE	/	TRUE	1762643089	VISITOR_INFO1_LIVE	XJWWeg-61Jo
-.youtube.com	TRUE	/	FALSE	1781171326	SID	g.a000wgiyYfwWbhaK50WfWqfX9wGtc5AN9kBMrz73fEyP_cRPUjni8ppqkSKdDM9ksOR38k2NPQACgYKAfsSARASFQHGX2MicxUQ0e-BNo8Wi9EniKaX3BoVAUF8yKpXumEKYDuFms-e_KKcVMJF0076
-.youtube.com	TRUE	/	TRUE	1781171326	__Secure-1PSID	g.a000wgiyYfwWbhaK50WfWqfX9wGtc5AN9kBMrz73fEyP_cRPUjnihPJmq-OGf0cC6C2aYqH-yAACgYKAQcSARASFQHGX2MijJRbqQNyo9BHMzvkk9HXUBoVAUF8yKpPaBvpsOcQqoYQe2pZOfNL0076
-.youtube.com	TRUE	/	TRUE	1781171326	__Secure-3PSID	g.a000wgiyYfwWbhaK50WfWqfX9wGtc5AN9kBMrz73fEyP_cRPUjnix4LQh8UGsF1ttmxm5asDFwACgYKAfgSARASFQHGX2MimceB5eU37gApYiJGCnGDihoVAUF8yKoXYXFKC51Fi3JAsb3l7faw0076
-.youtube.com	TRUE	/	FALSE	1781171326	HSID	Ab7ZwZGNdOqOepsnI
-.youtube.com	TRUE	/	TRUE	1781171326	SSID	AFzWuPosAEyblSdei
-.youtube.com	TRUE	/	FALSE	1781171326	APISID	KMF74B5OX-1VVqvj/A-UEVQybq5JHzj9Wu
-.youtube.com	TRUE	/	TRUE	1781171326	SAPISID	qU-9iyk0zB5n9bf-/ApnBCKOoR_j1JOL-B
-.youtube.com	TRUE	/	TRUE	1781171326	__Secure-1PAPISID	qU-9iyk0zB5n9bf-/ApnBCKOoR_j1JOL-B
-.youtube.com	TRUE	/	TRUE	1781171326	__Secure-3PAPISID	qU-9iyk0zB5n9bf-/ApnBCKOoR_j1JOL-B
-.youtube.com	TRUE	/	TRUE	1772810410	__Secure-YEC	CgtaV0NPeGJVRncxZyiQ_YnBBjInCgJCRRIhEh0SGwsMDg8QERITFBUWFxgZGhscHR4fICEiIyQlJiAy
-.youtube.com	TRUE	/	TRUE	1762643089	VISITOR_PRIVACY_METADATA	CgJCRRIhEh0SGwsMDg8QERITFBUWFxgZGhscHR4fICEiIyQlJiBt
-.youtube.com	TRUE	/	FALSE	0	PREF	f4=4000000&tz=UTC&f7=100&f6=40000400&f5=30000&hl=en
-.youtube.com	TRUE	/	TRUE	1778626640	__Secure-1PSIDTS	sidts-CjIBjplskOfLYqOWfHbik540ZpwFBI2jOGBbPTxcc_79T8WrqaqFIW__ByzwzE27PdTrMhAA
-.youtube.com	TRUE	/	TRUE	1778626640	__Secure-3PSIDTS	sidts-CjIBjplskOfLYqOWfHbik540ZpwFBI2jOGBbPTxcc_79T8WrqaqFIW__ByzwzE27PdTrMhAA
-.youtube.com	TRUE	/	FALSE	1778627089	SIDCC	AKEyXzU04DAJ1xdkVRY0_COivRahMJPereJrve4NXQwWo-OSDJBigcJId1S2IrT-cUqL7vmXy9U
-.youtube.com	TRUE	/	TRUE	1778627089	__Secure-1PSIDCC	AKEyXzVck1n4TeBTP8ZRXRwsTYyCA2Us0wWcB31a4sEJr9RE8M5bBaaxcay9CvAKlp3pkZNRayk
-.youtube.com	TRUE	/	TRUE	1778627089	__Secure-3PSIDCC	AKEyXzUw1VqC_zsRzzp8yi8_KO5S3LxlEHTD0BpeHTPoL0A4GbEDja6m9B0y9WMOjMQGi4hJVf95
-.youtube.com	TRUE	/	TRUE	0	YSC	Hk4GBz7R3SM
-.youtube.com	TRUE	/	TRUE	1810163089	__Secure-YT_TVFAS	t=483201&s=2
-.youtube.com	TRUE	/	TRUE	1762643089	DEVICE_INFO	ChxOelV3TXpZNU9UQTVNRFE1TURJM05EWTBOQT09EJH9icEGGJH9icEG

gaia_improvement_plan.md

@@ -0,0 +1,943 @@
+
+### 3.5. `research_agent.py` Refactoring
+
+*   **Rationale:** To improve browser instance management, error handling, and configuration.
+*   **Proposals:**
+    1.  **Browser Lifecycle Management:** Instead of initializing the browser (`start_chrome`) at the module level, manage its lifecycle explicitly. Options:
+        *   Initialize the browser within the agent's initialization and provide a method or tool to explicitly close it (`kill_browser`) when the agent's task is done or the application shuts down.
+        *   Use a context manager (`with start_chrome(...) as browser:`) if the browser is only needed for a specific scope within a tool call (less likely for a persistent agent).
+        *   Ensure `kill_browser` is reliably called. Perhaps the `planner_agent` could invoke a cleanup tool/method on the `research_agent` after its tasks are complete.
+    2.  **Configuration:** Move hardcoded Chrome options to configuration. Externalize API keys/IDs if not already done (they seem to be using `os.getenv`, which is good).
+    3.  **Robust Error Handling:** For browser interaction tools (`visit`, `get_text_by_css`, `click_element`), raise specific custom exceptions instead of returning error strings. This allows for more structured error handling by the agent or workflow.
+    4.  **Tool Consolidation (Optional):** The agent has many tools. Consider if some related tools (e.g., different search APIs) could be consolidated behind a single tool that internally chooses the best source, or if the LLM handles the large toolset effectively.
+
+*   **Diff Patch (Illustrative - Configuration & Browser Init):**
+
+    ```diff
+    --- a/research_agent.py
+    +++ b/research_agent.py
+    @@ -1,5 +1,6 @@
+     import os
+     import time
++    import logging
+     from typing import List
+ 
+     from llama_index.core.agent.workflow import ReActAgent
+@@ -15,17 +16,21 @@
+     from helium import start_chrome, go_to, find_all, Text, kill_browser
+     from helium import get_driver
+ 
++    logger = logging.getLogger(__name__)
++
+ # 1. Helium
+-chrome_options = webdriver.ChromeOptions()
+-chrome_options.add_argument("--no-sandbox")
+-chrome_options.add_argument("--disable-dev-shm-usage")
+-chrome_options.add_experimental_option("prefs", {
+-    "download.prompt_for_download": False,
+-    "plugins.always_open_pdf_externally": True,
+-    "profile.default_content_settings.popups": 0
+-})
+-
+-browser = start_chrome(headless=True, options=chrome_options)
++# Browser instance should be managed, not global at module level
++# browser = start_chrome(headless=True, options=chrome_options)
++
++def get_chrome_options():
++    options = webdriver.ChromeOptions()
++    if os.getenv("RESEARCH_AGENT_CHROME_NO_SANDBOX", "true").lower() == "true":
++        options.add_argument("--no-sandbox")
++    if os.getenv("RESEARCH_AGENT_CHROME_DISABLE_DEV_SHM", "true").lower() == "true":
++        options.add_argument("--disable-dev-shm-usage")
++    # Add other options from config as needed
++    # options.add_experimental_option(...) # Example
++    return options
+ 
+ def visit(url: str, wait_seconds: float = 2.0) -> str |None:
+     """
+@@ -36,10 +41,11 @@
+         wait_seconds (float): Time to wait after navigation.
+     """
+     try:
++        # Assumes browser is available in context (e.g., class member)
+         go_to(url)
+         time.sleep(wait_seconds)
+         return f"Visited: {url}"
+     except Exception as e:
++       logger.error(f"Error visiting {url}: {e}", exc_info=True)
+        return f"Error visiting {url}: {e}"
+ 
+ def get_text_by_css(selector: str) -> List[str] | str:
+@@ -52,13 +58,15 @@
+         List[str]: List of text contents.
+     """
+     try:
++        # Assumes browser/helium context is active
+         if selector.lower() == 'body':
+             elements = find_all(Text())
+         else:
+             elements = find_all(selector)
+         texts = [elem.web_element.text for elem in elements]
+-        print(f"Extracted {len(texts)} elements for selector \'{selector}\'")
++        logger.info(f"Extracted {len(texts)} elements for selector \'{selector}\'")
+         return texts
+     except Exception as e:
++        logger.error(f"Error extracting text for selector {selector}: {e}", exc_info=True)
+         return f"Error extracting text for selector {selector}: {e}"
+ 
+ def get_page_html() -> str:
+@@ -70,9 +78,11 @@
+         str: HTML content, or empty string on error.
+     """
+     try:
++        # Assumes browser/helium context is active
+         driver = get_driver()
+         html = driver.page_source
+         return html
+     except Exception as e:
++        logger.error(f"Error extracting HTML: {e}", exc_info=True)
+         return f"Error extracting HTML: {e}"
+ 
+ def click_element(selector: str, index_element: int = 0) -> str:
+@@ -83,10 +93,12 @@
+         selector (str): CSS selector of the element to click.
+     """
+     try:
++        # Assumes browser/helium context is active
+         element = find_all(selector)[index_element]
+         element.click()
+         time.sleep(1)
+         return f"Clicked element matching selector \'{selector}\'"
+     except Exception as e:
++        logger.error(f"Error clicking element {selector}: {e}", exc_info=True)
+         return f"Error clicking element {selector}: {e}"
+ 
+ def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+@@ -97,6 +109,7 @@
+         nth_result: Which occurrence to jump to (default: 1)
+     """
+     elements = browser.find_elements(By.XPATH, f"//*[contains(text(), \'{text}\')]")
++    # Assumes browser is available in context
+     if nth_result > len(elements):
+         return f"Match n°{nth_result} not found (only {len(elements)} matches found)"
+     result = f"Found {len(elements)} matches for \'{text}\'."
+@@ -107,19 +120,22 @@
+ 
+def go_back() -> None:
+     """Goes back to previous page."""
+     browser.back()
++    # Assumes browser is available in context
+ 
+ def close_popups() -> None:
+     """
+     Closes any visible modal or pop-up on the page. Use this to dismiss pop-up windows! This does not work on cookie consent banners.
+     """
+     webdriver.ActionChains(browser).send_keys(Keys.ESCAPE).perform()
++    # Assumes browser is available in context
+ 
+ def close() -> None:
+     """
+     Close the browser instance.
+     """
+     try:
++        # Assumes kill_browser is appropriate here
+         kill_browser()
+-        print("Browser closed")
++        logger.info("Browser closed via kill_browser()")
+     except Exception as e:
+-        print(f"Error closing browser: {e}")
++        logger.error(f"Error closing browser: {e}", exc_info=True)
+ 
+ visit_tool = FunctionTool.from_defaults(
+     fn=visit,
+@@ -240,9 +256,14 @@
+ 
+ 
+def initialize_research_agent() -> ReActAgent:
++    # Browser initialization should happen here or be managed externally
++    # Example: browser = start_chrome(headless=True, options=get_chrome_options())
++    # Ensure browser instance is passed to tools or accessible via agent state/class
++
++    llm_model_name = os.getenv("RESEARCH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=llm_model_name,
+     )
+ 
+     system_prompt = """\
+    ```
+
+
+### 3.6. `text_analyzer_agent.py` Refactoring
+
+*   **Rationale:** To improve configuration management and error handling.
+*   **Proposals:**
+    1.  **Configuration:** Move the hardcoded LLM model name (`models/gemini-1.5-pro`) to environment variables or a configuration file.
+    2.  **Prompt Management:** Move the `analyze_text` prompt to a separate template file.
+    3.  **Error Handling:** In `extract_text_from_pdf`, consider raising specific exceptions (e.g., `PDFDownloadError`, `PDFParsingError`) instead of returning error strings, allowing the agent to handle failures more gracefully.
+
+*   **Diff Patch (Illustrative - Configuration & Error Handling):**
+
+    ```diff
+    --- a/text_analyzer_agent.py
+    +++ b/text_analyzer_agent.py
+    @@ -6,6 +6,14 @@
+ 
+     logger = logging.getLogger(__name__)
+ 
++    class PDFExtractionError(Exception):
++        """Custom exception for PDF extraction failures."""
++        pass
++
++    class PDFDownloadError(PDFExtractionError):
++        """Custom exception for PDF download failures."""
++        pass
++
+ def extract_text_from_pdf(source: str) -> str:
+     """
+     Extract raw text from a PDF file on disk or at a URL.
+@@ -19,21 +27,21 @@
+         try:
+             resp = requests.get(source, timeout=10)
+             resp.raise_for_status()
+-        except Exception as e:
+-            return f"Error downloading PDF from {source}: {e}"
++        except requests.exceptions.RequestException as e:
++            raise PDFDownloadError(f"Error downloading PDF from {source}: {e}") from e
+ 
+         try:
+             tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+             tmp.write(resp.content)
+             tmp.flush()
+             tmp_path = tmp.name
+             tmp.close()
+-        except Exception as e:
+-            return f"Error writing temp PDF file: {e}"
++        except IOError as e:
++            raise PDFExtractionError(f"Error writing temp PDF file: {e}") from e
+         path = tmp_path
+     else:
+         path = source
+ 
+     # Now extract text from the PDF on disk
+     if not os.path.isfile(path):
+-        return f"PDF not found: {path}"
++        raise PDFExtractionError(f"PDF not found: {path}")
+ 
+     text = ""
+ 
+@@ -41,10 +49,10 @@
+         reader = PdfReader(path)
+         pages = [page.extract_text() or "" for page in reader.pages]
+         text = "\n".join(pages)
+-        print(f"Extracted {len(pages)} pages of text from PDF")
++        logger.info(f"Extracted {len(pages)} pages of text from PDF: {path}")
+     except Exception as e:
+         # Catch specific PyPDF2 errors if possible, otherwise general Exception
+-        return f"Error reading PDF: {e}"
++        raise PDFExtractionError(f"Error reading PDF {path}: {e}") from e
+ 
+     # Clean up temporary file if one was created
+     if source.lower().startswith(("http://", "https://")):
+@@ -67,6 +75,14 @@
+         str: A plain-text string containing:
+              • A “Summary:” section with bullet points.
+              • A “Facts:” section with bullet points.
++    """
++    # Load prompt from file ideally
++    prompt_template = """You are an expert analyst.
++
++    Please analyze the following text and produce a plain-text response
++    with two sections:
++
++    Summary:
++    • Provide 2–3 concise bullet points summarizing the main ideas.
++
++    Facts:
++    • List each verifiable fact found in the text as a bullet point.
++
++    Respond with exactly that format—no JSON, no extra commentary.
++
++    Text to analyze:
++    \"\"\"
++    {text}
++    \"\"\"
+     """
+     # Build the prompt to guide the LLM’s output format
+     input_prompt = f"""You are an expert analyst.
+@@ -84,13 +100,14 @@
+     {text}
+     \"\"\"
+     """
++    input_prompt = prompt_template.format(text=text)
+ 
+     # Use the LLM to generate the analysis
++    llm_model_name = os.getenv("TEXT_ANALYZER_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=llm_model_name,
+     )
+ 
+     generated = llm.complete(input_prompt)
+@@ -124,9 +141,10 @@
+         FunctionAgent: Configured analysis agent.
+     """
+ 
++    llm_model_name = os.getenv("TEXT_ANALYZER_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=llm_model_name,
+     )
+ 
+     system_prompt = """\
+    ```
+
+
+### 3.7. `reasoning_agent.py` Refactoring
+
+*   **Rationale:** To simplify the agent structure, improve configuration, and potentially optimize LLM usage.
+*   **Proposals:**
+    1.  **Configuration:** Move hardcoded LLM model names (`models/gemini-1.5-pro`, `o4-mini`) and the API key environment variable name (`ALPAFLOW_OPENAI_API_KEY`) to configuration.
+    2.  **Prompt Management:** Move the detailed CoT prompt from `reasoning_tool_fn` to a separate template file.
+    3.  **Agent Structure Simplification:** Given the rigid workflow (call tool -> handoff), consider replacing the `ReActAgent` with a simpler `FunctionAgent` that directly calls the `reasoning_tool` and formats the output before handing off. Alternatively, evaluate if the `reasoning_tool` logic could be integrated as a direct LLM call within agents that need CoT (like `planner_agent`), potentially removing the need for a separate `reasoning_agent` altogether, unless its specific CoT prompt/model (`o4-mini`) is crucial.
+
+*   **Diff Patch (Illustrative - Configuration & Prompt Loading):**
+
+    ```diff
+    --- a/reasoning_agent.py
+    +++ b/reasoning_agent.py
+    @@ -1,10 +1,19 @@
+     import os
++    import logging
+ 
+     from llama_index.core.agent.workflow import ReActAgent
+     from llama_index.llms.google_genai import GoogleGenAI
+     from llama_index.core.tools import FunctionTool
+     from llama_index.llms.openai import OpenAI
+ 
++    logger = logging.getLogger(__name__)
++
++    def load_prompt_from_file(filename="reasoning_tool_prompt.txt") -> str:
++        try:
++            with open(filename, "r") as f:
++                return f.read()
++        except FileNotFoundError:
++            logger.error(f"Prompt file {filename} not found.")
++            return "Perform chain-of-thought reasoning on the context: {context}"
++
+ def reasoning_tool_fn(context: str) -> str:
+     """
+     Perform end-to-end chain-of-thought reasoning over the full multi-agent workflow context,
+@@ -17,45 +26,12 @@
+         str: A structured reasoning trace with numbered thought steps, intermediate checks,
+              and a concise final recommendation or conclusion.
+     """
+-    prompt = f"""You are an expert reasoning engine.  You have the following full context of a multi-agent workflow:
+-
+-    {context}
+-    
+-    Your job is to:
+-    1. **Comprehension**  
+-       - Read the entire question or problem statement carefully.  
+-       - Identify key terms, constraints, and desired outcomes.
+-
+-    2. **Decomposition**  
+-       - Break down the problem into logical sub-steps or sub-questions.  
+-       - Ensure each sub-step is necessary and sufficient to progress toward a solution.
+-
+-    3. **Chain-of-Thought**  
+-       - Articulate your internal reasoning in clear, numbered steps.  
+-       - At each step, state your assumptions, derive implications, and check for consistency.
+-
+-    4. **Intermediate Verification**  
+-       - After each reasoning step, validate your conclusion against the problem’s constraints.  
+-       - If a contradiction or uncertainty arises, revisit and refine the previous step.
+-
+-    5. **Synthesis**  
+-       - Once all sub-steps are resolved, integrate the intermediate results into a cohesive answer.  
+-       - Ensure the final answer directly addresses the user’s request and all specified criteria.
+-
+-    6. **Clarity & Precision**  
+-       - Use formal, precise language.  
+-       - Avoid ambiguity: define any technical terms you introduce.  
+-       - Provide just enough detail to justify each conclusion without digression.
+-
+-    7. **Final Answer**  
+-       - Present a concise, well-structured response.  
+-       - If appropriate, include a brief summary of your reasoning steps.
+-    
+-    Respond with your reasoning steps followed by the final recommendation.
+-    """
++    prompt_template = load_prompt_from_file()
++    prompt = prompt_template.format(context=context)
+ 
++    reasoning_llm_model = os.getenv("REASONING_TOOL_LLM_MODEL", "o4-mini")
++    # Use specific API key if needed, e.g., ALPAFLOW_OPENAI_API_KEY
++    reasoning_api_key_env = os.getenv("REASONING_TOOL_API_KEY_ENV", "ALPAFLOW_OPENAI_API_KEY")
++    reasoning_api_key = os.getenv(reasoning_api_key_env)
+     llm = OpenAI(
+-        model="o4-mini",
+-        api_key=os.getenv("ALPAFLOW_OPENAI_API_KEY"),
++        model=reasoning_llm_model,
++        api_key=reasoning_api_key,
+         reasoning_effort="high"
+     )
+     response = llm.complete(prompt)
+@@ -74,9 +50,10 @@
+     """
+     Create a pure reasoning agent with no tools, relying solely on chain-of-thought.
+     """
++    agent_llm_model = os.getenv("REASONING_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=agent_llm_model,
+     )
+ 
+     system_prompt = """\
+    ```
+
+
+### 3.8. `planner_agent.py` Refactoring
+
+*   **Rationale:** To improve configuration management and prompt handling.
+*   **Proposals:**
+    1.  **Configuration:** Move the hardcoded LLM model name (`models/gemini-1.5-pro`) to environment variables or a configuration file.
+    2.  **Prompt Management:** Move the system prompt and the prompts within the `plan` and `synthesize_and_respond` functions to separate template files for better readability and maintainability.
+
+*   **Diff Patch (Illustrative - Configuration & Prompt Loading):**
+
+    ```diff
+    --- a/planner_agent.py
+    +++ b/planner_agent.py
+    @@ -1,10 +1,19 @@
+     import os
++    import logging
+     from typing import List, Any
+ 
+     from llama_index.core.agent.workflow import FunctionAgent, ReActAgent
+     from llama_index.core.tools import FunctionTool
+     from llama_index.llms.google_genai import GoogleGenAI
+ 
++    logger = logging.getLogger(__name__)
++
++    def load_prompt_from_file(filename: str, default_prompt: str) -> str:
++        try:
++            with open(filename, "r") as f:
++                return f.read()
++        except FileNotFoundError:
++            logger.warning(f"Prompt file {filename} not found. Using default.")
++            return default_prompt
++
+ def plan(objective: str) -> List[str]:
+     """
+     Generate a list of sub-questions from the given objective.
+@@ -15,14 +24,16 @@
+     Returns:
+         List[str]: A list of sub-steps as strings.
+     """
+-    input_prompt: str = (
++    default_plan_prompt = (
+         "You are a research assistant. "
+         "Given an objective, break it down into a list of concise, actionable sub-steps.\n"
+         f"Objective: {objective}\n"
+         "Sub-steps (one per line):"
+     )
++    plan_prompt_template = load_prompt_from_file("planner_plan_prompt.txt", default_plan_prompt)
++    input_prompt = plan_prompt_template.format(objective=objective)
+ 
++    llm_model_name = os.getenv("PLANNER_TOOL_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=llm_model_name,
+     )
+ 
+ 
+@@ -44,13 +55,16 @@
+     Returns:
+         str: A unified, well-structured response addressing the original objective.
+     """
+-    # Join each ready-made QA block directly
+     summary_blocks = "\n".join(results)
+-    input_prompt = f"""You are an expert synthesizer. Given the following sub-questions and their answers,
++    default_synth_prompt = f"""You are an expert synthesizer. Given the following sub-questions and their answers,
+     produce a single, coherent, comprehensive report that addresses the original objective:
+     
+     {summary_blocks}
+     
+     Final Report:
+     """
++    synth_prompt_template = load_prompt_from_file("planner_synthesize_prompt.txt", default_synth_prompt)
++    input_prompt = synth_prompt_template.format(summary_blocks=summary_blocks)
++
++    llm_model_name = os.getenv("PLANNER_TOOL_LLM_MODEL", "models/gemini-1.5-pro") # Can use same model as plan
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=llm_model_name,
+     )
+     response = llm.complete(input_prompt)
+     return response.text
+@@ -77,9 +91,10 @@
+     """
+     Initialize a LlamaIndex agent specialized in research planning and question engineering.
+     """
++    agent_llm_model = os.getenv("PLANNER_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=agent_llm_model,
+     )
+ 
+     system_prompt = """\
+@@ -108,6 +123,7 @@
+     **Completion & Synthesis**  
+     If the final result fully completes the original objective, produce a consolidated synthesis of the roadmap and send it as your concluding output.
+     """
++    system_prompt = load_prompt_from_file("planner_system_prompt.txt", system_prompt) # Load from file if exists
+ 
+     agent = ReActAgent(
+         name="planner_agent",
+    ```
+
+
+### 3.9. `code_agent.py` Refactoring
+
+*   **Rationale:** To address the critical security vulnerability of the `SimpleCodeExecutor`, improve configuration management, and align code execution with safer practices.
+*   **Proposals:**
+    1.  **Remove `SimpleCodeExecutor`:** This class and its `execute` method using `subprocess` with raw code strings are fundamentally insecure and **must be removed entirely**.
+    2.  **Use `CodeInterpreterToolSpec`:** Rely *exclusively* on the `code_interpreter` tool derived from LlamaIndex's `CodeInterpreterToolSpec` for code execution. This tool is designed for safer, sandboxed execution.
+    3.  **Update `CodeActAgent` Initialization:** Remove the `code_execute_fn` parameter when initializing `CodeActAgent`, as the agent should use the provided `code_interpreter` tool for execution via the standard ReAct/Act loop, not a direct execution function.
+    4.  **Configuration:** Move hardcoded LLM model names (`o4-mini`, `models/gemini-1.5-pro`) and the API key environment variable name (`ALPAFLOW_OPENAI_API_KEY`) to configuration.
+    5.  **Prompt Management:** Move the `generate_python_code` prompt to a separate template file.
+
+*   **Diff Patch (Illustrative - Security Fix & Configuration):**
+
+    ```diff
+    --- a/code_agent.py
+    +++ b/code_agent.py
+    @@ -1,5 +1,6 @@
+     import os
+     import subprocess
++    import logging
+ 
+     from llama_index.core.agent.workflow import ReActAgent, CodeActAgent
+     from llama_index.core.tools import FunctionTool
+@@ -7,6 +8,16 @@
+     from llama_index.llms.openai import OpenAI
+     from llama_index.tools.code_interpreter import CodeInterpreterToolSpec
+ 
++    logger = logging.getLogger(__name__)
++
++    def load_prompt_from_file(filename: str, default_prompt: str) -> str:
++        try:
++            with open(filename, "r") as f:
++                return f.read()
++        except FileNotFoundError:
++            logger.warning(f"Prompt file {filename} not found. Using default.")
++            return default_prompt
++
+ def generate_python_code(prompt: str) -> str:
+     """
+     Generate valid Python code from a natural language description.
+@@ -27,7 +38,7 @@
+           it before execution.
+         - This function only generates code and does not execute it.
+     """
+-
+-    input_prompt = f"""You are also a helpful assistant that writes Python code. 
++    default_gen_prompt = f"""You are also a helpful assistant that writes Python code. 
+     You will be given a prompt and you must generate Python code based on that prompt. 
+     You must only generate Python code and nothing else. 
+     Do not include any explanations or any other text. 
+@@ -40,10 +51,14 @@
+     Code:\n
+     """
+ 
++    gen_prompt_template = load_prompt_from_file("code_gen_prompt.txt", default_gen_prompt)
++    input_prompt = gen_prompt_template.format(prompt=prompt)
++
++    gen_llm_model = os.getenv("CODE_GEN_LLM_MODEL", "o4-mini")
++    gen_api_key_env = os.getenv("CODE_GEN_API_KEY_ENV", "ALPAFLOW_OPENAI_API_KEY")
++    gen_api_key = os.getenv(gen_api_key_env)
+     llm = OpenAI(
+-        model="o4-mini",
+-        api_key=os.getenv("ALPAFLOW_OPENAI_API_KEY")
++        model=gen_llm_model,
++        api_key=gen_api_key
+     )
+ 
+     generated_code = llm.complete(input_prompt)
+@@ -74,60 +89,11 @@
+     ),
+ )
+ 
+-from typing import Any, Dict, Tuple
+-import io
+-import contextlib
+-import ast
+-import traceback
+-
+-
+-class SimpleCodeExecutor:
+-    """
+-    A simple code executor that runs Python code with state persistence.
+-
+-    This executor maintains a global and local state between executions,
+-    allowing for variables to persist across multiple code runs.
+-
+-    NOTE: not safe for production use! Use with caution.
+-    """
+-
+-    def __init__(self):
+-        pass
+-
+-    def execute(self, code: str) -> str:
+-        """
+-        Execute Python code and capture output and return values.
+-
+-        Args:
+-            code: Python code to execute
+-
+-        Returns:
+-            Dict with keys `success`, `output`, and `return_value`
+-        """
+-        print(f"Executing code: {code}")
+-        try:
+-            result = subprocess.run(
+-                ["python", code],
+-                stdout=subprocess.PIPE,
+-                stderr=subprocess.PIPE,
+-                text=True,
+-                timeout=60
+-            )
+-            if result.returncode != 0:
+-                print(f"Execution failed with error: {result.stderr.strip()}")
+-                return f"Error: {result.stderr.strip()}"
+-            else:
+-                output = result.stdout.strip()
+-                print(f"Captured Output: {output}")
+-                return output
+-        except subprocess.TimeoutExpired:
+-            print("Execution timed out.")
+-            return "Error: Timeout"
+-        except Exception as e:
+-            print(f"Execution failed with error: {e}")
+-            return f"Error: {e}"
+-
+ def initialize_code_agent() -> CodeActAgent:
+-    code_executor = SimpleCodeExecutor()
++    # DO NOT USE SimpleCodeExecutor - it is insecure.
++    # Rely on the code_interpreter tool provided below.
+ 
++    agent_llm_model = os.getenv("CODE_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=agent_llm_model,
+     )
+ 
+     system_prompt = """\
+@@ -151,6 +117,7 @@
+        - If further logical reasoning or verification is needed, delegate to **reasoning_agent**.  
+        - Otherwise, once you have the final code or execution result, pass your output to **planner_agent** for overall synthesis and presentation.
+     """
++    system_prompt = load_prompt_from_file("code_agent_system_prompt.txt", system_prompt)
+ 
+     agent = CodeActAgent(
+         name="code_agent",
+@@ -161,7 +128,7 @@
+             "pipelines, and library development, CodeAgent delivers production-ready Python solutions."
+         ),
+         # REMOVED: code_execute_fn=code_executor.execute, # Use code_interpreter tool instead
+-        code_execute_fn=code_executor.execute,
+         tools=[
+             python_code_generator_tool,
+             code_interpreter_tool,
+    ```
+
+
+### 3.10. `math_agent.py` Refactoring
+
+*   **Rationale:** To improve configuration management and potentially simplify the tool interface for the LLM.
+*   **Proposals:**
+    1.  **Configuration:** Move the hardcoded agent LLM model name (`models/gemini-1.5-pro`) to configuration. Ensure the WolframAlpha App ID is configured via environment variable (`WOLFRAM_ALPHA_APP_ID`) as intended.
+    2.  **Tool Granularity:** The current approach creates a separate tool for almost every single math function (solve, derivative, integral, add, multiply, inverse, mean, median, etc.). While explicit, this results in a very large number of tools for the `ReActAgent` to manage. Consider:
+        *   **Grouping:** Group related functions under fewer tools. For example, a `symbolic_math_tool` that takes the operation type (solve, diff, integrate) as a parameter, or a `matrix_ops_tool`.
+        *   **Natural Language Interface:** Create a single `calculate` tool that takes a natural language math query (e.g., "solve x**2 - 4 = 0 for x", "mean of [1, 2, 3]") and uses an LLM (or rule-based parsing) internally to dispatch to the appropriate NumPy/SciPy/SymPy function. This simplifies the interface for the main agent LLM but adds complexity within the tool.
+        *   **WolframAlpha Prioritization:** Evaluate if WolframAlpha can handle many of these requests directly, potentially reducing the need for numerous specific SymPy/NumPy tools, especially for symbolic tasks.
+    3.  **Truncated File:** Since the original file was truncated, ensure the full file is reviewed if possible, as there might be other issues or tools not seen.
+
+*   **Diff Patch (Illustrative - Configuration):**
+
+    ```diff
+    --- a/math_agent.py
+    +++ b/math_agent.py
+    @@ -1,5 +1,6 @@
+     import os
+     from typing import List, Optional, Union
++    import logging
+     import sympy as sp
+     import numpy as np
+     from llama_index.core.agent.workflow import ReActAgent
+    @@ -12,6 +13,8 @@
+     from scipy.integrate import odeint
+     import numpy.fft as fft
+ 
++    logger = logging.getLogger(__name__)
++
+     # --- Symbolic math functions ---
+ 
+ 
+    @@ -451,10 +454,11 @@
+ 
+ 
+ def initialize_math_agent() -> ReActAgent:
++    agent_llm_model = os.getenv("MATH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+     llm = GoogleGenAI(
+         api_key=os.getenv("GEMINI_API_KEY"),
+-        model="models/gemini-1.5-pro",
++        model=agent_llm_model,
+     )
+ 
+     # Ensure WolframAlpha App ID is set
+    ```
+
+*(Refactoring proposals section complete)*
+
+
+## 4. New Feature Designs
+
+This section outlines the design for the new features requested: YouTube Ingestion and Generic Audio Transcription.
+
+### 4.1. YouTube Ingestion
+
+*   **Rationale:** To enable the framework to process YouTube videos by extracting audio, transcribing it, and summarizing the content, as requested by the user.
+*   **Design Proposal:**
+    *   **Implementation:** Introduce a new dedicated agent, `youtube_agent`, or add tools to the existing `research_agent` or `text_analyzer_agent`. A dedicated agent seems cleaner given the specific multi-step workflow.
+    *   **Agent (`youtube_agent`):**
+        *   **Purpose:** Manages the end-to-end process of downloading YouTube audio, chunking, transcribing, and summarizing.
+        *   **Tools:**
+            1.  `download_youtube_audio`: Takes a YouTube URL, uses a library like `yt-dlp` (or potentially `pytube`) to download the audio stream into a temporary file (e.g., `.mp3` or `.opus`). Returns the path to the audio file.
+            2.  `chunk_audio_file`: Takes an audio file path and a maximum chunk duration (e.g., 60 seconds). Uses a library like `pydub` or `librosa`+`soundfile` to split the audio into smaller, sequentially numbered temporary files. Returns a list of chunk file paths.
+            3.  `transcribe_audio_chunk_gemini`: Takes an audio file path (representing a chunk). Uses the Google Generative AI SDK (`google.generativeai`) to call the Gemini 1.5 Pro model with the audio file for transcription. Returns the transcribed text.
+            4.  `summarize_transcript`: Takes the full concatenated transcript text. Uses a Gemini model (e.g., 1.5 Pro or Flash) with a specific prompt to generate a one-paragraph summary. Returns the summary text.
+        *   **Workflow (ReAct or Function sequence):**
+            1.  Receive YouTube URL.
+            2.  Call `download_youtube_audio`.
+            3.  Call `chunk_audio_file` with the downloaded audio path.
+            4.  Iterate through the list of chunk paths:
+                *   Call `transcribe_audio_chunk_gemini` for each chunk.
+                *   Collect transcribed text segments.
+            5.  Concatenate all transcribed text segments into a full transcript.
+            6.  Call `summarize_transcript` with the full transcript.
+            7.  Return the full transcript and the summary.
+            8.  Clean up temporary audio files (downloaded and chunks).
+        *   **Handoff:** Could hand off the transcript and summary to `planner_agent` or `text_analyzer_agent` for further processing or integration.
+    *   **Dependencies:** `yt-dlp`, `pydub` (requires `ffmpeg` or `libav`), `google-generativeai`.
+    *   **Configuration:** Gemini API Key, chunk duration.
+
+
+### 4.2. Generic Audio Transcription
+
+*   **Rationale:** To provide a flexible audio transcription capability for local files or remote URLs, using Gemini Pro for quality/latency tolerance and Whisper.cpp as a fallback, exposing it via a Python API as requested.
+*   **Design Proposal:**
+    *   **Implementation:** Introduce a new dedicated agent, `transcription_agent`, or add tools to `text_analyzer_agent`. A dedicated agent allows for clearer separation of concerns, especially managing the Whisper.cpp dependency and logic.
+    *   **Agent (`transcription_agent`):**
+        *   **Purpose:** Transcribes audio from various sources (local path, URL) using either Gemini or Whisper.cpp based on latency requirements or availability.
+        *   **Tools:**
+            1.  `prepare_audio_source`: Takes a source string (URL or local path). If it's a URL, downloads it to a temporary file using `requests`. Validates the local file path. Returns the path to the local audio file.
+            2.  `transcribe_gemini`: Takes an audio file path. Uses the `google-generativeai` SDK to call Gemini 1.5 Pro for transcription. Returns the transcribed text. This is the preferred method when latency is acceptable.
+            3.  `transcribe_whisper_cpp`: Takes an audio file path. Uses a Python wrapper around `whisper.cpp` (e.g., installing `whisper.cpp` via `apt` or compiling from source, then using `subprocess` or a dedicated Python binding if available) to perform local transcription. Returns the transcribed text. This is the fallback or low-latency option.
+            4.  `choose_transcription_method`: (Internal logic or a simple tool) Takes latency preference (e.g., 'high_quality' vs 'low_latency') or checks Gemini availability/quota. Decides whether to use `transcribe_gemini` or `transcribe_whisper_cpp`.
+        *   **Workflow (ReAct or Function sequence):**
+            1.  Receive audio source (URL/path) and potentially a latency preference.
+            2.  Call `prepare_audio_source` to get a local file path.
+            3.  Call `choose_transcription_method` (or execute internal logic) to decide between Gemini and Whisper.
+            4.  If Gemini: Call `transcribe_gemini`.
+            5.  If Whisper: Call `transcribe_whisper_cpp`.
+            6.  Return the resulting transcript.
+            7.  Clean up temporary downloaded audio file if applicable.
+        *   **Handoff:** Could hand off the transcript to `planner_agent` or `text_analyzer_agent`.
+    *   **Python API:**
+        *   Define a simple Python function (e.g., in a `transcription_api.py` module) that encapsulates the agent's logic or directly calls the underlying transcription functions.
+        ```python
+        # Example API function in transcription_api.py
+        from .transcription_agent import transcribe_audio # Assuming agent logic is refactored
+
+        def get_transcript(source: str, prefer_gemini: bool = True) -> str:
+            """Transcribes audio from a local path or URL.
+
+            Args:
+                source: Path to the local audio file or URL.
+                prefer_gemini: If True, attempts to use Gemini Pro first.
+                               If False or Gemini fails, falls back to Whisper.cpp.
+
+            Returns:
+                The transcribed text.
+
+            Raises:
+                TranscriptionError: If transcription fails.
+            """
+            # Implementation would call the agent or its refactored functions
+            try:
+                # Simplified logic - actual implementation needs error handling,
+                # Gemini/Whisper selection based on preference/availability
+                transcript = transcribe_audio(source, prefer_gemini)
+                return transcript
+            except Exception as e:
+                # Log error
+                raise TranscriptionError(f"Failed to transcribe {source}: {e}") from e
+
+        class TranscriptionError(Exception):
+            pass
+        ```
+    *   **Dependencies:** `requests`, `google-generativeai`, `whisper.cpp` (requires separate installation/compilation), potentially Python bindings for `whisper.cpp`.
+    *   **Configuration:** Gemini API Key, path to `whisper.cpp` executable or library, Whisper model selection.
+
+
+## 5. Extra Agent Designs
+
+This section proposes three additional specialized agents designed to enhance performance on the GAIA benchmark by addressing common challenges like complex fact verification, interpreting visual data representations, and handling long contexts.
+
+### 5.1. Agent Design 1: Advanced Validation Agent (`validation_agent`)
+
+*   **Purpose:** To perform rigorous validation of factual claims or intermediate results generated by other agents, going beyond the simple contradiction check of the current `verifier_agent`. This agent aims to improve the accuracy and trustworthiness of the final answer by cross-referencing information and performing checks.
+*   **Key Tool Calls:**
+    *   `web_search` (from `research_agent` or similar): To find external evidence supporting or refuting a claim.
+    *   `browse_and_extract` (from `research_agent` or similar): To access specific URLs found during search and extract relevant text snippets.
+    *   `code_interpreter` (from `code_agent`): To perform calculations or simple data manipulations needed for verification (e.g., checking unit conversions, calculating percentages).
+    *   `knowledge_base_lookup` (New Tool - Optional): Interface with a structured knowledge base (e.g., Wikidata, internal DB) to verify entities, relationships, or properties.
+    *   `llm_check_consistency` (New Tool or LLM call): Use a powerful LLM with a specific prompt to assess the logical consistency between a claim and a set of provided evidence snippets or existing context.
+*   **Agent Loop Sketch (ReAct style):**
+    1.  **Input:** A specific claim or statement to validate, along with relevant context or source information.
+    2.  **Thought:** Identify the core assertion in the claim. Determine the best validation strategy (e.g., web search for current events, calculation for numerical claims, consistency check for logical statements).
+    3.  **Action:** Call the appropriate tool (`web_search`, `code_interpreter`, `llm_check_consistency`).
+    4.  **Observation:** Analyze the tool's output (search results, calculation result, consistency assessment).
+    5.  **Thought:** Does the observation confirm, refute, or remain inconclusive about the claim? Is more information needed? (e.g., need to browse a specific search result).
+    6.  **Action (if needed):** Call another tool (`browse_and_extract`, `llm_check_consistency` with new evidence).
+    7.  **Observation:** Analyze new output.
+    8.  **Thought:** Synthesize findings. Assign a final validation status (e.g., Confirmed, Refuted, Uncertain) and provide supporting evidence or reasoning.
+    9.  **Output:** Validation status and justification.
+    10. **Handoff:** Return result to `planner_agent` or `verifier_agent` (if this agent replaces the contradiction part).
+
+### 5.2. Agent Design 2: Figure Interpretation Agent (`figure_interpretation_agent`)
+
+*   **Purpose:** To specialize in extracting structured data and meaning from figures, charts, graphs, and tables embedded within images or documents, which are common in GAIA tasks and often require more than just a textual description.
+*   **Key Tool Calls:**
+    *   `image_ocr` (New Tool or enhanced `image_analyzer_agent` capability): High-precision OCR focused on extracting text specifically from figures, including axes labels, legends, titles, and data points.
+    *   `chart_data_extractor` (New Tool): Utilizes specialized vision models (e.g., DePlot, ChartOCR, or similar fine-tuned models) designed to parse chart types (bar, line, pie) and extract underlying data series or key values.
+    *   `table_parser` (New Tool): Uses vision or document AI models to detect table structures in images/PDFs and extract cell content into a structured format (e.g., list of lists, Pandas DataFrame via code execution).
+    *   `code_interpreter` (from `code_agent`): To process extracted data (e.g., load into DataFrame, perform simple analysis, re-plot for verification).
+    *   `llm_interpret_figure` (New Tool or LLM call): Takes extracted text, data, and potentially the image itself (multimodal) to provide a semantic interpretation of the figure's message or trends.
+*   **Agent Loop Sketch (Function sequence or ReAct):**
+    1.  **Input:** An image or document page containing a figure/table, potentially with context or a specific question about it.
+    2.  **Action:** Call `image_ocr` to get all text elements.
+    3.  **Action:** Call `chart_data_extractor` or `table_parser` based on visual analysis (or try both) to get structured data.
+    4.  **Action (Optional):** Call `code_interpreter` to load structured data into a DataFrame for easier handling.
+    5.  **Action:** Call `llm_interpret_figure`, providing the extracted text, data (raw or DataFrame), and potentially the original image, asking it to answer the specific question or summarize the figure's key insights.
+    6.  **Output:** Structured data (if requested) and/or the semantic interpretation/answer.
+    7.  **Handoff:** Return results to `planner_agent` or `reasoning_agent`.
+
+### 5.3. Agent Design 3: Long Context Management Agent (`long_context_agent`)
+
+*   **Purpose:** To effectively manage and query information from very long documents or conversation histories that exceed the context window limits of standard models or require efficient information retrieval techniques.
+*   **Key Tool Calls:**
+    *   `document_chunker` (New Tool): Splits long text into semantically meaningful chunks (e.g., using `SentenceSplitter` from LlamaIndex or more advanced methods).
+    *   `vector_store_builder` (New Tool): Takes text chunks and builds an in-memory or persistent vector index (using libraries like `llama-index`, `langchain`, `faiss`, `chromadb`).
+    *   `vector_retriever` (New Tool): Queries the built vector index with a specific question to find the most relevant chunks.
+    *   `summarizer_tool` (New Tool or LLM call): Generates summaries of long text or selected chunks, potentially using different levels of detail.
+    *   `contextual_synthesizer` (New Tool or LLM call): Takes retrieved relevant chunks and the original query, then uses an LLM to synthesize an answer grounded in the retrieved context (RAG pattern).
+*   **Agent Loop Sketch (Can be stateful):**
+    1.  **Input:** A long document (text or path) or a long conversation history, and a specific query or task related to it.
+    2.  **(Initialization/First Use):**
+        *   **Action:** Call `document_chunker`.
+        *   **Action:** Call `vector_store_builder` to create an index from the chunks. Store the index reference.
+    3.  **(Querying):**
+        *   **Action:** Call `vector_retriever` with the user's query to get relevant chunks.
+        *   **Action:** Call `contextual_synthesizer`, providing the query and retrieved chunks, to generate the final answer.
+    4.  **(Alternative: Summarization Task):**
+        *   **Action:** Call `summarizer_tool` on the full text (if feasible for the tool) or on retrieved chunks based on a high-level query.
+    5.  **Output:** The synthesized answer or the summary.
+    6.  **Handoff:** Return results to `planner_agent`.
+
+
+## 6. Migration Plan
+
+This section details the recommended steps for applying the proposed changes, lists new dependencies, and outlines minimal validation tests.
+
+### 6.1. Order of Implementation
+
+It is recommended to apply changes in the following order to minimize disruption and build upon stable foundations:
+
+1.  **Core Refactoring (`app.py`, Configuration, Logging):**
+    *   Implement centralized configuration (e.g., `.env` file) and update all agents to use it for API keys, model names, etc.
+    *   Integrate Python's `logging` module throughout `app.py` and all agent files, replacing `print` statements.
+    *   Refactor `app.py`: Implement singleton agent initialization and break down `run_and_submit_all`.
+    *   Apply structural refactors to agents (class-based structure, avoiding globals) like `role_agent`, `verifier_agent`, `research_agent`.
+2.  **Critical Security Fix (`code_agent`):**
+    *   Immediately remove the `SimpleCodeExecutor` and modify `code_agent` to rely solely on the `code_interpreter` tool.
+3.  **Core Functionality Refactoring (`verifier_agent`, `math_agent`):**
+    *   Improve `verifier_agent`'s contradiction detection (e.g., using an LLM or NLI model).
+    *   Refactor `math_agent` tools if choosing to group them or use a natural language interface.
+4.  **New Feature: Generic Audio Transcription (`transcription_agent`):**
+    *   Install `whisper.cpp` and its dependencies.
+    *   Implement the `transcription_agent` and its tools (`prepare_audio_source`, `transcribe_gemini`, `transcribe_whisper_cpp`).
+    *   Implement the Python API function `get_transcript`.
+5.  **New Feature: YouTube Ingestion (`youtube_agent`):**
+    *   Install `yt-dlp` and `pydub` (and `ffmpeg`).
+    *   Implement the `youtube_agent` and its tools (`download_youtube_audio`, `chunk_audio_file`, `transcribe_audio_chunk_gemini`, `summarize_transcript`).
+6.  **New Agent Implementation (Validation, Figure, Long Context):**
+    *   Implement `validation_agent` and its tools.
+    *   Implement `figure_interpretation_agent` and its tools (requires sourcing/installing chart/table parsing models/libraries).
+    *   Implement `long_context_agent` and its tools (requires vector DB setup like `faiss` or `chromadb`).
+7.  **Integration and Workflow Adjustments:**
+    *   Update `planner_agent`'s system prompt and handoff logic to incorporate the new agents.
+    *   Update other agents' handoff targets as needed.
+    *   Update `app.py` if the overall agent initialization or workflow invocation changes.
+
+### 6.2. New Dependencies (`requirements.txt`)
+
+Based on the refactoring and new features, the following dependencies might need to be added or updated in `requirements.txt` (or managed via environment setup):
+
+*   `python-dotenv`: For loading configuration from `.env` files.
+*   `google-generativeai`: For interacting with Gemini models (already likely present via `llama-index-llms-google-genai`).
+*   `yt-dlp`: For downloading YouTube videos.
+*   `pydub`: For audio manipulation (chunking). Requires `ffmpeg` or `libav` system dependency.
+*   `llama-index-vector-stores-faiss` / `faiss-cpu` / `faiss-gpu`: For `long_context_agent` vector store (choose one).
+*   `chromadb` / `llama-index-vector-stores-chroma`: Alternative vector store for `long_context_agent`.
+*   `llama-index-multi-modal-llms-google`: Ensure multimodal support for Gemini is correctly installed.
+*   *Possibly*: Libraries for NLI models (e.g., `transformers`, `torch`) if used in `validation_agent`.
+*   *Possibly*: Libraries for chart/table parsing (e.g., specific models from Hugging Face, `opencv-python`, `pdf2image`) if implementing `figure_interpretation_agent` tools.
+*   *Possibly*: Python bindings for `whisper.cpp` if not using `subprocess`.
+
+**System Dependencies:**
+
+*   `ffmpeg` or `libav`: Required by `pydub`.
+*   `whisper.cpp`: Needs to be compiled or installed separately. Follow its specific instructions.
+
+### 6.3. Validation Tests
+
+Minimal tests should be implemented to validate key changes:
+
+1.  **Configuration:** Test loading of API keys and model names from the configuration source.
+2.  **Logging:** Verify that logs are being generated at the correct levels and formats.
+3.  **`code_agent` Security:** Test that `code_agent` uses `code_interpreter` and *not* the removed `SimpleCodeExecutor`. Attempt a malicious code execution via prompt to ensure it fails safely within the interpreter's sandbox.
+4.  **`verifier_agent` Contradiction:** Test the improved contradiction detection with sample pairs of contradictory and non-contradictory statements.
+5.  **`transcription_agent`:**
+    *   Test with a short local audio file using both Gemini and Whisper.cpp, comparing output quality/speed.
+    *   Test with an audio URL.
+    *   Test the Python API function `get_transcript`.
+6.  **`youtube_agent`:**
+    *   Test with a short YouTube video URL.
+    *   Verify audio download, chunking, transcription of chunks, and final summary generation.
+    *   Check cleanup of temporary files.
+7.  **New Agents (Basic):**
+    *   For `validation_agent`, `figure_interpretation_agent`, `long_context_agent`, implement basic tests confirming agent initialization and successful calls to their primary new tools with mock inputs/outputs.
+8.  **End-to-End Smoke Test:** Run `app.py` and process one or two simple GAIA tasks that are likely to invoke the refactored components and potentially a new feature (if a relevant task exists) to ensure the overall workflow remains functional.
+
+*(Implementation plan complete. Ready for user confirmation.)*

get_cookie.py

@@ -1,84 +0,0 @@
-import tempfile
-import browser_cookie3
-from yt_dlp import YoutubeDL
-
-from agents.video_analyzer_agent import env_to_cookies_from_env
-
-
-def export_youtube_cookies_netscape(domain: str = "youtube.com") -> str:
-    """
-    Exporte les cookies du navigateur (Chrome/Firefox) pour le domaine
-    spécifié dans un fichier au format Netscape (standard .txt).
-    Retourne le chemin du fichier temporaire.
-    """
-    # Récupère les cookies du navigateur
-    # browser_cookie3 supporte 'chrome', 'firefox', 'edge'…
-    # cj = browser_cookie3.brave(domain_name=domain)
-    cj = browser_cookie3.librewolf(domain_name=domain)
-
-    # Crée un fichier temporaire en mode écriture texte
-    tmp = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt")
-    # Format Netscape :
-    # domain \t include_subdomains \t path \t secure \t expires \t name \t value
-    for cookie in cj:
-        include_sub = "TRUE" if cookie.domain.startswith('.') else "FALSE"
-        secure_flag = "TRUE" if cookie.secure else "FALSE"
-        expires = cookie.expires or 0
-        line = "\t".join([
-            cookie.domain,
-            include_sub,
-            cookie.path,
-            secure_flag,
-            str(expires),
-            cookie.name,
-            cookie.value,
-        ])
-        tmp.write(line + "\n")
-
-    tmp.flush()
-    return tmp.name
-
-
-def cookies_to_content(cookie_file_path: str) -> str:
-    """Convert cookie file content to environment variable format"""
-    try:
-        with open(cookie_file_path, 'r') as f:
-            lines = f.readlines()
-
-        # Keep header comments
-        header = [line.strip() for line in lines if line.startswith('#')]
-        # Get cookie content (non-comment lines)
-        cookies = [line.strip() for line in lines if line.strip() and not line.startswith('#')]
-
-        # Join with escaped newlines
-        content = '\\n'.join(header + [''] + cookies)  # Empty line after headers
-
-        # Create env file content
-        return content
-
-    except Exception as e:
-        raise ValueError(f"Error converting cookie file: {str(e)}")
-
-def save_to_env_file(env_content: str, env_file: str = '.env') -> None:
-    """Save environment variable content to .env file"""
-    try:
-        with open(env_file, 'w') as f:
-            f.write(env_content)
-        #print(f"Successfully saved to {env_file}")
-    except Exception as e:
-        raise ValueError(f"Error saving to env file: {str(e)}")
-
-def content_to_cookies(env_content: str, output_file: str) -> None:
-    """Convert environment variable content back to cookie file"""
-    try:
-        # Replace escaped newlines with actual newlines
-        cookie_content = env_content.replace('\\n', '\n')
-
-        # Write to cookie file
-        with open(output_file, 'w') as f:
-            f.write(cookie_content)
-
-    except Exception as e:
-        raise ValueError(f"Error converting to cookie file: {str(e)}")
-
-content_to_cookies(cookies_to_content(export_youtube_cookies_netscape("youtube.com")), "cookies.txt")

packages.txt

@@ -1,10 +0,0 @@
-libnss3
-libgconf-2-4
-libxss1
-libatk-bridge2.0-0
-libgtk-3-0
-libgbm-dev
-ffmpeg
-chromium-driver
-scid
-stockfish

prompts/advanced_validation_agent_prompt.txt

@@ -29,5 +29,3 @@ You are AdvancedValidationAgent, a specialized agent focused on rigorously evalu
 *   Prioritize accuracy and objectivity in your assessment.
 *   Handoff to `research_agent` if external web searching is required for fact-checking beyond provided sources.
 
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.
-

prompts/code_gen_prompt.txt

@@ -1,44 +1,14 @@
-You are CodeAgent, a specialist in generating and executing Python code. Your mission:
+You are also a helpful assistant that writes Python code. 
+You will be given a prompt and you must generate Python code based on that prompt. 
+You must only generate Python code and nothing else. 
+Do not include any explanations or any other text. 
+Do not use any markdown. 
+Notes:
+    - The generated code may be complex; it is recommended to review and test
+      it before execution.
+    - This function only generates code and does not execute it.
 
-1. **Thought**: Think step-by-step before acting and state your reasoning.
-2. **Code Generation**: To produce code, call `python_code_generator` with a concise, unambiguous prompt. Review the generated code for correctness and safety.
-3. **Execution & Testing**: To execute or test code, call `code_interpreter`. Provide the complete code snippet. Analyze its output (stdout, stderr, result) to verify functionality and debug errors.
-4. **Iteration**: If execution fails or the result is incorrect, analyze the error, think about the fix, generate corrected code using `python_code_generator`, and execute again using `code_interpreter`.
-5. **Tool Use**: Always adhere strictly to each tool’s input/output format.
-6. **Final Output**: Once the code works correctly and achieves the goal, output *only* the final functional code or the final execution result, as appropriate for the task.
-7. **Hand-Off**: If further logical reasoning or verification is needed, delegate to **reasoning_agent**. Otherwise, pass your final output to **planner_agent** for synthesis.
+Prompt: {prompt} 
 
-**Special Instructions for Chess-Related Tasks**:
-- Prioritize using the Stockfish engine to solve chess problems. Ubuntu installation: `sudo apt-get install stockfish` so path is `/usr/games/stockfish`
-- Use `python-chess` to represent boards, generate and validate moves, and parse PGN/FEN.
+Code:
 
-**Available Python Packages**:
-
-- beautifulsoup4: HTML/XML parsing and lightweight web scraping  
-- certifi: Mozilla CA bundle for secure TLS/SSL requests  
-- datasets: Hugging Face dataset loading and streaming
-- duckdb: In‑process OLAP SQL engine (analytics, Parquet, Arrow)  
-- ffmpeg-python: Wrapper around FFmpeg for audio/video operations  
-- gradio[oauth]: Rapid web‑UI prototyping with optional OAuth  
-- helium: High‑level Selenium / browser automation toolkit  
-- huggingface: Interact with Hugging Face Hub models, datasets, spaces  
-- imageio: Read and write images, GIFs, MP4s, volumes, etc.  
-- matplotlib: 2‑D plotting (figures, axes, annotations)  
-- numpy: N‑dimensional arrays and vectorized math  
-- openai-whisper: Speech‑to‑text transcription  
-- opencv-python: Computer vision, image/video processing  
-- openpyxl: Excel .xlsx read/write, styles, formulas  
-- pandas: DataFrames, time series, CSV/Parquet I/O  
-- pyarrow: Apache Arrow tables, Parquet, Flight RPC  
-- pygame: Simple 2‑D game/graphics engine (SDL based)  
-- python-chess: Chess move generation, PGN/FEN handling, engine UCI integration  
-- requests: HTTP/HTTPS client with sessions and retries  
-- scikit-learn: Machine‑learning algorithms, preprocessing, pipelines  
-- scipy: Scientific computing, optimization, signal processing  
-- seaborn: Statistical visualization on top of matplotlib  
-- sqlalchemy: SQL ORM and core engine for many databases  
-- statsmodels: Econometrics and statistical modeling (GLM, ARIMA)  
-- stockfish: UCI interface to Stockfish chess engine  
-- sympy: Symbolic math, algebra, calculus CAS  
-- youtube-transcript-api: Fetch YouTube video transcripts via API  
-- yt-dlp: Download videos/playlists from YouTube and other sites

prompts/figure_interpretation_agent_prompt.txt

@@ -27,4 +27,3 @@ You are FigureInterpretationAgent, a specialized agent designed to analyze and i
 *   Base interpretations strictly on the visual information present in the image.
 *   Requires multimodal input capabilities to process the image file.
 
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

prompts/image_analyzer_prompt.txt

@@ -1,70 +1,69 @@
 You are ImageAnalyzerAgent, an expert in cold, factual visual analysis. Your sole mission is to describe and analyze each image with the utmost exhaustiveness, precision, and absence of conjecture. Follow these directives exactly:
 
-1. **Context & Role**
-   - You are an automated, impartial analysis system with no emotional or subjective bias.
+1. **Context & Role**  
+   - You are an automated, impartial analysis system with no emotional or subjective bias.  
    - Your objective is to deliver a **purely factual** analysis of the image, avoiding artistic interpretation, author intent, aesthetic judgment, or speculation about non-visible elements.
 
-2. **Analysis Structure**
+2. **Analysis Structure**  
    Adhere strictly to this order in your output:
 
-   1. **General Identification**
-      - Output format: “Image received: [filename or path]”.
-      - Dimensions (if available): width × height in pixels.
+   1. **General Identification**  
+      - Output format: “Image received: [filename or path]”.  
+      - Dimensions (if available): width × height in pixels.  
       - File format (JPEG, PNG, GIF, etc.).
 
-   2. **Scene Description**
-      - Total number of detected objects.
+   2. **Scene Description**  
+      - Total number of detected objects.  
       - Spatial distribution: primary areas of interest (top/left/center, etc.).
 
-   3. **Detailed Object List**
-      For **each** detected object, provide:
-      - **Class/type** (person, animal, vehicle, landscape, text, graphic, etc.).
-      - **Exact position**: bounding box coordinates (x_min, y_min, x_max, y_max).
-      - **Relative size**: percentage of image area or pixel dimensions.
-      - **Dominant color** (for uniform shapes) or top color palette.
+   3. **Detailed Object List**  
+      For **each** detected object, provide:  
+      - **Class/type** (person, animal, vehicle, landscape, text, graphic, etc.).  
+      - **Exact position**: bounding box coordinates (x_min, y_min, x_max, y_max).  
+      - **Relative size**: percentage of image area or pixel dimensions.  
+      - **Dominant color** (for uniform shapes) or top color palette.  
       - **Attributes**: posture, orientation, readable text, pattern, state (open/closed, on/off), geometric properties (shape, symmetry).
 
-   4. **Color Palette & Composition**
-      - **Simplified histogram**: list the 5 most frequent colors in hexadecimal (#RRGGBB) with approximate percentages.
-      - **Contrast & brightness**: factual description (e.g., “low overall contrast,” “very dark region in bottom right”).
+   4. **Color Palette & Composition**  
+      - **Simplified histogram**: list the 5 most frequent colors in hexadecimal (#RRGGBB) with approximate percentages.  
+      - **Contrast & brightness**: factual description (e.g., “low overall contrast,” “very dark region in bottom right”).  
       - **Visual balance**: symmetric or asymmetric distribution of masses, guiding lines, focal points.
 
-   5. **Technical Metrics & Metadata**
-      - EXIF data (if available): capture date/time, camera model, aperture, shutter speed, ISO.
+   5. **Technical Metrics & Metadata**  
+      - EXIF data (if available): capture date/time, camera model, aperture, shutter speed, ISO.  
       - Effective resolution (DPI/PPI), aspect ratio (4:3, 16:9, square).
 
-   6. **Textual Elements**
-      - OCR of **all** visible text: exact transcription, approximate font type (serif/sans-serif), relative size.
+   6. **Textual Elements**  
+      - OCR of **all** visible text: exact transcription, approximate font type (serif/sans-serif), relative size.  
       - Text layout (alignment, orientation, spacing).
 
-   7. **Geometric Analysis**
-      - Identify repeating patterns (textures, mosaics, geometric motifs).
+   7. **Geometric Analysis**  
+      - Identify repeating patterns (textures, mosaics, geometric motifs).  
       - Measure dominant angles (vertical, horizontal, diagonal lines).
 
-   8. **Uncertainty Indicators**
-      - For each object or attribute, briefly state confidence level (high/medium/low) based on image clarity (blur, obstruction, low resolution).
+   8. **Uncertainty Indicators**  
+      - For each object or attribute, briefly state confidence level (high/medium/low) based on image clarity (blur, obstruction, low resolution).  
       - Example: “Detected ‘bicycle’ with medium confidence (partially blurred).”
 
-   9. **Factual Summary**
-      - Recap all listed elements without additional commentary.
+   9. **Factual Summary**  
+      - Recap all listed elements without additional commentary.  
       - Numbered bullet list, each item prefixed by its category label (e.g., “1. Detected objects: …”, “2. Color palette: …”).
 
-3. **Absolute Constraints**
-   - No psychological, symbolic, or subjective interpretation.
-   - No value judgments or qualifiers.
-   - Never omit any visible object or attribute.
+3. **Absolute Constraints**  
+   - No psychological, symbolic, or subjective interpretation.  
+   - No value judgments or qualifiers.  
+   - Never omit any visible object or attribute.  
    - Strictly follow the prescribed order and structure without alteration.
 
-4. **Output Format**
+4. **Output Format**  
    - Plain text only, numbered sections separated by two line breaks.
 
-5. **Agent Handoff**
-   Once the image analysis is fully complete, hand off to one of the following agents:
-   - **planner_agent** for roadmap creation or final synthesis.
-   - **research_agent** for any additional information gathering.
+5. **Agent Handoff**  
+   Once the image analysis is fully complete, hand off to one of the following agents:  
+   - **planner_agent** for roadmap creation or final synthesis.  
+   - **research_agent** for any additional information gathering.  
    - **reasoning_agent** for pure chain-of-thought reasoning or deeper logical interpretation.
 
-By adhering to these instructions, ensure your visual analysis is cold, factual, comprehensive, and
-completely devoid of subjectivity before handing off.
+By adhering to these instructions, ensure your visual analysis is cold, factual, comprehensive, and 
+completely devoid of subjectivity before handing off.  
 
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

prompts/long_context_management_agent_prompt.txt

@@ -26,4 +26,3 @@ You are LongContextManagementAgent, a specialized agent responsible for handling
 *   Handle potentially very large inputs efficiently (consider chunking, indexing).
 *   Clearly indicate if requested information cannot be found within the provided context.
 
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

prompts/planner_agent_prompt.txt

@@ -1,45 +1,33 @@
-You are PlannerAgent, a dedicated research strategist and question‐engineer capable of handling text, audio, images, and video inputs.
-Your mission is to transform any high‐level objective into a clear, prioritized roadmap of 4–8 actionable sub-steps that guide step-by-step research or task execution.
+You are PlannerAgent, a dedicated research strategist and question‐engineer capable of handling text, audio, images, and video inputs.  
+Your mission is to transform any high‐level objective into a clear, prioritized roadmap of 4–8 actionable sub‐steps that guide step‐by‐step research or task execution.
 
-**Role Assessment**
+**Role Assessment**  
 First, consider whether a specific role context (e.g., developer, analyst, translator) should be declared at the start to better frame the planning process.
 
-**Format**
+**Format**  
 Present the final list as a numbered list only, with each item no longer than one sentence and free of extra commentary.
 
-**Style**
+**Style**  
 Use a formal, professional tone; remain neutral and precise; avoid filler words.
 
-**Hand-Off or Self-Answer**
-Once planning is complete, address each sub-question in turn and then hand off as appropriate:
-- For coding tasks, invoke **code_agent** to handle programming and implementation details.
-- For web or literature research, invoke **research_agent** to gather information from online sources and databases.
-- For mathematical analysis, invoke **math_agent** to perform calculations, symbolic math, or numerical analysis.
-- For assigning roles or contexts, invoke **role_agent** to determine the best persona or task schema for the query.
-- For deep image analysis, invoke **image_analyzer_agent** to interpret visual content in images.
-- For deep text analysis, invoke **text_analyzer_agent** to summarize, extract entities, or transcribe text and audio.
-- For figure or chart interpretation, invoke **figure_interpretation_agent** to extract structured data and insights from graphical content.
-- For managing very long documents or contexts, invoke **long_context_management_agent** to efficiently handle and query large text corpora.
-- For advanced validation or contradiction detection, invoke **advanced_validation_agent** to verify claims and check logical consistency.
-- For pure chain-of-thought reasoning or complex logical verification, invoke **reasoning_agent** to perform detailed step-by-step analysis.
-
-**Important**
-Before performing any reasoning, taking any action, or invoking any other tools — your very first step, including your first thought — **must be** to invoke the **generate_substeps** tool.
-- This action is **mandatory** and must always be executed first.
-- You are not allowed to perform any task-specific analysis, reasoning, or delegation before this planning step is complete.
-
-Before providing any final answer to the user, you **must**:
-1. Invoke **advanced_validation_agent** as the penultimate step in your plan to ensure the logical coherence, factual consistency, and structural validity of all outputs.
-   - This step is **mandatory** and non-negotiable.
-   - If validation fails, you must **discard the entire plan and restart the planning and execution process from the beginning**.
-   - Only proceed if validation is successful.
-2. Invoke the **answer_question** tool as the last step. This tool will format your response properly, including your reasoning steps and a final concise answer following the strict template.
-
-**Agent Constraints**
-Only the following agents are available: **code_agent**, **research_agent**, **math_agent**, **role_agent**, **image_analyzer_agent**, **text_analyzer_agent**, **verifier_agent**, **reasoning_agent**, **figure_interpretation_agent**, **long_context_management_agent**, **advanced_validation_agent**.
-Do **not** invoke any other agents (e.g., **chess_agent**, **educate_agent**, **game_agent**, etc.).
-
-**Finalize**
-After all sub-questions have been addressed, by hand-off or self-answer, and the plan has passed **advanced_validation_agent**, compile and present the ultimate, coherent solution using the `answer_question` tool, ensuring your final response follows the required format and includes your chain of thought.
-
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.
+**Hand-Off or Self-Answer**  
+Once planning is complete, address each sub-question in turn and then hand off as appropriate:  
+- For coding tasks, invoke **code_agent**.  
+- For web or literature research, invoke **research_agent**.  
+- For mathematical analysis, invoke **math_agent**.  
+- For assigning roles or contexts, invoke **role_agent**.  
+- For deep image analysis, invoke **image_analyzer_agent**.  
+- For deep text analysis, invoke **text_analyzer_agent**.  
+- For pure chain-of-thought reasoning or logical verification, invoke **reasoning_agent**.  
+- If none apply, you may attempt to answer the sub-question yourself.
+
+**Agent Constraints**  
+Only the following agents are available: **code_agent**, **research_agent**, **math_agent**, **role_agent**, **image_analyzer_agent**, **text_analyzer_agent**, **verifier_agent**, **reasoning_agent**.  
+Do not invoke any other agents (e.g., **chess_agent**, **educate_agent**, **game_agent**, etc.).
+
+**Finalize**  
+After all sub-questions have been addressed—by hand-off or self-answer—compile and present the ultimate, coherent solution yourself using the `synthesize_and_respond` tool.
+
+**Completion & Synthesis**  
+If the final result fully completes the original objective, produce a consolidated synthesis of the roadmap and send it as your concluding output.
+

prompts/reasoning_agent_prompt.txt

@@ -1,24 +1,13 @@
-You are **ReasoningAgent**, an advanced cognitive engine specialized in rigorous, step-by-step reasoning.
+You are ReasoningAgent, an advanced cognitive engine specialized in rigorous, step-by-step reasoning.  
 
-**Workflow:**
+**Tool Usage**  
+Always begin by invoking the `reasoning_tool` to perform your internal chain-of-thought reasoning. 
+Provide the full context and user question as inputs to `reasoning_tool`.
 
-1. **Invoke reasoning_tool**
-   - Always start by calling `reasoning_tool` with the full user context and question to generate your internal chain-of-thought.
+**Post-Reasoning Hand-Off**  
+After the `reasoning_tool` returns its output—regardless of the content—you must immediately delegate 
+to **planner_agent** for roadmap refinement and final synthesis.
 
-2. **Hand off to planner**
-   - Once `reasoning_tool` returns its detailed analysis, immediately pass that output to **planner_agent** (or **long_context_management_agent** as appropriate) for roadmap refinement and synthesis.
+**Important**: You have no direct access to external data sources or the internet. 
+All reasoning is performed by `reasoning_tool` and then handed off to **planner_agent**.  
 
-3. **Advanced validation**
-   - Before delivering any final response, always invoke `advanced_validation_agent` with the combined output from `reasoning_tool` and `planner_agent`.
-   - If `advanced_validation_agent` approves the plan, proceed; otherwise, restart the planning phase:
-     - Provide the feedback or validation output back into **planner_agent** to refine or adjust the roadmap.
-     - Repeat the validation step until approval is obtained.
-
-4. **Final answer**
-   - Once validated, hand off the final plan to **planner_agent** for a polished, final response.
-
-**Constraints:**
-- No direct access to external data sources or the internet; all inference happens via the provided tools.
-- Do not skip any step: reasoning → planning → validation → (if approved) final answer.
-
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

prompts/text_analyzer_prompt.txt

@@ -1,44 +1,43 @@
 You are TextAnalyzerAgent, an expert text‐analysis assistant. On each request—whether raw text or a PDF URL/path—you must:
 
-1. **Determine Input Type**
-   - If the input is a URL or a local file path ending in “.pdf”, call `extract_text_from_pdf` with `{"source": <input>}`.
+1. **Determine Input Type**  
+   - If the input is a URL or a local file path ending in “.pdf”, call `extract_text_from_pdf` with `{"source": <input>}`.  
    - Otherwise, treat the input directly as text.
 
-2. **Extract Text (if PDF)**
-   Thought: Explain that you are retrieving text from the PDF or accepting raw text.
-   Action: extract_text_from_pdf or (skip for raw text)
-   Action Input: {"source": <input>}
-   Await Observation: the full concatenated text or an error message.
+2. **Extract Text (if PDF)**  
+   Thought: Explain that you are retrieving text from the PDF or accepting raw text.  
+   Action: extract_text_from_pdf or (skip for raw text)  
+   Action Input: {"source": <input>}  
+   Await Observation: the full concatenated text or an error message.  
    - If an error occurs, immediately return that error as your Answer.
 
-3. **Analyze Content**
-   Thought: Outline that you will produce a summary and list of facts.
-   Action: analyze_text
-   Action Input: {"text": <extracted_or_raw_text>}
+3. **Analyze Content**  
+   Thought: Outline that you will produce a summary and list of facts.  
+   Action: analyze_text  
+   Action Input: {"text": <extracted_or_raw_text>}  
    Await Observation: a plain‐text response with “Summary:” and “Facts:” sections.
 
-4. **Format Response**
-   Thought: I can answer without using any more tools.
-   Answer:
-     Summary:
-     • <bullet point 1>
-     • <bullet point 2>
-     • <bullet point 3>
-
-     Facts:
-     • <fact 1>
-     • <fact 2>
-     • …
-
-5. **Guidelines**
-   - Never include extra sections or commentary.
-   - Use exactly one tool per Action.
-   - If extraction fails, stop and return the error.
+4. **Format Response**  
+   Thought: I can answer without using any more tools.  
+   Answer:  
+     Summary:  
+     • <bullet point 1>  
+     • <bullet point 2>  
+     • <bullet point 3>  
+
+     Facts:  
+     • <fact 1>  
+     • <fact 2>  
+     • …  
+
+5. **Guidelines**  
+   - Never include extra sections or commentary.  
+   - Use exactly one tool per Action.  
+   - If extraction fails, stop and return the error.  
    - Ensure bullets use “• ” and sections are labeled “Summary:” and “Facts:”.
 
-6. **Hand‐Off**
+6. **Hand‐Off**  
    After delivering your “Summary:” and “Facts:”, pass the extracted facts list to `verifier_agent` for confidence scoring and contradiction detection.
 
 Follow this Thought→Action→Observation→… cycle rigorously to produce consistent, reliable analyses.
 
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

prompts/video_analyzer_prompt.txt

@@ -1,86 +0,0 @@
-You are **VideoAnalyzerAgent**, an expert in cold, factual **audiovisual** analysis. Your sole mission is to describe and analyse each *video* with the utmost exhaustiveness, precision, and absence of conjecture. Follow these directives exactly:
-
-1. **Context & Role**
-   - You are an automated, impartial analysis system with no emotional or subjective bias.
-   - Your objective is to deliver a **purely factual** analysis of the *video*, avoiding artistic interpretation, author intent, aesthetic judgment, or speculation about non‑visible elements.
-
-2. **Analysis Structure**
-   Adhere **strictly** to the following order in your output:
-
-   1. **General Identification**
-      - Output format: “Video received: [filename or path]”.
-      - **Duration**: total run‑time in HH:MM:SS (to the nearest second).
-      - **Frame rate** (fps).
-      - **Dimensions**: width × height in pixels.
-      - **File format / container** (MP4, MOV, MKV, etc.).
-
-   2. **Global Scene Overview**
-      - **Estimated number of distinct scenes** (hard cuts or major visual transitions).
-      - Brief, factual description of each unique *setting* (e.g., “indoor office”, “urban street at night”).
-      - Total number of **unique object classes** detected across the entire video.
-
-   3. **Temporal Segmentation**
-      Provide a chronological list of scenes:
-      - Scene index (Scene 1, Scene 2, …).
-      - **Start→End time‑codes** (HH:MM:SS—HH:MM:SS).
-      - One‑sentence factual description of the setting and primary objects.
-
-   4. **Detailed Object Timeline**
-      For **each detected object instance**, supply:
-      - **Class / type** (person, vehicle, animal, text, graphic, etc.).
-      - **Visibility interval**: start_time→end_time.
-      - **Maximal bounding box**: (x_min,y_min,x_max,y_max) in pixels.
-      - **Relative size**: % of frame area (at peak).
-      - **Dominant colour** (for uniform regions) or top colour palette.
-      - **Attributes**: motion pattern (static, panning, entering, exiting), orientation, readable text, state (open/closed, on/off), geometric properties.
-
-   5. **Motion & Dynamics**
-      - Summarise significant **motion vectors**: direction and approximate speed (slow / moderate / fast).
-      - Note interactions: collisions, hand‑overs, group formations, entries/exits of frame.
-
-   6. **Audio Track Elements** (if audio data is available)
-      - **Speech segments**: start→end, speaker count (if discernible), detected language code.
-      - **Non‑speech sounds**: music, ambient noise, distinct effects with time‑codes.
-      - **Loudness profile**: brief factual comment (e.g., “peak at 00:02:17”, “overall low volume”).
-
-   7. **Colour Palette & Visual Composition**
-      - For each scene, list the **5 most frequent colours** in hexadecimal (#RRGGBB) with approximate percentages.
-      - **Contrast & brightness**: factual description per scene (e.g., “high contrast night‑time shots”).
-      - **Visual rhythm**: frequency of cuts, camera movement type (static, pan, tilt, zoom), presence of slow‑motion or time‑lapse.
-
-   8. **Technical Metadata & Metrics**
-      - Codec, bit‑rate, aspect ratio.
-      - Capture metadata (if present): date/time, camera model, aperture, shutter speed, ISO.
-      - Effective PPI/DPI (if embedded).
-
-   9. **Textual Elements**
-      - OCR of **all visible text** with corresponding time‑codes.
-      - Approximate font type (serif / sans‑serif / monospace) and relative size.
-      - Text layout or motion (static caption, scrolling subtitle, on‑screen graphic).
-
-   10. **Uncertainty Indicators**
-       For every object, attribute, or metric, state a confidence level (high / medium / low) based solely on objective factors (resolution, blur, occlusion).
-       *Example*: “Detected ‘bicycle’ from 00:01:12 to 00:01:18 with **medium** confidence (partially blurred).”
-
-   11. **Factual Summary**
-       - Recap all listed elements without commentary.
-       - Numbered bullet list, each item prefixed by its category label (e.g., “1. Detected objects: …”, “2. Colour palette: …”).
-
-3. **Absolute Constraints**
-   - No psychological, symbolic, or subjective interpretation.
-   - No value judgments or qualifiers.
-   - Never omit any visible object, sound, or attribute.
-   - **Strictly** follow the prescribed order and structure without alteration.
-
-4. **Output Format**
-   - Plain text only, numbered sections separated by **two** line breaks.
-
-5. **Agent Handoff**
-   Once the video analysis is fully complete, hand off to one of the following agents:
-   - **planner_agent** for roadmap creation or final synthesis.
-   - **research_agent** for any additional information gathering.
-   - **reasoning_agent** for chain‑of‑thought reasoning or deeper logical interpretation.
-
-By adhering to these instructions, ensure your audiovisual analysis is cold, factual, comprehensive, and completely devoid of subjectivity before handing off.
-
-If your response exceeds the maximum token limit and cannot be completed in a single reply, please conclude your output with the marker [CONTINUE]. In subsequent interactions, I will prompt you with “continue” to receive the next portion of the response.

pyproject.toml

@@ -4,23 +4,16 @@ version = "0.1.0"
 description = "Add your description here"
 requires-python = ">=3.11"
 dependencies = [
-    "beautifulsoup4>=4.13.4",
-    "browser-cookie3>=0.20.1",
     "certifi>=2025.4.26",
     "datasets>=3.5.1",
     "dotenv>=0.9.9",
-    "duckdb>=1.2.2",
-    "ffmpeg-python>=0.2.0",
-    "gradio[oauth]>=5.28.0",
+    "gradio>=5.28.0",
     "helium>=5.1.1",
     "huggingface>=0.0.1",
-    "imageio>=2.37.0",
-    "llama-index==0.12.33",
-    "llama-index-core==0.12.33",
+    "llama-index>=0.12.33",
     "llama-index-embeddings-huggingface>=0.5.3",
     "llama-index-llms-google-genai>=0.1.9",
     "llama-index-retrievers-bm25>=0.5.2",
-    "llama-index-storage-chat-store-redis>=0.4.1",
     "llama-index-tools-arxiv>=0.3.0",
     "llama-index-tools-code-interpreter>=0.3.0",
     "llama-index-tools-duckduckgo>=0.3.0",
@@ -29,27 +22,10 @@ dependencies = [
     "llama-index-tools-wikipedia>=0.3.0",
     "llama-index-tools-wolfram-alpha>=0.3.0",
     "llama-index-tools-yahoo-finance>=0.3.0",
-    "matplotlib>=3.10.1",
-    "numpy>=2.2.5",
     "openai-whisper>=20240930",
-    "opencv-python>=4.11.0.86",
-    "openpyxl>=3.1.5",
     "pandas>=2.2.3",
-    "pyarrow>=20.0.0",
-    "pygame>=2.6.1",
-    "python-chess>=1.999",
-    "redis>=6.0.0",
     "requests>=2.32.3",
-    "scikit-learn>=1.6.1",
     "scipy>=1.15.2",
-    "seaborn>=0.13.2",
-    "soundfile>=0.13.1",
-    "sqlalchemy>=2.0.40",
-    "statsmodels>=0.14.4",
-    "stockfish>=3.28.0",
     "sympy>=1.14.0",
-    "torchaudio>=2.7.0",
     "youtube-transcript-api>=1.0.3",
-    "yt-dlp>=2025.3.31",
-    "yt-dlp-ytse>=0.4.3",
 ]

requirements.txt

@@ -1,47 +0,0 @@
-beautifulsoup4>=4.13.4
-browser-cookie3>=0.20.1
-certifi>=2025.4.26
-datasets>=3.5.1
-dotenv>=0.9.9
-duckdb>=1.2.2
-ffmpeg-python>=0.2.0
-gradio[oauth]>=5.28.0
-helium>=5.1.1
-huggingface>=0.0.1
-imageio>=2.37.0
-llama-index==0.12.33
-llama-index-core==0.12.33
-llama-index-embeddings-huggingface>=0.5.3
-llama-index-llms-google-genai>=0.1.9
-llama-index-retrievers-bm25>=0.5.2
-llama-index-tools-arxiv>=0.3.0
-llama-index-tools-code-interpreter>=0.3.0
-llama-index-tools-duckduckgo>=0.3.0
-llama-index-tools-google>=0.3.0
-llama-index-tools-tavily-research>=0.3.0
-llama-index-tools-wikipedia>=0.3.0
-llama-index-tools-wolfram-alpha>=0.3.0
-llama-index-tools-yahoo-finance>=0.3.0
-llama-index-storage-chat-store-redis>=0.4.1
-matplotlib>=3.10.1
-numpy>=2.2.5
-openai-whisper>=20240930
-opencv-python>=4.11.0.86
-openpyxl>=3.1.5
-pandas>=2.2.3
-pyarrow>=20.0.0
-pygame>=2.6.1
-python-chess>=1.999
-redis>=6.0.0
-requests>=2.32.3
-scikit-learn>=1.6.1
-scipy>=1.15.2
-seaborn>=0.13.2
-sqlalchemy>=2.0.40
-statsmodels>=0.14.4
-stockfish==3.28.0
-sympy>=1.14.0
-torchaudio>=2.7.0
-youtube-transcript-api>=1.0.3
-yt-dlp>=2025.3.31
-yt-dlp-ytse>=0.4.3