funcion read mejorada

agents.py

@@ -2,7 +2,7 @@ import asyncio
 import os
 from llama_index.core.agent.workflow import AgentWorkflow
 from llama_index.llms.openai import OpenAI
-from tools import (image_analyzer_tool, youtube_transcript_tool, calculator_tool, read_document_tool, search_tool)
+from tools import (image_analyzer_tool,python_tool, youtube_transcript_tool, calculator_tool, read_document_tool, search_tool)
 from llama_index.core.workflow import (Workflow, Context, step, StartEvent, StopEvent, Event)
 from llama_index.core.agent import ReActAgent
 from dotenv import load_dotenv
@@ -19,33 +19,28 @@ class AlfredAdvancedWorkflow(AgentWorkflow):
 
             description="Main agent that routes to the correct tool based on question type.",
 
-            system_prompt="""You are Alfred, a precise assistant for the GAIA benchmark.
+            system_prompt="""You are Alfred, an elite autonomous agent for the GAIA benchmark.
 
-CRITICAL RULES:
-1. Your FINAL answer must be EXTREMELY concise - typically just a number, name, date, or single sentence.
-2. Available tools:
-   - web_search: For factual questions requiring web search (people, places, current events, papers)
-   - read_document: For files (.xlsx, .pdf, .csv, .txt, .docx, .json) and audio files (.mp3, .wav, .m4a, .flac, .ogg)
-   - youtube_transcript: For YouTube URLs
-   - analyze_image: For images (.jpg, .png, .gif, .webp)
-   - calculator: For mathematical calculations
+STRATEGY FOR SUCCESS:
+1. **PYTHON FILES (.py)**: If asked about a python file output:
+   - First, use `read_document` to see the code.
+   - Second, use `python_interpreter` to execute that exact code and get the answer.
+   
+2. **COMPLEX SEARCH**: For questions like "Pitcher before X...", do not give up.
+   - Step 1: Find the specific team/roster and year mentioned.
+   - Step 2: Find the list/order of players.
+   - Step 3: Extract the names.
+   - If `web_search` returns generic info, refine the query (e.g., "Taishō Tamai roster 2023 numbers").
 
-3. MULTI-STEP STRATEGY:
-   - Use tools AS MANY TIMES as needed to get the complete answer
-   - For complex questions: read file → extract info → calculate → verify
-   - Don't stop after first tool call if more information is needed
+3. **FILES**: Always trust the filename provided in the prompt. If `read_document` fails initially, check the extension.
 
-4. ANSWER FORMAT:
-   - Numbers: Return exact value (e.g., "42" not "approximately 42")
-   - Dates: Use format in question (e.g., "January 15, 2024" or "2024-01-15")
-   - Names: Full name as it appears (e.g., "Marie Curie")
-   - Lists: Use commas (e.g., "Paris, London, Berlin")
+4. **FINAL ANSWER**:
+   - Must be concise.
+   - No preamble like "The answer is". Just the value.
 
-5. If tool fails: Try alternative approach or return "Unable to determine"
+REMEMBER: Extract the EXACT answer. No explanations, no context, no PREAMBLES.""",
 
-REMEMBER: Extract the EXACT answer. No explanations, no context, no preamble.""",
-
-            tools=[search_tool, read_document_tool, image_analyzer_tool, youtube_transcript_tool, calculator_tool],
+            tools=[search_tool,python_tool, read_document_tool, image_analyzer_tool, youtube_transcript_tool, calculator_tool],
             llm=llm,
             verbose=True,
             max_iterations=15)

requirements.txt

@@ -17,4 +17,5 @@ whisper
 pydub
 python-docx
 pillow
-pandas
+pandas
+openpyxl

tools.py

@@ -23,6 +23,32 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 TAVILY = os.getenv("TAVILY_KEY")
 client = InferenceClient(HF_TOKEN)
 
+def python_interpreter(code: str) -> str:
+    """
+    Execute Python code and return the output (stdout). 
+    Use this when you need to perform complex calculations, string manipulations, 
+    or when asked to determine the output of a python script.
+    WARNING: The code will be executed in the current environment.
+    """
+    # Crear un buffer para capturar el print()
+    buffer = io.StringIO()
+    
+    try:
+        # Redirigir stdout a nuestro buffer
+        with contextlib.redirect_stdout(buffer):
+            # Crear un diccionario local para las variables
+            local_scope = {}
+            exec(code, {}, local_scope)
+            
+        output = buffer.getvalue()
+        if not output and local_scope:
+            # Si no hubo prints, devolvemos las variables finales
+            return f"Code executed successfully. Variables: {local_scope}"
+        return output if output else "Code executed. No output produced."
+        
+    except Exception as e:
+        return f"Error executing code: {str(e)}"
+
 def transcribe_audio_openai(audio_path: str) -> str:
     """Transcribe audio using OpenAI Whisper API - compatible with Spaces"""
     try:
@@ -75,25 +101,58 @@ def get_youtube_transcript(video_url: str) -> str:
     
 
 
-def read_document(file_path: str) -> str:
+def read_document(file_name: str) -> str:
     """
-    file_spec can be:
-      - a local file path (e.g., "data.xlsx")
-      - a task_id (e.g., "abc123") to download from GAIA
+    Downloads a file from the GAIA source if not present.
+    - If it's a text file (.txt, .py, .csv, .json, .md), returns the content.
+    - If it's a binary file (.xlsx, .pdf, .png, .mp3), returns the file path 
+      and instructions to use other tools (like python_interpreter or analyze_image).
     """
-    name = "read_file"
-    description = "Reads a file and returns its content"
-    inputs = {
-        "file_path": {"type": "string", "description": "Path to the file to read"},
-    }
-    output_type = "string"
-
-    def forward(self, file_path: str) -> str:
+    import os
+    import requests
+
+    # Limpiar el nombre del archivo (a veces el LLM alucina rutas)
+    file_name = os.path.basename(file_name)
+    
+    # URL oficial de validación de GAIA (Donde viven los archivos reales)
+    base_url = "https://huggingface.co/datasets/gaia-benchmark/GAIA/resolve/main/2023/validation"
+    file_url = f"{base_url}/{file_name}"
+    
+    # 1. Descarga si no existe
+    if not os.path.exists(file_name):
         try:
-            with open(file_path, "r") as file:
-                return file.read()
+            print(f"📥 Downloading {file_name} from {file_url}...")
+            response = requests.get(file_url)
+            if response.status_code == 200:
+                with open(file_name, "wb") as f:
+                    f.write(response.content)
+            else:
+                return f"Error: File {file_name} not found in GAIA source (Status {response.status_code})."
         except Exception as e:
-            return f"Error reading file: {str(e)}"
+            return f"Error downloading file: {str(e)}"
+    
+    # 2. Decidir cómo leerlo según la extensión
+    _, ext = os.path.splitext(file_name)
+    ext = ext.lower()
+    
+    # Lista de archivos que NO se deben leer como texto plano
+    binary_extensions = ['.xlsx', '.xls', '.png', '.jpg', '.jpeg', '.mp3', '.wav', '.pdf', '.zip']
+    
+    if ext in binary_extensions:
+        return (f"File '{file_name}' has been downloaded and saved locally. "
+                f"It is a binary file ({ext}). DO NOT read it as text. "
+                f"Use 'python_interpreter' (with pandas for excel) or 'analyze_image' to process it.")
+    
+    # 3. Si es texto, leerlo y devolver el contenido
+    try:
+        with open(file_name, "r", encoding='utf-8', errors='ignore') as file:
+            content = file.read()
+            # Truncar si es demasiado largo para evitar errores de contexto
+            if len(content) > 10000: 
+                return content[:10000] + "\n...[Content Truncated]..."
+            return content
+    except Exception as e:
+        return f"Error reading text file: {str(e)}"
 
    
 
@@ -169,6 +228,12 @@ async def search_web(query: str) -> str:
 
 
 # Definimos las tool
+python_tool = FunctionTool.from_defaults(
+    fn=python_interpreter,
+    name="python_interpreter",
+    description="Executes Python code. Use this to run code found in files or to perform complex logic."
+)
+
 image_analyzer_tool = FunctionTool.from_defaults(
         fn = analyze_image,
         name = "analyze_image",