Update app.py

app.py

@@ -8,8 +8,7 @@ import re # For parsing LLM output
 # --- HF Inference API for LLM ---
 from huggingface_hub import InferenceClient
 
-# You can choose a different model, but make sure it's good at instruction following and ReAct-style prompting.
-LLM_MODEL = "HuggingFaceH4/zephyr-7b-beta" # or "mistralai/Mistral-7B-Instruct-v0.2"
+LLM_MODEL = "HuggingFaceH4/zephyr-7b-beta"
 
 try:
     hf_token = os.getenv("HF_TOKEN")
@@ -19,21 +18,13 @@ except Exception as e:
     llm_client = None
 
 # --- Tools ---
-# 1. Search Tool (using DuckDuckGo)
 from duckduckgo_search import DDGS
 
 def search_tool(query: str) -> str:
-    """
-    Searches the web using DuckDuckGo for a given query and returns the top results.
-    Args:
-        query (str): The search query.
-    Returns:
-        str: A string containing the search results, or an error/status message.
-    """
     print(f"Tool: search_tool, Query: {query}")
     try:
         with DDGS() as ddgs:
-            results = ddgs.text(query, max_results=3) # Get top 3 results
+            results = ddgs.text(query, max_results=3)
             if results:
                 return "\n".join([f"Title: {r['title']}\nSnippet: {r['body']}\nURL: {r['href']}" for r in results])
             else:
@@ -42,16 +33,7 @@ def search_tool(query: str) -> str:
         print(f"Error in search_tool: {e}")
         return f"Error performing search: {str(e)}. This could be due to a network issue, an invalid query, or a rate limit."
 
-# 2. Calculator Tool
 def calculator_tool(expression: str) -> str:
-    """
-    Calculates the result of a mathematical expression.
-    Args:
-        expression (str): The mathematical expression to evaluate (e.g., "2+2", "100*3.14/4").
-                          It should be a valid Python-evaluable expression.
-    Returns:
-        str: The result of the calculation or an error message.
-    """
     print(f"Tool: calculator_tool, Expression: {expression}")
     try:
         result = eval(expression, {"__builtins__": {}}, {"sqrt": lambda x: x**0.5, "pi": 3.1415926535})
@@ -62,14 +44,13 @@ def calculator_tool(expression: str) -> str:
 
 # --- Agent Definition ---
 class ReActAgent:
-    def __init__(self, llm_client, tools: dict, max_iterations=7): # max_iterations can be tuned
+    def __init__(self, llm_client, tools: dict, max_iterations=7):
         print("ReActAgent initialized.")
         if llm_client is None:
-            raise ValueError("LLM client not initialized. Check HF_TOKEN and model availability.")
+            raise ValueError("LLM client not initialized.")
         self.llm = llm_client
         self.tools = tools
         self.max_iterations = max_iterations
-        self.stop_pattern = "Final Answer:"
 
         self.tool_descriptions = "\n".join([
             f"- {name}: {inspect.getdoc(func)}"
@@ -77,25 +58,25 @@ class ReActAgent:
         ])
         self.tool_names = ", ".join(tools.keys())
 
-        # Refined ReAct prompt template for exact match answers
         self.react_prompt_template = inspect.cleandoc(f"""
-            You are a helpful and observant AI assistant. Your goal is to answer the following question accurately.
-            You must use a step-by-step thinking process (Thought, Action, Observation).
+            You are a helpful AI assistant. Your goal is to answer the CURRENT question accurately.
+            Focus ONLY on the provided "Question:". Do not generate new questions or continue a dialogue beyond answering the current question.
+            You must use a step-by-step thinking process (Thought, Action, Observation) for the current question.
             The final answer submitted must be an EXACT match to the correct response, without any extra explanations or prefixes being part of the answer itself.
 
             Available tools:
             {self.tool_descriptions}
 
-            Use the following format:
+            Use the following format FOR THE CURRENT QUESTION ONLY:
             Question: the input question you must answer
-            Thought: You should always think about what to do.
-            Action: The action to take, should be one of [{self.tool_names}]. The input to the tool is between the brackets. For example: search_tool[query] or calculator_tool[expression].
-            Observation: The result of the action.
-            ... (this Thought/Action/Observation sequence can repeat up to {self.max_iterations} times)
-            Thought: I now know the final answer.
-            Final Answer: [Provide ONLY the precise answer here. For example, if the question is "What is 2+2?", the Final Answer should be just "4". Do not include any other text or explanations in the answer part itself.]
-
-            Begin!
+            Thought: Your reasoning and plan for the current question.
+            Action: The action to take for the current question, should be one of [{self.tool_names}]. Input to the tool is between brackets. E.g., search_tool[query] or calculator_tool[expression].
+            Observation: The result of the action for the current question.
+            ... (this Thought/Action/Observation sequence can repeat for the current question)
+            Thought: I now have enough information to answer the current question.
+            Final Answer: [Provide ONLY the precise answer to the CURRENT question here. For example, if the question is "What is 2+2?", the Final Answer should be just "4". Do not include any other text, reasoning, or new questions after this line.]
+
+            Let's begin with the current question.
         """) + "\nQuestion: {question}\n{scratchpad}"
 
 
@@ -103,11 +84,9 @@ class ReActAgent:
         try:
             response = self.llm.text_generation(
                 prompt,
-                max_new_tokens=512, # Adjust if LLM needs more space for thought process
-                temperature=0.1,    # Lower temperature for more deterministic and precise answers
-                do_sample=True,     # Often needed if temperature is not 1.0
-                                    # Using temperature < 1.0 makes it do_sample=True by default in many HuggingFace implementations
-                # stop_sequences=["Observation:"] # Can help, but might prematurely stop LLM. Parsing is more robust.
+                max_new_tokens=512,
+                temperature=0.1,
+                do_sample=True,
             )
             return response.strip()
         except Exception as e:
@@ -116,77 +95,75 @@ class ReActAgent:
 
     def __call__(self, question: str) -> str:
         print(f"ReActAgent received question (first 100 chars): {question[:100]}...")
-
         scratchpad = ""
-        # Initial prompt construction for the first turn
         current_prompt = self.react_prompt_template.format(question=question, scratchpad=scratchpad)
 
         for i in range(self.max_iterations):
             print(f"\nIteration {i+1}")
-            # Note: The scratchpad builds up. Ensure the LLM prompt correctly handles cumulative context.
-            # The current template appends the new LLM output and observation to the scratchpad.
-            # current_prompt is reconstructed each time using the *updated* scratchpad.
-
             llm_output = self.run_llm(current_prompt)
 
             if not llm_output:
                 print("LLM returned empty or error, stopping.")
                 return "Agent Error: LLM failed to respond."
 
-            # Append the LLM's full response (thought and potentially action or final answer) to scratchpad
             scratchpad += llm_output + "\n"
 
-            # Check for "Final Answer:" in the LLM's *current* output
-            final_answer_match = re.search(r"Final Answer:\s*(.*)", llm_output, re.DOTALL | re.IGNORECASE)
-            if final_answer_match:
-                answer = final_answer_match.group(1).strip()
-                print(f"Found Final Answer in LLM output: '{answer}'")
-                return answer # This is the clean answer
+            all_final_answers = re.findall(r"Final Answer:\s*(.*)", llm_output, re.DOTALL | re.IGNORECASE)
+            if all_final_answers:
+                answer = all_final_answers[-1].strip() # Get the last "Final Answer:"
+                
+                # Further clean up common patterns of LLM over-generation within the answer
+                if "Thought:" in answer:
+                    answer = answer.split("Thought:")[0].strip()
+                if "Action:" in answer:
+                    answer = answer.split("Action:")[0].strip()
+                if "Observation:" in answer:
+                    answer = answer.split("Observation:")[0].strip()
+                if "Question:" in answer: # If it starts generating a new question within the answer
+                    answer = answer.split("Question:")[0].strip()
+
+                # Handle nested "Final Answer:" in the extracted part
+                inner_final_answers = re.findall(r"Final Answer:\s*(.*)", answer, re.DOTALL | re.IGNORECASE)
+                if inner_final_answers:
+                    answer = inner_final_answers[-1].strip()
+                
+                print(f"Found and extracted Final Answer: '{answer}'")
+                return answer
 
-            # Parse Action from the LLM's *current* output
             action_match = re.search(r"Action:\s*([a-zA-Z_0-9]+)\[(.*?)\]", llm_output, re.DOTALL)
             if action_match:
                 tool_name = action_match.group(1).strip()
                 tool_input = action_match.group(2).strip()
-
                 if tool_name in self.tools:
                     print(f"Executing Tool: {tool_name}, Input: {tool_input}")
                     try:
                         observation = self.tools[tool_name](tool_input)
                     except Exception as e:
                         observation = f"Error executing tool {tool_name}: {e}"
-                    print(f"Observation: {observation[:200]}...") # Print truncated observation
-                    scratchpad += f"Observation: {observation}\n" # Add observation to scratchpad
+                    print(f"Observation: {observation[:200]}...")
+                    scratchpad += f"Observation: {observation}\n"
                 else:
                     print(f"Unknown tool: {tool_name}")
                     scratchpad += f"Observation: Error - Unknown tool '{tool_name}'. Available tools: {self.tool_names}\n"
             else:
-                # If no action and no Final Answer, it implies the LLM might be just thinking,
-                # or the output is malformed. The loop will continue, using the updated scratchpad.
-                print("No valid action found in LLM output for this iteration. LLM might be thinking or output is malformed.")
+                print("No valid action found in LLM output for this iteration.")
 
-            # Reconstruct the prompt for the next iteration with the updated scratchpad
             current_prompt = self.react_prompt_template.format(question=question, scratchpad=scratchpad)
 
-
-        # Fallback if max_iterations is reached without a "Final Answer:"
         print(f"Max iterations reached for question (first 50 chars): {question[:50]}...")
         standard_failure_message = "Agent could not determine an answer within the allowed steps."
         print(f"Returning standard failure message: {standard_failure_message}")
         return standard_failure_message
 
-
-# --- Constants (from template) ---
+# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Main Execution Logic (from template, modified to use ReActAgent) ---
+# --- Main Execution Logic ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if profile:
         username = f"{profile.username}"
-        print(f"User logged in: {username}")
     else:
-        print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
@@ -194,157 +171,79 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     submit_url = f"{api_url}/submit"
 
     try:
-        available_tools = {
-            "search_tool": search_tool,
-            "calculator_tool": calculator_tool,
-        }
+        available_tools = {"search_tool": search_tool, "calculator_tool": calculator_tool}
         if llm_client is None:
              return "LLM Client could not be initialized. Check logs and HF_TOKEN.", None
         agent = ReActAgent(llm_client=llm_client, tools=available_tools)
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Code not available (SPACE_ID not set)"
-    print(f"Agent code link: {agent_code}")
 
-    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=20)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            print("Fetched questions list is empty.")
             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
+    except Exception as e:
         return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-        print(f"Error decoding JSON response from questions endpoint: {e}")
-        print(f"Response text: {response.text[:500]}")
-        return f"Error decoding server response for questions: {e}", None
-
-    results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+
+    results_log, answers_payload = [], []
     for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
+        task_id, question_text = item.get("task_id"), item.get("question")
+        if not task_id or question_text is None: continue
         try:
             print(f"\n--- Processing Task ID: {task_id}, Question: {question_text[:100]}... ---")
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
-            print(f"Agent answer for task {task_id}: '{submitted_answer[:100]}...'") # Added quotes for clarity
+            print(f"Agent answer for task {task_id}: '{submitted_answer[:100]}...'")
         except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
 
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=120)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
+            f"Submission Successful!\nUser: {result_data.get('username')}\n"
             f"Overall Score: {result_data.get('score', 'N/A')}% "
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
+        return final_status, pd.DataFrame(results_log)
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        try: error_detail += f" Detail: {e.response.json().get('detail', e.response.text)}"
+        except: error_detail += f" Response: {e.response.text[:500]}"
+        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
 
-# --- Build Gradio Interface using Blocks (from template) ---
+# --- Gradio Interface ---
 with gr.Blocks() as demo:
     gr.Markdown("# ReAct Agent Evaluation Runner (GAIA Modified)")
-    gr.Markdown(
-        """
-        **Instructions:**
-        1.  This Space implements a ReAct (Reasoning-Action) agent using an LLM from the Hugging Face Inference API.
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-        4.  The agent uses a search tool (DuckDuckGo) and a calculator tool. The prompt has been refined to encourage EXACT MATCH answers.
-        ---
-        **Disclaimers:**
-        * LLM responses can be slow, and running through all questions will take time.
-        * The agent's performance depends heavily on the chosen LLM and the quality of its ReAct prompting.
-        * You may need to set an `HF_TOKEN` in your Space secrets if you use a gated model or encounter rate limits.
-        * The calculator tool uses `eval()` which has security implications if not carefully managed. For this specific benchmark it is a common simplification.
-        """
-    )
+    gr.Markdown("Instructions and disclaimers...") # Keep your existing markdown or customize
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Startup messages (space_host, space_id, llm_client status)
     space_host_startup = os.getenv("SPACE_HOST")
     space_id_startup = os.getenv("SPACE_ID")
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
-    if llm_client is None:
-        print("⚠️ LLM Client (InferenceClient) was not initialized. The agent will not work.")
-        print("   Please check if you need to set the HF_TOKEN secret in your Space settings,")
-        print(f"   and ensure the model '{LLM_MODEL}' is accessible via the Inference API.")
-    else:
-        print(f"✅ LLM Client initialized with model: {LLM_MODEL}")
-
+    if space_host_startup: print(f"✅ SPACE_HOST found: {space_host_startup}")
+    if space_id_startup: print(f"✅ SPACE_ID found: {space_id_startup}")
+    if llm_client is None: print("⚠️ LLM Client (InferenceClient) was not initialized.")
+    else: print(f"✅ LLM Client initialized with model: {LLM_MODEL}")
     print("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for ReAct Agent Evaluation...")
     demo.launch(debug=True, share=False)