Update app.py

app.py

@@ -2,7 +2,6 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-import anthropic
 import re
 from duckduckgo_search import DDGS
 
@@ -12,7 +11,6 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Tool Implementations ---
 
 def web_search(query: str) -> str:
-    """Search the web using DuckDuckGo."""
     try:
         with DDGS() as ddgs:
             results = list(ddgs.text(query, max_results=5))
@@ -20,298 +18,187 @@ def web_search(query: str) -> str:
             return "No results found."
         output = []
         for r in results:
-            output.append(f"Title: {r.get('title', '')}\nURL: {r.get('href', '')}\nSnippet: {r.get('body', '')}\n")
+            output.append(f"Title: {r.get('title', '')}\nSnippet: {r.get('body', '')}")
         return "\n---\n".join(output)
     except Exception as e:
         return f"Search error: {e}"
 
 
-def fetch_page(url: str) -> str:
-    """Fetch content from a URL."""
-    try:
-        headers = {"User-Agent": "Mozilla/5.0"}
-        response = requests.get(url, headers=headers, timeout=10)
-        response.raise_for_status()
-        # Basic text extraction
-        text = response.text
-        # Remove HTML tags crudely
-        text = re.sub(r'<[^>]+>', ' ', text)
-        text = re.sub(r'\s+', ' ', text).strip()
-        return text[:3000]
-    except Exception as e:
-        return f"Error fetching page: {e}"
-
-
-def run_python(code: str) -> str:
-    """Execute Python code and return the output."""
-    import sys
-    from io import StringIO
-    old_stdout = sys.stdout
-    sys.stdout = StringIO()
-    try:
-        exec_globals = {}
-        exec(code, exec_globals)
-        output = sys.stdout.getvalue()
-        return output if output else "Code executed successfully (no output)."
-    except Exception as e:
-        return f"Error executing code: {e}"
-    finally:
-        sys.stdout = old_stdout
-
-
 def wikipedia_search(query: str) -> str:
-    """Search Wikipedia for a topic."""
     try:
         search_url = "https://en.wikipedia.org/w/api.php"
-        params = {
-            "action": "query",
-            "list": "search",
-            "srsearch": query,
-            "format": "json",
-            "srlimit": 3,
-        }
+        params = {"action": "query", "list": "search", "srsearch": query, "format": "json", "srlimit": 1}
         response = requests.get(search_url, params=params, timeout=10)
         data = response.json()
         results = data.get("query", {}).get("search", [])
         if not results:
             return "No Wikipedia results found."
-        
-        # Fetch first result's summary
         title = results[0]["title"]
-        summary_params = {
-            "action": "query",
-            "titles": title,
-            "prop": "extracts",
-            "exintro": True,
-            "explaintext": True,
-            "format": "json",
-        }
+        summary_params = {"action": "query", "titles": title, "prop": "extracts", "exintro": True, "explaintext": True, "format": "json"}
         summary_response = requests.get(search_url, params=summary_params, timeout=10)
         summary_data = summary_response.json()
         pages = summary_data.get("query", {}).get("pages", {})
         for page_id, page in pages.items():
             extract = page.get("extract", "No content available.")
-            return f"Wikipedia: {title}\n\n{extract[:2000]}"
+            return f"Wikipedia: {title}\n\n{extract[:3000]}"
         return "No content found."
     except Exception as e:
         return f"Wikipedia error: {e}"
 
 
-# --- Tool Definitions for Claude API ---
-TOOLS = [
-    {
-        "name": "web_search",
-        "description": "Search the web for current information. Use this for facts, recent events, or anything that requires looking up.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": "The search query"
-                }
-            },
-            "required": ["query"]
-        }
-    },
-    {
-        "name": "wikipedia_search",
-        "description": "Search Wikipedia for factual information about people, places, events, concepts, etc.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": "The topic to search on Wikipedia"
-                }
-            },
-            "required": ["query"]
-        }
-    },
-    {
-        "name": "fetch_page",
-        "description": "Fetch and read the content of a specific URL/webpage.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "url": {
-                    "type": "string",
-                    "description": "The URL to fetch"
-                }
-            },
-            "required": ["url"]
-        }
-    },
-    {
-        "name": "run_python",
-        "description": "Execute Python code for calculations, data processing, or logic. Returns stdout output.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "code": {
-                    "type": "string",
-                    "description": "Python code to execute"
-                }
-            },
-            "required": ["code"]
-        }
-    }
-]
-
-TOOL_FUNCTIONS = {
-    "web_search": web_search,
-    "wikipedia_search": wikipedia_search,
-    "fetch_page": fetch_page,
-    "run_python": run_python,
-}
-
-SYSTEM_PROMPT = """You are a general AI assistant solving benchmark questions. 
-
-For each question:
-1. Think carefully about what information you need
-2. Use tools to search for facts, do calculations, or fetch web pages
-3. Reason step by step
-4. Give ONLY the final answer - no explanation, no "FINAL ANSWER:" prefix
-
-Your answer should be:
-- A number (no units unless specified, no commas in numbers)
-- A short phrase (no articles like "the" or "a", no abbreviations for proper nouns)  
-- A comma-separated list of numbers/strings
-
-Be precise. The answer is checked by exact match."""
+def run_python(code: str) -> str:
+    import sys
+    from io import StringIO
+    old_stdout = sys.stdout
+    sys.stdout = StringIO()
+    try:
+        exec_globals = {}
+        exec(code, exec_globals)
+        output = sys.stdout.getvalue()
+        return output if output else "Code executed (no output)."
+    except Exception as e:
+        return f"Error: {e}"
+    finally:
+        sys.stdout = old_stdout
 
 
 class SmartAgent:
     def __init__(self):
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            raise ValueError("ANTHROPIC_API_KEY environment variable not set!")
-        self.client = anthropic.Anthropic(api_key=api_key)
-        self.model = "claude-opus-4-5"
-        print("SmartAgent (Claude-powered) initialized.")
+        self.hf_token = os.getenv("HF_TOKEN")
+        if not self.hf_token:
+            raise ValueError("HF_TOKEN environment variable not set!")
+        self.api_url = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-72B-Instruct/v1/chat/completions"
+        self.headers = {"Authorization": f"Bearer {self.hf_token}"}
+        print("SmartAgent initialized with Qwen2.5-72B (HF Inference API - FREE)")
+
+    def call_llm(self, messages: list) -> str:
+        payload = {
+            "model": "Qwen/Qwen2.5-72B-Instruct",
+            "messages": messages,
+            "max_tokens": 1024,
+            "temperature": 0.1,
+        }
+        response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=60)
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"]
 
     def __call__(self, question: str) -> str:
         print(f"\nQuestion: {question[:100]}...")
-        messages = [{"role": "user", "content": question}]
-        
-        max_iterations = 10
-        for iteration in range(max_iterations):
-            response = self.client.messages.create(
-                model=self.model,
-                max_tokens=4096,
-                system=SYSTEM_PROMPT,
-                tools=TOOLS,
-                messages=messages,
-            )
-            
-            # Check if we're done
-            if response.stop_reason == "end_turn":
-                # Extract text answer
-                for block in response.content:
-                    if hasattr(block, "text"):
-                        answer = block.text.strip()
-                        # Clean up any "FINAL ANSWER:" prefix if model adds it
-                        answer = re.sub(r'^FINAL ANSWER:\s*', '', answer, flags=re.IGNORECASE).strip()
-                        print(f"Answer: {answer}")
-                        return answer
-                return "No answer"
-            
-            # Process tool calls
-            if response.stop_reason == "tool_use":
-                # Add assistant's response to messages
-                messages.append({"role": "assistant", "content": response.content})
-                
-                # Execute all tool calls
-                tool_results = []
-                for block in response.content:
-                    if block.type == "tool_use":
-                        tool_name = block.name
-                        tool_input = block.input
-                        print(f"  Tool: {tool_name}({list(tool_input.values())[0] if tool_input else ''})")
-                        
-                        try:
-                            func = TOOL_FUNCTIONS.get(tool_name)
-                            if func:
-                                result = func(**tool_input)
-                            else:
-                                result = f"Unknown tool: {tool_name}"
-                        except Exception as e:
-                            result = f"Tool error: {e}"
-                        
-                        tool_results.append({
-                            "type": "tool_result",
-                            "tool_use_id": block.id,
-                            "content": str(result)[:5000],
-                        })
-                
-                messages.append({"role": "user", "content": tool_results})
+
+        system_prompt = """You are a precise AI assistant solving benchmark questions.
+
+You have access to these tools - call them by outputting exactly:
+SEARCH: <query>
+WIKIPEDIA: <query>
+PYTHON: <code>
+
+Rules:
+- Use tools to look up facts you are unsure about
+- After gathering info, output your final answer as: ANSWER: <your answer>
+- Answer must be a number, short phrase, or comma-separated list
+- No articles (a/the), no units unless asked, no explanations
+- The answer is checked by exact match so be precise"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": question}
+        ]
+
+        for iteration in range(6):
+            response = self.call_llm(messages)
+            print(f"  LLM: {response[:200]}")
+
+            answer_match = re.search(r'ANSWER:\s*(.+?)(?:\n|$)', response, re.IGNORECASE)
+            if answer_match:
+                answer = answer_match.group(1).strip()
+                print(f"  Final answer: {answer}")
+                return answer
+
+            tool_result = None
+
+            search_match = re.search(r'SEARCH:\s*(.+?)(?:\n|$)', response)
+            if search_match:
+                query = search_match.group(1).strip()
+                print(f"  Tool: web_search({query})")
+                tool_result = f"Search results for '{query}':\n{web_search(query)}"
+
+            wiki_match = re.search(r'WIKIPEDIA:\s*(.+?)(?:\n|$)', response)
+            if wiki_match:
+                query = wiki_match.group(1).strip()
+                print(f"  Tool: wikipedia({query})")
+                tool_result = f"Wikipedia results for '{query}':\n{wikipedia_search(query)}"
+
+            python_match = re.search(r'PYTHON:\s*```(?:python)?\n?(.*?)```', response, re.DOTALL)
+            if not python_match:
+                python_match = re.search(r'PYTHON:\s*(.+?)(?:\nSEARCH|\nWIKIPEDIA|\nANSWER|$)', response, re.DOTALL)
+            if python_match:
+                code = python_match.group(1).strip()
+                print(f"  Tool: python({code[:50]})")
+                tool_result = f"Python output:\n{run_python(code)}"
+
+            if tool_result:
+                messages.append({"role": "assistant", "content": response})
+                messages.append({"role": "user", "content": tool_result})
             else:
-                # Unexpected stop reason
-                break
-        
-        return "Unable to determine answer"
+                messages.append({"role": "assistant", "content": response})
+                messages.append({"role": "user", "content": "Please provide your final answer now using: ANSWER: <your answer>"})
+
+        last_response = self.call_llm(messages)
+        answer_match = re.search(r'ANSWER:\s*(.+?)(?:\n|$)', last_response, re.IGNORECASE)
+        if answer_match:
+            return answer_match.group(1).strip()
+        return last_response.strip().split('\n')[0][:200]
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Fetches all questions, runs the SmartAgent, submits answers, and displays results."""
     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
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
     try:
         agent = SmartAgent()
     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"
-    print(agent_code)
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            return "Fetched questions list is empty or invalid format.", None
+            return "Fetched questions list is empty.", None
         print(f"Fetched {len(questions_data)} questions.")
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    # 3. Run Agent on all questions
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
     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
         try:
             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})
         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}"})
+            print(f"Error on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"ERROR: {e}"})
 
     if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        return "Agent did not produce any answers.", pd.DataFrame(results_log)
 
-    # 4. Submit
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    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()
@@ -323,7 +210,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             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.")
         return final_status, pd.DataFrame(results_log)
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
@@ -334,52 +220,30 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             error_detail += f" Response: {e.response.text[:500]}"
         return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
     except Exception as e:
-        return f"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
+        return f"Submission error: {e}", pd.DataFrame(results_log)
 
 
-# --- Gradio Interface ---
 with gr.Blocks() as demo:
     gr.Markdown("# 🤖 Smart Agent — GAIA Benchmark Runner")
     gr.Markdown(
         """
-        **Powered by Claude with Web Search, Wikipedia, and Python tools**
-        
+        **Powered by Qwen2.5-72B via HuggingFace Inference API (FREE)**
+
         **Instructions:**
-        1. Make sure `ANTHROPIC_API_KEY` is set in your Space secrets
+        1. Make sure `HF_TOKEN` is set in your Space secrets (your HF access token)
         2. Log in with your Hugging Face account below
         3. Click **Run Evaluation & Submit All Answers**
-        
-        The agent will fetch all 20 GAIA questions, reason through each one using tools, and submit your answers.
         """
     )
-
     gr.LoginButton()
-
     run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary")
-
     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)
-    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}")
-    else:
-        print("ℹ️ SPACE_HOST not found (running locally?)")
-
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-    else:
-        print("ℹ️ SPACE_ID not found (running locally?)")
-
-    print("-" * 74 + "\n")
-    print("Launching Gradio Interface...")
+    print("\n" + "=" * 30 + " Application Startup " + "=" * 30)
+    print(f"SPACE_HOST: {os.getenv('SPACE_HOST', 'not set')}")
+    print(f"SPACE_ID: {os.getenv('SPACE_ID', 'not set')}")
+    print("=" * 81 + "\n")
     demo.launch(debug=True, share=False)