test3

app.py

@@ -2,88 +2,67 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+import datetime
 from openai import OpenAI
 
-# Constants
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# ToolEnhancedAgent menggunakan OpenAI API terbaru (1.x)
 class ToolEnhancedAgent:
     def __init__(self):
         api_key = os.getenv("OPENAI_API_KEY")
         if not api_key:
-            raise ValueError("OPENAI_API_KEY not found in environment variables.")
+            raise ValueError("OPENAI_API_KEY is not set.")
         self.client = OpenAI(api_key=api_key)
-        print("ToolEnhancedAgent initialized with OpenAI GPT model.")
+        print("ToolEnhancedAgent initialized.")
 
     def use_tool(self, tool_name: str, input_text: str) -> str:
-        # Contoh penggunaan tool sederhana: kalkulator, tanggal, Wikipedia
         try:
             if tool_name == "calculator":
-                # Aman eval dengan math
-                import math
-                return str(eval(input_text, {"__builtins__": None, "math": math}))
+                return str(eval(input_text))
             elif tool_name == "date":
-                import datetime
                 return str(datetime.datetime.now().date())
             elif tool_name == "wikipedia":
-                return self.search_wikipedia(input_text)
+                res = requests.get(f"https://en.wikipedia.org/api/rest_v1/page/summary/{input_text}")
+                if res.status_code == 200:
+                    return res.json().get("extract", "No summary found.")
+                else:
+                    return "No summary found."
             else:
-                return "[Tool Error: Unknown tool]"
+                return "[Unknown Tool]"
         except Exception as e:
             return f"[Tool Error: {e}]"
 
-    def search_wikipedia(self, query: str) -> str:
-        try:
-            res = requests.get(f"https://en.wikipedia.org/api/rest_v1/page/summary/{query}")
-            if res.status_code == 200:
-                return res.json().get("extract", "No summary found.")
-            return f"No Wikipedia summary for {query}."
-        except Exception as e:
-            return f"Wikipedia Error: {e}"
-
     def __call__(self, question: str) -> str:
-        # Prompt dengan Chain of Thought dan instruksi penggunaan tools
-        prompt = (
-            "You are an AI assistant that can think step-by-step and use tools when needed.\n"
-            f"Question: {question}\n"
-            "Answer with your reasoning steps. If needed, mention the tool you want to use like [calculator], [date], [wikipedia]."
-        )
-
         try:
+            prompt = f"""
+You are an advanced AI assistant with access to tools like calculator, date lookup, and Wikipedia.
+Follow this format:
+Step 1: Think step-by-step.
+Step 2: Use tool if needed.
+Step 3: Final answer.
+
+Question: {question}
+Answer:
+"""
+            messages = [
+                {"role": "system", "content": "You are a helpful assistant that uses tools and thinks step-by-step."},
+                {"role": "user", "content": prompt}
+            ]
             response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant using tools and reasoning."},
-                    {"role": "user", "content": prompt}
-                ],
+                model="gpt-4",
+                messages=messages,
                 temperature=0.3,
-                max_tokens=700,
+                max_tokens=700
             )
-            answer = response.choices[0].message.content.strip()
-            # Simple tool simulation: jika ada tag [tool:toolname] di jawaban, gunakan tool dan tambahkan hasilnya
-            # Contoh: "[calculator] 2+2" -> hitung 4 dan tambahkan ke jawaban
-            import re
-            pattern = r"\[([a-z]+)\](.*)"
-            match = re.search(pattern, answer, re.IGNORECASE)
-            if match:
-                tool_name = match.group(1).lower()
-                tool_input = match.group(2).strip()
-                tool_result = self.use_tool(tool_name, tool_input)
-                answer += f"\n\n[Tool used: {tool_name}]\nResult: {tool_result}"
-            return answer
+            return response.choices[0].message.content.strip()
         except Exception as e:
-            print(f"Agent error: {e}")
             return f"[Agent Error: {e}]"
 
-# Revisi run_and_submit_all untuk menerima profile (LoginButton output)
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    if profile is None:
-        return "Please login with your Hugging Face account.", None
-
-    username = profile.username
-    space_id = os.getenv("SPACE_ID") or "your-username/your-space"  # Ganti sesuai space kamu jika perlu
-
+def run_and_submit_all():
+    profile_username = os.getenv("HF_USER") or "anonymous"
+    space_id = os.getenv("SPACE_ID")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
@@ -91,85 +70,63 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     try:
         agent = ToolEnhancedAgent()
     except Exception as e:
-        return f"Error initializing agent: {e}", None
-
-    agent_code_url = f"https://huggingface.co/spaces/{space_id}/tree/main"
+        return f"Failed to initialize agent: {e}", pd.DataFrame()
 
-    # Ambil pertanyaan
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
+        res = requests.get(questions_url, timeout=20)
+        res.raise_for_status()
+        questions_data = res.json()
     except Exception as e:
-        return f"Error fetching questions: {e}", None
+        return f"Error fetching questions: {e}", pd.DataFrame()
 
     answers_payload = []
-    results_log = []
+    log = []
 
-    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:
+    for q in questions_data:
+        task_id = q.get("task_id")
+        question = q.get("question")
+        if not task_id or not question:
             continue
         try:
-            answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text,
-                "Submitted Answer": answer,
-            })
+            answer = agent(question)
         except Exception as e:
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text,
-                "Submitted Answer": f"Agent Error: {e}",
-            })
+            answer = f"[Error]: {e}"
+        answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+        log.append({"Task ID": task_id, "Question": question, "Submitted Answer": answer})
 
     if not answers_payload:
-        return "Agent did not produce answers to submit.", pd.DataFrame(results_log)
+        return "No answers submitted.", pd.DataFrame(log)
 
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code_url,
-        "answers": answers_payload,
+    submission = {
+        "username": profile_username,
+        "agent_code": agent_code,
+        "answers": answers_payload
     }
 
     try:
-        submit_response = requests.post(submit_url, json=submission_data, timeout=60)
-        submit_response.raise_for_status()
-        result = submit_response.json()
-
-        status = (
-            f"Submission Successful!\n"
+        res = requests.post(submit_url, json=submission, timeout=30)
+        res.raise_for_status()
+        result = res.json()
+        msg = (
+            f"✅ Submission Successful!\n"
             f"User: {result.get('username')}\n"
-            f"Score: {result.get('score', 'N/A')}% "
-            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')} correct)\n"
-            f"Message: {result.get('message', 'No message')}"
+            f"Score: {result.get('score')}%\n"
+            f"Correct: {result.get('correct_count')}/{result.get('total_attempted')}\n"
+            f"Message: {result.get('message')}"
         )
-        return status, pd.DataFrame(results_log)
+        return msg, pd.DataFrame(log)
     except Exception as e:
-        return f"Submission failed: {e}", pd.DataFrame(results_log)
+        return f"❌ Submission Failed: {e}", pd.DataFrame(log)
 
-# Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Benchmark Agent Runner")
-    gr.Markdown("""
-    1. Login with your Hugging Face account.
-    2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, and submit answers.
-    """)
-
-    login_btn = gr.LoginButton()
-    run_btn = gr.Button("Run Evaluation & Submit All Answers")
-
-    status_out = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_df = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    gr.Markdown("# 🔍 GAIA Agent Evaluator")
+    gr.Markdown("Log in, then click the button to evaluate your agent.")
+    run_button = gr.Button("▶️ Run Evaluation & Submit All Answers")
+    status = gr.Textbox(label="Status", lines=4)
+    table = gr.DataFrame(label="Agent Logs")
 
-    run_btn.click(
-        fn=run_and_submit_all,
-        inputs=[login_btn],
-        outputs=[status_out, results_df]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    print("Launching GAIA App...")
+    demo.launch()