new day new attempt

app.py

@@ -1,38 +1,44 @@
+# app.py
+
 import os
 import re
 import gradio as gr
 import requests
 import pandas as pd
-import torch
 import logging
-from transformers.pipelines import pipeline
+import numexpr
+from typing import TypedDict, Annotated
+
+# --- Langchain & HF Imports ---
+# CHANGED: Swapped local pipeline for Inference API and removed torch
+from langchain_huggingface import HuggingFaceInferenceAPI
 from langchain_community.tools import DuckDuckGoSearchRun
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.prompts import PromptTemplate
-from langchain_huggingface import HuggingFacePipeline
+from langchain_core.prompts import PromptTemplate
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.tools import tool
 from langgraph.graph import StateGraph, END
-from typing import TypedDict, Annotated, List
 from langchain_community.document_loaders.youtube import YoutubeLoader
-import numexpr
+
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-SYSTEM_PROMPT = """You are a helpful assistant tasked with answering questions.
-
-You have access to a set of tools to help you. The question you receive may require you to use these tools.
-When you receive a question, you should first think about what steps you need to take.
-Based on your plan, you can then call the necessary tools.
-After calling a tool, you will get a result. You should analyze the result and decide if you need to call another tool or if you have enough information to answer the question.
-
-When you have the final answer, you must output it in the following format:
+# ADDED: A more robust prompt tailored for tool use with Llama 3
+SYSTEM_PROMPT = """You are a helpful and expert assistant named GAIA, designed to answer questions accurately.
+
+To do this, you have access to a set of tools. Based on the user's question, you must decide which tool to use, if any.
+Your process is:
+1.  **Analyze the Question**: Understand what is being asked.
+2.  **Select a Tool**: If necessary, choose the best tool for the job. Your available tools are: `web_search`, `math_calculator`, `image_analyzer`, `youtube_transcript_reader`.
+3.  **Call the Tool**: Output a tool call in the format `tool_name("argument")`. For example: `web_search("what is the weather in Paris?")`.
+4.  **Analyze the Result**: Look at the tool's output.
+5.  **Final Answer**: If you have enough information, provide the final answer. If not, you can use another tool.
+
+When you have the final answer, you **must** output it in the following format, and nothing else:
 FINAL ANSWER: [YOUR FINAL ANSWER]
 
-YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma-separated list of numbers and/or strings.
-- If you are asked for a number, do not use commas for thousands separators or units like '$' or '%' unless specified.
-- If you are asked for a string, do not use articles or abbreviations (e.g., for cities).
-- If you are asked for a comma-separated list, apply the above rules to each element.
+- YOUR FINAL ANSWER should be a number, a short string, or a comma-separated list.
+- Do not use formatting like thousands separators or units unless the question explicitly asks for it.
+- Do not add explanations or prose in the final answer.
 
 Example:
 Question: What is the capital of France?
@@ -44,48 +50,51 @@ Your final answer: FINAL ANSWER: Paris
 
 # --- Tool Definitions ---
 
-# Global variable to cache the image-to-text pipeline. This allows for "lazy loading".
+# Global variable for lazy loading the image pipeline
 image_to_text_pipeline = None
 
 
 @tool
-def web_search(query: str):
-    """Searches the web using DuckDuckGo."""
+def web_search(query: str) -> str:
+    """Searches the web using DuckDuckGo for up-to-date information."""
     logging.info(f"--- Calling Web Search Tool with query: {query} ---")
     search = DuckDuckGoSearchRun()
     return search.run(query)
 
 
 @tool
-def math_calculator(expression: str):
-    """Calculates the result of a mathematical expression."""
+def math_calculator(expression: str) -> str:
+    """Calculates the result of a mathematical expression. Use it for any math operation."""
     logging.info(f"--- Calling Math Calculator Tool with expression: {expression} ---")
     try:
-        # Use numexpr for safe evaluation
+        # Sanitize expression: allow only numbers, basic operators, and parentheses
+        if not re.match(r"^[0-9\.\+\-\*\/\(\)\s]+$", expression):
+            return "Error: Invalid characters in expression."
         result = numexpr.evaluate(expression).item()
-        return result
+        return str(result)
     except Exception as e:
-        logging.error(f"Error evaluating expression: {e}")
-        return f"Error evaluating expression: {e}"
+        logging.error(f"Calculator error: {e}")
+        return f"Error: {e}"
 
 
 @tool
-def image_analyzer(image_url: str):
-    """Analyzes an image and returns a description. Loads the model on first use."""
+def image_analyzer(image_url: str) -> str:
+    """Analyzes an image from a URL and returns a text description."""
     global image_to_text_pipeline
     logging.info(f"--- Calling Image Analyzer Tool with URL: {image_url} ---")
     try:
         if image_to_text_pipeline is None:
             logging.info(
-                "--- Initializing Image Analyzer pipeline for the first time... ---"
+                "--- Initializing Image Analyzer pipeline (lazy loading)... ---"
             )
-            # Lazy-load the pipeline to conserve memory on startup
+            # This pipeline is small enough to be loaded on demand in a ZeroGPU space
+            from transformers import pipeline
+
             image_to_text_pipeline = pipeline(
                 "image-to-text", model="Salesforce/blip-image-captioning-base"
             )
             logging.info("--- Image Analyzer pipeline initialized. ---")
 
-        # More robustly handle the pipeline output
         pipeline_output = image_to_text_pipeline(image_url)
         if (
             pipeline_output
@@ -93,14 +102,10 @@ def image_analyzer(image_url: str):
             and len(pipeline_output) > 0
         ):
             description = pipeline_output[0].get(
-                "generated_text", "Error: Could not find text in image analysis result."
+                "generated_text", "Error: Could not generate text."
             )
         else:
-            logging.error(
-                f"Image analyzer returned no or invalid output for URL: {image_url}"
-            )
             description = "Error: Could not analyze image."
-
         return description
     except Exception as e:
         logging.error(f"Error analyzing image: {e}")
@@ -108,8 +113,8 @@ def image_analyzer(image_url: str):
 
 
 @tool
-def youtube_transcript_reader(youtube_url: str):
-    """Reads the transcript of a YouTube video."""
+def youtube_transcript_reader(youtube_url: str) -> str:
+    """Reads the transcript of a YouTube video from its URL."""
     logging.info(
         f"--- Calling YouTube Transcript Reader Tool with URL: {youtube_url} ---"
     )
@@ -117,11 +122,11 @@ def youtube_transcript_reader(youtube_url: str):
         loader = YoutubeLoader.from_youtube_url(youtube_url, add_video_info=False)
         docs = loader.load()
         transcript = " ".join([doc.page_content for doc in docs])
-        # Return a manageable chunk of the transcript
+        # Return a manageable chunk
         return transcript[:4000]
     except Exception as e:
         logging.error(f"Error reading YouTube transcript: {e}")
-        return f"Error reading YouTube transcript: {e}"
+        return f"Error: {e}"
 
 
 # --- Agent State Definition ---
@@ -142,32 +147,22 @@ class GaiaAgent:
             youtube_transcript_reader,
         ]
 
-        # Initialize the LLM
-        logging.info("Loading LLM... This may take a few minutes on first startup.")
-        # Removing device_map for better compatibility with ZeroGPU environments
-        llm = HuggingFacePipeline.from_model_id(
-            model_id="microsoft/Phi-3-mini-4k-instruct",
+        # CHANGED: Replaced local HuggingFacePipeline with HuggingFaceInferenceAPI
+        # This uses the Hugging Face Serverless API, offloading the memory and compute.
+        # It requires a HUGGING_FACE_HUB_TOKEN to be set in the Space secrets.
+        logging.info("Initializing LLM via Inference API...")
+        llm = HuggingFaceInferenceAPI(
+            model_id="meta-llama/Meta-Llama-3-8B-Instruct",
+            # repo_id="meta-llama/Meta-Llama-3-8B-Instruct", # Use repo_id if model_id gives issues
             task="text-generation",
-            pipeline_kwargs={
-                "max_new_tokens": 512,
-                "top_k": 50,
-                "temperature": 0.1,
-                "do_sample": False,
-            },
-            torch_dtype="auto",
-            trust_remote_code=True,  # Required for Phi-3
+            token=os.getenv("HUGGING_FACE_HUB_TOKEN"),
         )
-        logging.info("LLM loaded successfully.")
+        logging.info("LLM initialized successfully.")
 
         # Create the agent graph
         prompt = PromptTemplate(
             template=SYSTEM_PROMPT
-            + """
-Here is the current conversation:
-{messages}
-
-Question: {question}
-""",
+            + "\nHere is the current conversation:\n{messages}\n\nQuestion: {question}",
             input_variables=["messages", "question"],
         )
 
@@ -180,7 +175,7 @@ Question: {question}
         graph.add_node("agent", self._call_agent)
         graph.add_node("tools", self._call_tools)
         graph.add_conditional_edges(
-            "agent", self._decide_action, {"tools": "tools", END: END}
+            "agent", self._decide_action, {END: END, "tools": "tools"}
         )
         graph.add_edge("tools", "agent")
         graph.set_entry_point("agent")
@@ -206,11 +201,15 @@ Question: {question}
         logging.info("--- Calling Tools ---")
         raw_tool_call = state["messages"][-1]
 
-        # Simple regex to find tool calls like tool_name("argument") or tool_name(argument)
         tool_call_match = re.search(r"(\w+)\s*\((.*?)\)", raw_tool_call, re.DOTALL)
         if not tool_call_match:
             logging.warning("No valid tool call found in agent response.")
-            return {"messages": ["No valid tool call found."], "sender": "tools"}
+            return {
+                "messages": [
+                    'No valid tool call found. Please format your response as `tool_name("argument")` or provide a `FINAL ANSWER:`.'
+                ],
+                "sender": "tools",
+            }
 
         tool_name = tool_call_match.group(1).strip()
         tool_input_str = tool_call_match.group(2).strip()
@@ -237,31 +236,40 @@ Question: {question}
                 }
         else:
             logging.warning(f"Tool '{tool_name}' not found.")
-            return {"messages": [f"Tool '{tool_name}' not found."], "sender": "tools"}
+            return {
+                "messages": [
+                    f"Tool '{tool_name}' not found. Available tools are: web_search, math_calculator, image_analyzer, youtube_transcript_reader."
+                ],
+                "sender": "tools",
+            }
 
     def __call__(self, question: str) -> str:
-        logging.info(f"Agent received question: {question[:100]}...")
-
-        initial_state = {"question": question, "messages": [], "sender": "user"}
+        logging.info(f"Agent received question (first 100 chars): {question[:100]}...")
+        try:
+            initial_state = {"question": question, "messages": [], "sender": "user"}
+            # Increased recursion limit for potentially complex questions
+            final_state = self.graph.invoke(initial_state, {"recursion_limit": 15})
+            final_response = final_state["messages"][-1]
 
-        final_state = self.graph.invoke(initial_state, {"recursion_limit": 10})
+            match = re.search(
+                r"FINAL ANSWER:\s*(.*)", final_response, re.IGNORECASE | re.DOTALL
+            )
+            if match:
+                extracted_answer = match.group(1).strip()
+                logging.info(f"Agent returning final answer: {extracted_answer}")
+                return extracted_answer
+            else:
+                logging.warning(
+                    "Agent could not find a final answer. Returning the last message."
+                )
+                # Fallback: return the last piece of the conversation if parsing fails
+                return final_response
+        except Exception as e:
+            logging.error(f"Error during agent invocation: {e}", exc_info=True)
+            return f"Error during agent invocation: {e}"
 
-        final_answer = final_state["messages"][-1]
 
-        # Extract the answer after "FINAL ANSWER:"
-        match = re.search(
-            r"FINAL ANSWER:\s*(.*)", final_answer, re.IGNORECASE | re.DOTALL
-        )
-        if match:
-            extracted_answer = match.group(1).strip()
-            logging.info(f"Agent returning final answer: {extracted_answer}")
-            return extracted_answer
-        else:
-            logging.warning(
-                "Agent could not find a final answer in the required format."
-            )
-            # Return a fallback answer if parsing fails
-            return "Could not determine the final answer."
+# --- Gradio App Logic (largely unchanged, but with enhanced logging) ---
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
@@ -279,7 +287,10 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if not space_id:
         logging.error("SPACE_ID environment variable is not set. Cannot proceed.")
-        return "SPACE_ID environment variable is not set. Cannot proceed.", None
+        return (
+            "CRITICAL ERROR: SPACE_ID environment variable is not set. Cannot generate submission.",
+            None,
+        )
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
@@ -289,8 +300,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     try:
         agent = GaiaAgent()
     except Exception as e:
-        logging.critical(f"Error instantiating agent: {e}", exc_info=True)
-        return f"Error initializing agent: {e}", None
+        logging.critical(f"Fatal error instantiating agent: {e}", exc_info=True)
+        return f"Fatal error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     logging.info(f"Agent code URL: {agent_code}")
@@ -305,7 +316,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             logging.warning("Fetched questions list is empty.")
             return "Fetched questions list is empty.", None
         logging.info(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
+    except Exception as e:
         logging.error(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
@@ -313,9 +324,12 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     logging.info(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
+    for i, item in enumerate(questions_data):
         task_id = item.get("task_id")
         question_text = item.get("question")
+        logging.info(
+            f"--- Processing question {i+1}/{len(questions_data)} (Task ID: {task_id}) ---"
+        )
         if not task_id or question_text is None:
             continue
 
@@ -378,18 +392,20 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         )
 
 
-# --- Build Gradio Interface ---
+# --- Build Gradio Interface (UI text is maintained as requested) ---
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
+
         1.  This Space contains a `langgraph`-based agent equipped with tools for web search, math, image analysis, and YouTube transcript reading.
         2.  Log in to your Hugging Face account using the button below. Your HF username is used for the submission.
         3.  Click 'Run Evaluation & Submit All Answers' to fetch the questions, run the agent, submit the answers, and see your score.
+
         ---
         **Disclaimer:**
-        -   Once you click the submit button, please be patient. The agent needs time to process all the questions, which can take several minutes depending on the model and hardware.
+        Once you click the submit button, please be patient. The agent needs time to process all the questions, which can take several minutes.
         """
     )
 
@@ -408,11 +424,8 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    # Configure logging
     logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
+        level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
     )
-    logging.info("\n" + "-" * 30 + " App Starting " + "-" * 30)
+    logging.info("App Starting...")
     demo.launch(debug=True, share=False)