Lot's of changes

agents/advanced_validation_agent.py

@@ -45,7 +45,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", "models/gemini-1.5-pro") # Use a capable model
+    llm_model = os.getenv("VALIDATION_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # 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 +53,7 @@ def cross_reference_check(claim: str, sources_content: List[Dict[str, str]]) ->
 
     results = []
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using cross-referencing LLM: {llm_model}")
 
         for i, source in enumerate(sources_content):
@@ -114,7 +114,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", "models/gemini-1.5-pro")
+    llm_model = os.getenv("VALIDATION_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 for consistency check LLM.")
@@ -138,7 +138,7 @@ def logical_consistency_check(text: str) -> Dict[str, Union[bool, str, List[str]
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model, response_mime_type="application/json")
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using consistency check LLM: {llm_model}")
         response = llm.complete(prompt)
         
@@ -174,7 +174,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", "models/gemini-1.5-pro")
+    llm_model = os.getenv("VALIDATION_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 for bias detection LLM.")
@@ -203,7 +203,7 @@ def bias_detection(text: str, source_context: Optional[str] = None) -> Dict[str,
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model, response_mime_type="application/json")
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using bias detection LLM: {llm_model}")
         response = llm.complete(prompt)
         
@@ -300,7 +300,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", "models/gemini-1.5-pro") # Use Pro for main agent logic
+    agent_llm_model = os.getenv("VALIDATION_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Use Pro for main agent logic
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -308,7 +308,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=agent_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt

agents/code_agent.py

@@ -64,7 +64,7 @@ def generate_python_code(prompt: str) -> str:
             model=gen_llm_model,
             api_key=gen_api_key,
             reasoning_effort="high",
-            temperature=0.25,
+            temperature=0.05,
             max_tokens=16384
         )
         logger.info(f"Using code generation LLM: {gen_llm_model}")
@@ -116,7 +116,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", "models/gemini-1.5-pro")
+    agent_llm_model = os.getenv("CODE_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -127,6 +127,7 @@ def initialize_code_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}")
 
@@ -147,37 +148,38 @@ def initialize_code_agent() -> ReActAgent:
         agent = ReActAgent(
             name="code_agent",
             description=(
-                "Generates Python code using `python_code_generator` and executes it safely using `code_interpreter`. "
-                "Iteratively debugs and refines code based on execution results. "
-                "The agent has access to the following Python packages:\n"
-                "- beautifulsoup4>=4.13.4\n"
-                "- certifi>=2025.4.26\n"
-                "- datasets>=3.5.1\n"
-                "- dotenv>=0.9.9\n"
-                "- duckdb>=1.2.2\n"
-                "- ffmpeg-python>=0.2.0\n"
-                "- gradio[oauth]>=5.28.0\n"
-                "- helium>=5.1.1\n"
-                "- huggingface>=0.0.1\n"
-                "- imageio>=2.37.0\n"
-                "- matplotlib>=3.10.1\n"
-                "- numpy>=2.2.5\n"
-                "- openai-whisper>=20240930\n"
-                "- opencv-python>=4.11.0.86\n"
-                "- openpyxl>=3.1.5\n"
-                "- pandas>=2.2.3\n"
-                "- pyarrow>=20.0.0\n"
-                "- pygame>=2.6.1\n"
-                "- python-chess>=1.999\n"
-                "- requests>=2.32.3\n"
-                "- scikit-learn>=1.6.1\n"
-                "- scipy>=1.15.2\n"
-                "- seaborn>=0.13.2\n"
-                "- sqlalchemy>=2.0.40\n"
-                "- statsmodels>=0.14.4\n"
-                "- sympy>=1.14.0\n"
-                "- youtube-transcript-api>=1.0.3\n"
-                "- yt-dlp>=2025.3.31"
+                "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"
+                "- dotenv>=0.9.9          : Load environment variables from .env files\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"
             ),
             # REMOVED: code_execute_fn - Execution is handled by the code_interpreter tool via the agent loop.
             tools=[

agents/figure_interpretation_agent.py

@@ -1,298 +0,0 @@
-import os
-import logging
-
-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
-
-# 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

@@ -35,7 +35,7 @@ def initialize_image_analyzer_agent() -> FunctionAgent:
     logger.info("Initializing ImageAnalyzerAgent...")
     
     # Configuration from environment variables
-    llm_model_name = os.getenv("IMAGE_ANALYZER_LLM_MODEL", "models/gemini-1.5-pro")
+    llm_model_name = os.getenv("IMAGE_ANALYZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:

agents/long_context_management_agent.py

@@ -115,7 +115,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", "models/gemini-1.5-pro") # Use Pro for potentially long context
+    llm_model = os.getenv("CONTEXT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # 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 +135,7 @@ def summarize_long_context(detail_level: Literal["brief", "standard", "detailed"
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using summarization LLM: {llm_model}")
         response = llm.complete(prompt)
         summary = response.text.strip()
@@ -307,7 +307,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", "models/gemini-1.5-pro") # Needs to handle planning
+    agent_llm_model = os.getenv("CONTEXT_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # Needs to handle planning
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -315,7 +315,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=agent_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using agent LLM: {agent_llm_model}")
         Settings.llm = llm # Set default LLM for LlamaIndex components used by tools
 
@@ -339,7 +339,8 @@ 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" 
+            "reasoning_agent",
+            "research_agent"
         ]
 
         agent = ReActAgent(

agents/math_agent.py

@@ -627,7 +627,7 @@ def initialize_math_agent() -> ReActAgent:
     logger.info("Initializing MathAgent...")
 
     # Configuration
-    agent_llm_model = os.getenv("MATH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+    agent_llm_model = os.getenv("MATH_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -638,6 +638,7 @@ 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}")
 

agents/planner_agent.py

@@ -41,7 +41,7 @@ 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", "models/gemini-1.5-pro") # Specific model for this tool?
+    planner_llm_model = os.getenv("PLANNER_TOOL_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # 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.")
@@ -57,7 +57,7 @@ def plan(objective: str) -> List[str]:
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=planner_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using planning LLM: {planner_llm_model}")
         response = llm.complete(input_prompt)
         
@@ -112,7 +112,7 @@ 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", "models/gemini-1.5-pro") # Specific model?
+    synthesizer_llm_model = os.getenv("SYNTHESIZER_LLM_MODEL", "gemini-2.5-pro-preview-03-25") # 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.")
@@ -131,7 +131,7 @@ def synthesize_and_report(results: List[Dict[str, str]]) -> str:
     """
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=synthesizer_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using synthesis LLM: {synthesizer_llm_model}")
         response = llm.complete(input_prompt)
         logger.info("Synthesis successful.")
@@ -163,7 +163,7 @@ def answer_question(question: str) -> str:
         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", "models/gemini-1.5-pro")
+    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 = (
@@ -180,7 +180,7 @@ def answer_question(question: str) -> str:
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=model_name)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using answer LLM: {model_name}")
         response = llm.complete(assistant_prompt)
         logger.info("Answer generated successfully.")
@@ -213,8 +213,8 @@ answer_question = FunctionTool.from_defaults(
     fn=answer_question,
     name="answer_question",
     description=(
-        "Répond à une question quelconque et renvoie le texte complet, "
-        "terminant toujours par « FINAL ANSWER: ... » conformément aux règles."
+        "Answers any question and returns the full text, always ending with "
+        "‘FINAL ANSWER: ...’ in accordance with the formatting rules."
     ),
 )
 
@@ -224,7 +224,7 @@ def initialize_planner_agent() -> ReActAgent:
     logger.info("Initializing PlannerAgent...")
 
     # Configuration for the agent's main LLM
-    agent_llm_model = os.getenv("PLANNER_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+    agent_llm_model = os.getenv("PLANNER_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -232,7 +232,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=agent_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -243,7 +243,7 @@ def initialize_planner_agent() -> ReActAgent:
              logger.warning("Using default/fallback system prompt for PlannerAgent.")
 
         # Define available tools
-        tools = [generate_substeps_tool, synthesize_tool, answer_question]
+        tools = [generate_substeps_tool, synthesize_tool]
 
         # Define valid handoff targets
         valid_handoffs = [
@@ -253,9 +253,7 @@ def initialize_planner_agent() -> ReActAgent:
             "role_agent",
             "image_analyzer_agent",
             "text_analyzer_agent",
-            "verifier_agent",
             "reasoning_agent",
-            "figure_interpretation_agent",
             "long_context_management_agent",
             "advanced_validation_agent",
             "video_analyzer_agent"
@@ -303,7 +301,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_respond(test_results)
+            report = synthesize_and_report(test_results)
             print(f"Synthesized Report:\n{report}")
 
             # Initialize the agent (optional)

agents/reasoning_agent.py

@@ -72,7 +72,7 @@ def reasoning_tool_fn(context: str) -> str:
             model=reasoning_llm_model,
             api_key=openai_api_key,
             reasoning_effort="high",
-            temperature=0.25,
+            temperature=0.055,
             max_tokens=16384
         )
         logger.info(f"Using reasoning LLM: {reasoning_llm_model}")
@@ -107,7 +107,7 @@ def answer_question(question: str) -> str:
         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", "models/gemini-1.5-pro")
+    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 = (
@@ -124,7 +124,7 @@ def answer_question(question: str) -> str:
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=model_name)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using answer LLM: {model_name}")
         response = llm.complete(assistant_prompt)
         logger.info("Answer generated successfully.")
@@ -159,7 +159,7 @@ def initialize_reasoning_agent() -> ReActAgent:
     logger.info("Initializing ReasoningAgent...")
 
     # Configuration for the agent's main LLM (Google GenAI)
-    agent_llm_model = os.getenv("REASONING_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+    agent_llm_model = os.getenv("REASONING_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -167,7 +167,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=agent_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -185,10 +185,21 @@ def initialize_reasoning_agent() -> ReActAgent:
                 "then seamlessly delegates the synthesized insights to `planner_agent` "
                 "or `long_context_management_agent` for subsequent task orchestration."
             ),
-            tools=[reasoning_tool, answer_question],
+            tools=[reasoning_tool],
             llm=llm,
             system_prompt=system_prompt,
-            can_handoff_to=["planner_agent", "long_context_management_agent", "advanced_validation_agent", "code_agent"],
+            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"
+            ],
         )
 
         return agent

agents/research_agent.py

@@ -2,10 +2,12 @@ import os
 import time
 import logging
 import re # Import regex for video ID extraction
-from typing import List, Optional, Dict # Added Dict
+from typing import List, Optional, Dict, Any  # Added Dict
 
+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
@@ -67,7 +69,7 @@ def browser_tool_handler(func):
     return wrapper
 
 @browser_tool_handler
-def visit(url: str, wait_seconds: float = 3.0) -> str:
+def visit_url(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)
@@ -76,9 +78,35 @@ def visit(url: str, wait_seconds: float = 3.0) -> str:
     return f"Successfully navigated to: {current_url}"
 
 @browser_tool_handler
-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."""
+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).
+    """
     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:
@@ -94,19 +122,253 @@ def get_text_by_css(selector: str) -> List[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 get_page_html() -> str:
-    """Return the full HTML source of the current page."""
-    logger.info("Retrieving page HTML source...")
-    return _browser_driver.page_source
+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
 
 @browser_tool_handler
 def click_element_by_css(selector: str, index: int = 0) -> str:
@@ -135,7 +397,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 = False) -> str:
+def input_text_by_css(selector: str, text: str, index: int = 0, press_enter: bool = True) -> 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
@@ -205,7 +467,7 @@ def close_popups() -> str:
     time.sleep(0.5)
     return "Sent ESC key press."
 
-def answer_question(question: str) -> str:
+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).
@@ -223,16 +485,78 @@ def answer_question(question: str) -> str:
     """
     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", "models/gemini-1.5-pro")
+    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 = (
-        "You are a general AI assistant. I will ask you a question. "
+        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 "
@@ -240,12 +564,14 @@ def answer_question(question: str) -> str:
         "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=model_name)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using answer LLM: {model_name}")
         response = llm.complete(assistant_prompt)
         logger.info("Answer generated successfully.")
@@ -282,21 +608,39 @@ class ResearchAgentInitializer:
             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."
-            ),
+                "(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."
+            )
         )
 
         logger.info("ResearchAgent resources initialized.")
 
     def _initialize_llm(self):
-        agent_llm_model = os.getenv("RESEARCH_AGENT_LLM_MODEL", "models/gemini-1.5-pro")
+        agent_llm_model = os.getenv("RESEARCH_AGENT_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 for ResearchAgent LLM.")
             raise ValueError("GEMINI_API_KEY must be set for ResearchAgent")
         try:
-            self.llm = GoogleGenAI(api_key=gemini_api_key, model=agent_llm_model)
+            self.llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
             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)
@@ -336,19 +680,138 @@ class ResearchAgentInitializer:
         if not SELENIUM_AVAILABLE:
             self.browser_tools = []
             return
-            
+
         self.browser_tools = [
-            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"),
+            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."
+                )
+            )
         ]
-        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):
@@ -357,8 +820,10 @@ 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")
-            google_tool.metadata.description = "(Search) Execute a Google Custom Search query. Returns structured results."
+            google_tool = FunctionTool.from_defaults(
+                fn=google_spec.google_search,
+                name="google_search",
+                description="(Search) Execute a Google Custom Search query. Returns structured results.")
             self.search_tools.append(google_tool)
 
         # Tavily Search
@@ -390,6 +855,62 @@ 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:
@@ -425,52 +946,66 @@ class ResearchAgentInitializer:
         logger.info("Creating ResearchAgent ReActAgent instance...")
         
         all_tools = self.browser_tools + self.search_tools + self.datasource_tools
-        all_tools.append(self.answer_question)
              
         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.
+        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).
+        Available Tool Categories
+        - (Browser): Tools for direct 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.
-        - (Answer): `answer_question` — use this when your research has yielded a definitive result and you need to reply in the strict “FINAL ANSWER” format.
-
-        **Answer Tool Usage**  
-        When you know the final answer and no further data is required, invoke `answer_question` with the user’s query. It will return text ending with:
+        - (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**:
+        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.
-          - If numeric: no thousands separators or units (%, $, etc.) unless explicitly requested.
-          - If string: omit articles and abbreviations; write digits in plain text.
-          - If a list: apply the above rules to each element.
-
-        **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.
-        2. **Action**: Call the chosen tool with the correct arguments. Ensure inputs match the tool's requirements.
-        3. **Observation**: Examine the tool's output. Extract the relevant information. Check for errors.
-        4. **Reflect & Iterate**: Does the observation satisfy the immediate goal? If not, return to step 1. If a tool failed, try an alternative approach.
-        5. **Advanced Validation**: Before delivering any final response, invoke `advanced_validation_agent` with the combined insights from the reasoning and planning phases. If validation fails, pass the feedback back into **planner_agent** to refine the approach and repeat validation.
-        6. **Synthesize**: Once validation is approved, synthesize all gathered information into a coherent answer.
-        7. **Respond**: Invoke `answer_question` to emit the **FINAL ANSWER** according to the strict template rules.
-
-        **Constraints:**
-        - Use only one tool per Action step.
-        - Think step-by-step.
-        - If using browser tools, start with `visit_url`.
-        - Synthesize results *before* handing off or responding.
-        - Do not skip any workflow step (reason → action → observation → reflect → validate → synthesize → respond).
+        - 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.
         """
 
         agent = ReActAgent(

agents/role_agent.py

@@ -30,7 +30,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", "models/gemini-1.5-pro")
+        self.llm_model_name = os.getenv("ROLE_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
         self.gemini_api_key = os.getenv("GEMINI_API_KEY")
 
         if not self.gemini_api_key:
@@ -153,6 +153,7 @@ class RoleAgentInitializer:
         llm = GoogleGenAI(
             api_key=self.gemini_api_key,
             model=self.llm_model_name,
+            temperature=0.05
         )
 
         agent = ReActAgent(

agents/synthesis_agent.py

@@ -0,0 +1,153 @@
+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
+"""
+
+# -----------------------------------------------------------------------------
+# 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

@@ -10,14 +10,6 @@ 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
-
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -44,28 +36,6 @@ 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:
@@ -92,7 +62,7 @@ def summarize_text(text: str, max_length: int = 150, min_length: int = 30) -> st
     )
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=summarizer_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using summarization LLM: {summarizer_llm_model}")
         response = llm.complete(prompt)
         summary = response.text.strip()
@@ -185,56 +155,6 @@ 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,
@@ -263,29 +183,13 @@ 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", "models/gemini-1.5-pro")
+    agent_llm_model = os.getenv("TEXT_ANALYZER_AGENT_LLM_MODEL", "gemini-2.5-pro-preview-03-25")
     gemini_api_key = os.getenv("GEMINI_API_KEY")
 
     if not gemini_api_key:
@@ -293,7 +197,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=agent_llm_model)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info(f"Using agent LLM: {agent_llm_model}")
 
         # Load system prompt
@@ -305,16 +209,12 @@ 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",
@@ -358,23 +258,6 @@ 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

@@ -1,296 +0,0 @@
-import os
-import logging
-import re
-from typing import List
-
-from llama_index.core.agent.workflow import FunctionAgent, ReActAgent
-from llama_index.core.tools import FunctionTool
-from llama_index.llms.google_genai import GoogleGenAI
-
-# 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", "advanced_validation_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

@@ -5,7 +5,7 @@ import os
 import re
 import shutil
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List
 
 import cv2
 import yt_dlp
@@ -15,6 +15,9 @@ 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
+import dotenv
+
+dotenv.load_dotenv()
 
 # ---------------------------------------------------------------------------
 # Environment setup & logging
@@ -86,7 +89,7 @@ def load_prompt_from_file(filename: str = "../prompts/video_analyzer_prompt.txt"
     )
 
 
-def extract_frames(video_path, output_dir, fps=1/2):
+def extract_frames(video_path, output_dir, fps=2):
     """
     Extract frames from video at specified FPS
     Returns a list of (frame_path, timestamp) tuples
@@ -134,7 +137,7 @@ def extract_frames(video_path, output_dir, fps=1/2):
 
 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", "models/gemini-1.5-pro")
+    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 = {
@@ -174,7 +177,7 @@ def download_video_and_analyze(video_url: str) -> str:
             blocks.append(ImageBlock(path=frame_path))
 
 
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model_name)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info("Using LLM model: %s", llm_model_name)
         response = llm.chat([ChatMessage(role="user", blocks=blocks)])
 
@@ -200,14 +203,15 @@ def extract_video_id(url: str) -> Optional[str]:
     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 None
+        return url
 
 
 # --- YouTube Transcript Tool ---
-def get_youtube_transcript(video_url_or_id: str, languages: str | None = None) -> str:
+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.
@@ -244,12 +248,11 @@ def get_youtube_transcript(video_url_or_id: str, languages: str | None = None) -
         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}")
+            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(
-                transcript_list.manually_created_transcripts.keys() or transcript_list.generated_transcripts.keys())
+            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(
@@ -265,21 +268,40 @@ def get_youtube_transcript(video_url_or_id: str, languages: str | None = None) -
 
 
 download_video_and_analyze_tool = FunctionTool.from_defaults(
+    fn=download_video_and_analyze,
     name="download_video_and_analyze",
     description=(
-        "Downloads a video (YouTube or direct URL), samples representative frames, "
-        "and feeds them to Gemini for multimodal analysis—returning a rich textual summary "
-        "of the visual content."
-    ),
-    fn=download_video_and_analyze,
+        "(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) Fetches the transcript text for a given YouTube video URL or video ID. "
-        "Specify preferred languages (e.g., 'en', 'es'). Returns transcript or error."
+        "(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."
     )
 )
 
@@ -293,7 +315,7 @@ def initialize_video_analyzer_agent() -> FunctionAgent:
 
     logger.info("Initialising VideoAnalyzerAgent …")
 
-    llm_model_name = os.getenv("VIDEO_ANALYZER_LLM_MODEL", "models/gemini-1.5-pro")
+    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:
@@ -301,10 +323,70 @@ def initialize_video_analyzer_agent() -> FunctionAgent:
         raise ValueError("GEMINI_API_KEY must be set")
 
     try:
-        llm = GoogleGenAI(api_key=gemini_api_key, model=llm_model_name)
+        llm = GoogleGenAI(api_key=gemini_api_key, model="gemini-2.5-pro-preview-03-25", temperature=0.05, max_tokens=8192)
         logger.info("Using LLM model: %s", llm_model_name)
 
-        system_prompt = load_prompt_from_file()
+        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.”
+        
+        End of prompt.
+        """
 
         tools = [download_video_and_analyze_tool, youtube_transcript_tool]
 
@@ -357,18 +439,14 @@ if __name__ == "__main__":
 
     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.")
 
+        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,12 +1,17 @@
 import os
 import logging
 import mimetypes
+import subprocess
 
 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
@@ -14,6 +19,8 @@ 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
 try:
@@ -26,34 +33,17 @@ 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:
-    # 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}")
+    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}")
 
 # Setup logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -62,6 +52,57 @@ 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
@@ -74,28 +115,30 @@ try:
     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, 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,
-        video_analyzer_agent
+        text_analyzer_agent, image_analyzer_agent, reasoning_agent,
+        advanced_validation_agent, long_context_management_agent,
+        video_analyzer_agent, synthesis_agent
     ]
     if not all(all_agents):
         raise RuntimeError("One or more agents failed to initialize.")
 
     AGENT_WORKFLOW = AgentWorkflow(
         agents=all_agents,
-        root_agent="planner_agent" # Keep planner as root as per plan
+        root_agent="reasoning_agent", # Keep planner as root as per plan
+        initial_state={
+            "research_content": []
+        }
     )
     logger.info("GAIA Multi-Agent Workflow initialized successfully.")
 except Exception as e:
@@ -160,18 +203,19 @@ 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="""
+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.
-"""
-
-llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"), temperature=0.1, system_prompt=system_prompt)
+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 ---
 
@@ -222,7 +266,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", ".csv", ".json", ".xml", ".yaml", ".yml", ".ini", ".cfg", ".toml", ".log", ".properties",
+                    ".txt", ".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
@@ -237,17 +281,22 @@ 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=file_content)
+                    file_block = TextBlock(block_type="text", text=f"[File: {file_name}]\n[Content]:\n{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
-                    file_block = AudioBlock(url=fetch_file_url, audio=response.content)
+                    audio_text = transcribe_audio(response.content)
+                    file_block = TextBlock(text=f"[Transcribed Audio: {audio_text}]")
                 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.")
@@ -278,6 +327,15 @@ async def process_question(agent: BasicAgent, item: dict, base_fetch_file_url: s
         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.
@@ -329,7 +387,7 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
         return "Failed to fetch questions.", None
 
     # 3. Process Questions
-    # questions_data = [questions_data[3], questions_data[6]]
+    # questions_data = [questions_data[6]]
     for item in questions_data:
         answers = await process_question(agent, item, fetch_file_url)
         results_log.append(answers)

cookies.txt

@@ -0,0 +1,16 @@
+# 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	1761928305	__Secure-ROLLOUT_TOKEN	CK2CtoGE9_qCKBDVmd6PqaqLAxiimOLanoqNAw%3D%3D
+.youtube.com	TRUE	/	TRUE	1780502573	__Secure-3PAPISID	Es8lNi2tKH_w6xhk/A5yqk-H0g0K329X1o
+.youtube.com	TRUE	/	TRUE	1780502573	__Secure-3PSID	g.a000wQiyYVADhJ0IDxSDoFRi6cUtMUs77vKiv67cKlhfBRyt8TWh6wP59ja7Ccu2lEPStG0E9gACgYKAT0SARASFQHGX2MirUvQtL-jYTLLnMocXq-eVxoVAUF8yKq2SkbS4FUiTUqswnomlXXS0076
+.youtube.com	TRUE	/	TRUE	1772810410	__Secure-YEC	CgtaV0NPeGJVRncxZyjwrN7ABjInCgJCRRIhEh0SGwsMDg8QERITFBUWFxgZGhscHR4fICEiIyQlJiAy
+.youtube.com	TRUE	/	TRUE	1761928305	VISITOR_PRIVACY_METADATA	CgJCRRIhEh0SGwsMDg8QERITFBUWFxgZGhscHR4fICEiIyQlJiAa
+.youtube.com	TRUE	/	TRUE	1777608592	__Secure-1PSIDTS	sidts-CjIBjplskMR_wI_-sxQCXIh_A5wIobOdoONYRAp32Akkn2F4h29lH76FjI_xUvu93oO86RAA
+.youtube.com	TRUE	/	TRUE	1777608592	__Secure-3PSIDTS	sidts-CjIBjplskMR_wI_-sxQCXIh_A5wIobOdoONYRAp32Akkn2F4h29lH76FjI_xUvu93oO86RAA
+.youtube.com	TRUE	/	TRUE	1777608592	__Secure-3PSIDCC	AKEyXzWgzZK09pWnLsejhZtkJMtHpvkaFBG7tdOEw0-1NRBycYj8xzr1E8FDKS6ZptP5vsTiSRi2
+.youtube.com	TRUE	/	FALSE	0	PREF	f4=4000000&tz=UTC&f7=100&f6=400&f5=30000&hl=en
+.youtube.com	TRUE	/	TRUE	1809448305	__Secure-YT_TVFAS	t=485104&s=3
+.youtube.com	TRUE	/	TRUE	1761928305	DEVICE_INFO	ChxOelV3TURZeU9URXhOemN5TVRRM05EazRPQT09EPGs3sAGGPGs3sAG
+.youtube.com	TRUE	/	TRUE	1761928305	VISITOR_INFO1_LIVE	gMG4-pZ0QBE

gaia_improvement_plan.md

@@ -1,943 +0,0 @@
-
-### 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

@@ -56,4 +56,13 @@ def cookies_to_env(cookie_file_path: str) -> str:
     except Exception as e:
         raise ValueError(f"Error converting cookie file: {str(e)}")
 
-print(cookies_to_env(export_youtube_cookies_netscape("youtube.com")))
+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)}")
+
+save_to_env_file(cookies_to_env(export_youtube_cookies_netscape("youtube.com")))

packages.txt

@@ -4,4 +4,5 @@ libxss1
 libatk-bridge2.0-0
 libgtk-3-0
 libgbm-dev
+ffmpeg
 chromium-driver

prompts/code_gen_prompt.txt

@@ -44,12 +44,11 @@ Notes:
         seaborn>=0.13.2,
         sqlalchemy>=2.0.40,
         statsmodels>=0.14.4,
+        stockfish==3.28.0,
         sympy>=1.14.0,
         youtube-transcript-api>=1.0.3,
         yt-dlp>=2025.3.31
 
-    - You can also access and process YouTube video and audio streams using `yt-dlp`, `opencv-python`, `ffmpeg-python`, or `imageio`.
-
 Prompt: {prompt}
 
 Code:

prompts/image_analyzer_prompt.txt

@@ -1,69 +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.
 

prompts/planner_agent_prompt.txt

@@ -24,10 +24,15 @@ Once planning is complete, address each sub-question in turn and then hand off a
 - 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** to check the coherence and consistency of your plan.
-   - If validation fails, discard the current plan and restart the planning process.
-   - If validation succeeds, proceed to step 2.
+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**
@@ -35,4 +40,4 @@ Only the following agents are available: **code_agent**, **research_agent**, **m
 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.
+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.

prompts/reasoning_agent_prompt.txt

@@ -14,10 +14,10 @@ You are **ReasoningAgent**, an advanced cognitive engine specialized in rigorous
      - 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. **Generate final answer**
-   - After validation approval and when you need to deliver a concise final response, invoke `answer_question` to format and emit the **FINAL ANSWER** according to its strict template rules.
+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 via `answer_question`.
+- Do not skip any step: reasoning → planning → validation → (if approved) final answer.
 

prompts/text_analyzer_prompt.txt

@@ -1,42 +1,42 @@
 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.

pyproject.toml

@@ -43,9 +43,12 @@ dependencies = [
     "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",
 ]

requirements.txt

@@ -39,6 +39,8 @@ 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

todo.md

@@ -1,44 +0,0 @@
-# GAIA Framework Improvement Plan - ToDo List
-
-1.  [X] Create overall output document structure (`gaia_improvement_plan.md`).
-2.  [ ] Generate ASCII diagram of the *revised* architecture (incorporating proposed changes).
-3.  [ ] Perform Code Quality Review:
-    *   [ ] Review `app.py`
-    *   [ ] Review `role_agent.py`
-    *   [ ] Review `image_analyzer_agent.py`
-    *   [ ] Review `verifier_agent.py`
-    *   [ ] Review `research_agent.py`
-    *   [ ] Review `text_analyzer_agent.py`
-    *   [ ] Review `reasoning_agent.py`
-    *   [ ] Review `planner_agent.py`
-    *   [ ] Review `code_agent.py`
-    *   [ ] Review `math_agent.py` (note truncation)
-    *   [ ] Consolidate findings for Code Quality section in the report.
-4.  [ ] Develop Refactor Proposals:
-    *   [ ] Propose refactors for `app.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `role_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `image_analyzer_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `verifier_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `research_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `text_analyzer_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `reasoning_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `planner_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `code_agent.py` (if any) + generate diff.
-    *   [ ] Propose refactors for `math_agent.py` (if any) + generate diff.
-    *   [ ] Consolidate proposals for Refactoring section in the report.
-5.  [ ] Design New Features:
-    *   [ ] Design YouTube Ingestion feature (module/agent, steps, tools, API).
-    *   [ ] Design Generic Audio Transcription feature (module/agent, steps, tools, API, Gemini/Whisper logic).
-    *   [ ] Document designs in New Features section of the report.
-6.  [ ] Design Extra Agents:
-    *   [ ] Design Agent 1 (Purpose, Tools, Loop Sketch).
-    *   [ ] Design Agent 2 (Purpose, Tools, Loop Sketch).
-    *   [ ] Design Agent 3 (Purpose, Tools, Loop Sketch).
-    *   [ ] Document designs in Extra Agents section of the report.
-7.  [ ] Create Migration Plan:
-    *   [ ] Define order of applying changes/features.
-    *   [ ] List new dependencies for `requirements.txt`.
-    *   [ ] Outline minimal unit/integration tests for validation.
-    *   [ ] Document plan in Migration Plan section of the report.
-8.  [ ] Assemble final report (`gaia_improvement_plan.md`).
-9.  [ ] Ask user for confirmation/feedback on the plan before proceeding (as per user's "First action" instruction).

uv.lock

@@ -914,9 +914,12 @@ dependencies = [
     { name = "scikit-learn" },
     { name = "scipy" },
     { name = "seaborn" },
+    { name = "soundfile" },
     { name = "sqlalchemy" },
     { name = "statsmodels" },
+    { name = "stockfish" },
     { name = "sympy" },
+    { name = "torchaudio" },
     { name = "youtube-transcript-api" },
     { name = "yt-dlp" },
 ]
@@ -962,9 +965,12 @@ requires-dist = [
     { name = "scikit-learn", specifier = ">=1.6.1" },
     { name = "scipy", specifier = ">=1.15.2" },
     { name = "seaborn", specifier = ">=0.13.2" },
+    { name = "soundfile", specifier = ">=0.13.1" },
     { name = "sqlalchemy", specifier = ">=2.0.40" },
     { name = "statsmodels", specifier = ">=0.14.4" },
+    { name = "stockfish", specifier = ">=3.28.0" },
     { name = "sympy", specifier = ">=1.14.0" },
+    { name = "torchaudio", specifier = ">=2.7.0" },
     { name = "youtube-transcript-api", specifier = ">=1.0.3" },
     { name = "yt-dlp", specifier = ">=2025.3.31" },
 ]
@@ -3556,6 +3562,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
 ]
 
+[[package]]
+name = "soundfile"
+version = "0.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", hash = "sha256:b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b", size = 46156 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", hash = "sha256:a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445", size = 25751 },
+    { url = "https://files.pythonhosted.org/packages/ea/ab/73e97a5b3cc46bba7ff8650a1504348fa1863a6f9d57d7001c6b67c5f20e/soundfile-0.13.1-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:82dc664d19831933fe59adad199bf3945ad06d84bc111a5b4c0d3089a5b9ec33", size = 1142250 },
+    { url = "https://files.pythonhosted.org/packages/a0/e5/58fd1a8d7b26fc113af244f966ee3aecf03cb9293cb935daaddc1e455e18/soundfile-0.13.1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:743f12c12c4054921e15736c6be09ac26b3b3d603aef6fd69f9dde68748f2593", size = 1101406 },
+    { url = "https://files.pythonhosted.org/packages/58/ae/c0e4a53d77cf6e9a04179535766b3321b0b9ced5f70522e4caf9329f0046/soundfile-0.13.1-py2.py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9c9e855f5a4d06ce4213f31918653ab7de0c5a8d8107cd2427e44b42df547deb", size = 1235729 },
+    { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618", size = 1313646 },
+    { url = "https://files.pythonhosted.org/packages/fe/df/8c11dc4dfceda14e3003bb81a0d0edcaaf0796dd7b4f826ea3e532146bba/soundfile-0.13.1-py2.py3-none-win32.whl", hash = "sha256:c734564fab7c5ddf8e9be5bf70bab68042cd17e9c214c06e365e20d64f9a69d5", size = 899881 },
+    { url = "https://files.pythonhosted.org/packages/14/e9/6b761de83277f2f02ded7e7ea6f07828ec78e4b229b80e4ca55dd205b9dc/soundfile-0.13.1-py2.py3-none-win_amd64.whl", hash = "sha256:1e70a05a0626524a69e9f0f4dd2ec174b4e9567f4d8b6c11d38b5c289be36ee9", size = 1019162 },
+]
+
 [[package]]
 name = "soupsieve"
 version = "2.7"
@@ -3652,6 +3677,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1d/eb/cb8b01f5edf8f135eb3d0553d159db113a35b2948d0e51eeb735e7ae09ea/statsmodels-0.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:81030108d27aecc7995cac05aa280cf8c6025f6a6119894eef648997936c2dd0", size = 9817574 },
 ]
 
+[[package]]
+name = "stockfish"
+version = "3.28.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/bd/b06883b957530867179da3672fa3d8b87a08a1e3c11ca9737d94b60689d2/stockfish-3.28.0.tar.gz", hash = "sha256:8764127c00434aa85b7fca1c064800e7ea907bb3626ccd4b583f0e911b014070", size = 16264 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/b2/b3a204dd7754685fef5e62bf19b82d2572b321df619775502326cf7d383e/stockfish-3.28.0-py3-none-any.whl", hash = "sha256:e432e57112448fe1271dff402db3a4747bf00d1721815ce0a36cfa26582cf360", size = 13907 },
+]
+
 [[package]]
 name = "striprtf"
 version = "0.0.26"
@@ -3816,6 +3850,32 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/90/48/7e6477cf40d48cc0a61fa0d41ee9582b9a316b12772fcac17bc1a40178e7/torch-2.7.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:27f5007bdf45f7bb7af7f11d1828d5c2487e030690afb3d89a651fd7036a390e", size = 68575074 },
 ]
 
+[[package]]
+name = "torchaudio"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "torch" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6e/d6/27deb8862ecc005c95a5c64bcc8cc27c74878eb8d4162ce4d39b35ea9e27/torchaudio-2.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:862d9c5cfe15688a7846962b5d3c9f959beffe82b1e5441935c7a37504c5c5e7", size = 1849075 },
+    { url = "https://files.pythonhosted.org/packages/04/95/29b4a4d87540779101cb60cb7f381fdb6bc6aea0af83f0f35aa8fc70cb0d/torchaudio-2.7.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:677bd32031310ee73a47d6eebc2e74e74c1cf467932945ee88082a3935b5c950", size = 1686165 },
+    { url = "https://files.pythonhosted.org/packages/ab/20/1873a49df9f1778c241543eaca14d613d657b9f9351c254952114251cb86/torchaudio-2.7.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c37b77dd528ad18a036466e856f53d8bd5912b757a775309354b4a977a069379", size = 3455781 },
+    { url = "https://files.pythonhosted.org/packages/9e/1d/1fa4f69e4cd8c83831c3baad0ac9b56ece8ce0e75e5e5c0cdd3f591a458c/torchaudio-2.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:36b94819f5406b2599ac31542e2e7a7aaf4a5b5f466ce034f296b1ee1134c945", size = 2494793 },
+    { url = "https://files.pythonhosted.org/packages/dd/b9/66dd7c4e16e8e6dcc52b4702ba7bbace589972b3597627d39d9dc3aa5fdd/torchaudio-2.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:65b4fc9b7f28367f918b02ae4db4290457bc4fdd160f22b7d684e93ab8dcb956", size = 1846733 },
+    { url = "https://files.pythonhosted.org/packages/47/48/850edf788c674494a7e148eee6f5563cae34c9a3e3e0962dcfce66c1dae7/torchaudio-2.7.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:33004ed47f18f00044c97ee8cd9e3f5e1c2e26ef23d4f72b5f1ae33e6182587b", size = 1686687 },
+    { url = "https://files.pythonhosted.org/packages/78/98/ec8c7aba67b44cdc59717d4b43d02023ded5da180d33c6469d20bf5bfa3c/torchaudio-2.7.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a6f03494075bcdd62e7fade7baf50a0ef107aa809d02b5e1786391adced451a3", size = 3454437 },
+    { url = "https://files.pythonhosted.org/packages/5e/23/b73163ac06e5a724375df61a5b6c853861a825fe98e64388f277514153dd/torchaudio-2.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:275931c8a38ff84b5692df990506b41f18d0a0706574d96bc8456ad9e5fa85c8", size = 2493451 },
+    { url = "https://files.pythonhosted.org/packages/c1/a5/bc4bb6b254d3d77e9fa4d219f29d3bff8db92acc9004c27e875f32d4724a/torchaudio-2.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:150fbde41da60296effed772b7a170f563cd44967555abb0603fc573f39ce245", size = 1847033 },
+    { url = "https://files.pythonhosted.org/packages/96/af/4c8d4e781ea5924590cccf8595a09081eb07a577c03fbf4bf04a2f5f7134/torchaudio-2.7.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9d921eeb036512a87efde007977b27bd326320cd7cd5f43195824173fe82e888", size = 1686308 },
+    { url = "https://files.pythonhosted.org/packages/12/02/ad1083f6ce534989c704c3efcd615bdd160934229882aa0a3ea95cd24a9a/torchaudio-2.7.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:30675a5f99551e036974a7476729eb5d31f453cf792ae6e0a0d449960f84f464", size = 3455266 },
+    { url = "https://files.pythonhosted.org/packages/88/49/923ebb2603156dd5c5ae6d845bf51a078e05f27432cd26f13ecdcc8713cd/torchaudio-2.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:ce8cfc07a4e59c835404583e7d3e171208b332b61bb92643f8723f6f192da8bf", size = 2493639 },
+    { url = "https://files.pythonhosted.org/packages/bf/85/dd4cd1202483e85c208e1ca3d31cc42c2972f1d955d11b742fa098a38a1b/torchaudio-2.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9e08138cac75cde2064c8b5bbd12f27bdeb3d36f4b8c2285fc9c42eaa97c0676", size = 1929989 },
+    { url = "https://files.pythonhosted.org/packages/ef/3a/8a1045f2b00c6300827c1e6a3e661e9d219b5406ef103dc2824604548b8c/torchaudio-2.7.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:1d928aeff495a0807b4da3b0dd46e15eae8070da5e7ed6d35c1dcfd9fdfe2b74", size = 1700439 },
+    { url = "https://files.pythonhosted.org/packages/72/53/21d589a5a41702b5d37bae224286986cb707500d5ecdbfdcfdbac9381a08/torchaudio-2.7.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ee4add33f24e9cb959bd9de89f36de5ebf844eda040d1d0b38f08617d67dedc3", size = 3466356 },
+    { url = "https://files.pythonhosted.org/packages/00/0b/5ef81aaacce5e9c316659ddc61a2b1e4f984a504d4a06fe61bab04cc75f1/torchaudio-2.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:725dbbcc9e744ca62de8856262c6f472ca26b1cd5db062b062a2d6b66a336cc0", size = 2544970 },
+]
+
 [[package]]
 name = "tqdm"
 version = "4.67.1"