Update app.py

app.py

@@ -3,8 +3,8 @@ import gradio as gr
 import requests
 import pandas as pd
 from datetime import datetime
-from transformers import pipeline, Tool
-from transformers.agents import Agent
+from smolagents import Tool, ToolCallingAgent
+from smolagents.models import InferenceClientModel
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -13,21 +13,8 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class CalculatorTool(Tool):
     name = "calculator"
     description = "Performs mathematical calculations"
-    inputs = {
-        "expression": {
-            "type": "text",
-            "description": "Mathematical expression to evaluate"
-        }
-    }
-    outputs = {
-        "result": {
-            "type": "text",
-            "description": "Result of the calculation"
-        }
-    }
-    output_type = "text"
     
-    def __call__(self, expression: str) -> str:
+    def use(self, expression: str) -> str:
         try:
             return str(eval(expression))
         except:
@@ -36,32 +23,26 @@ class CalculatorTool(Tool):
 class TimeTool(Tool):
     name = "current_time"
     description = "Gets current UTC time"
-    inputs = {}
-    outputs = {
-        "time": {
-            "type": "text",
-            "description": "Current time in UTC format"
-        }
-    }
-    output_type = "text"
     
-    def __call__(self) -> str:
+    def use(self) -> str:
         return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
 
 # --- Enhanced Agent ---
-class HFLocalAgent:
+class LocalAgent:
     def __init__(self):
-        print("Initializing local Hugging Face agent...")
+        print("Initializing local agent with smolagents...")
         self.tools = {
             "calculator": CalculatorTool(),
             "time": TimeTool()
         }
         
-        # Load local model (small but efficient)
-        self.llm = pipeline(
-            "text-generation",
-            model="HuggingFaceH4/zephyr-7b-beta",
-            device="cpu"  # Change to "cuda" if GPU available
+        # Using a local model through smolagents
+        self.agent = ToolCallingAgent(
+            tools=list(self.tools.values()),
+            model=InferenceClientModel(
+                model_id="HuggingFaceH4/zephyr-7b-beta",
+                api_base="https://api-inference.huggingface.co/models"
+            )
         )
         
     def __call__(self, question: str) -> str:
@@ -70,23 +51,89 @@ class HFLocalAgent:
         
         # Math questions
         if any(word in question_lower for word in ["calculate", "what is", "how much is", "+", "-", "*", "/"]):
-            return self.tools["calculator"](question.replace("?", ""))
+            return self.tools["calculator"].use(question.replace("?", ""))
         
         # Time questions
         if any(word in question_lower for word in ["time", "current time"]):
-            return self.tools["time"]()
+            return self.tools["time"].use()
         
-        # Fallback to local LLM
+        # Fallback to agent with tools
         try:
-            response = self.llm(
-                f"Answer concisely: {question}",
-                max_new_tokens=100,
-                temperature=0.7
-            )
-            return response[0]['generated_text'].split(":")[-1].strip()
+            return self.agent.run(question)
         except Exception as e:
-            print(f"LLM error: {e}")
+            print(f"Agent error: {e}")
             return "I couldn't process this question."
 
-# [Rest of the code remains exactly the same as in the previous implementation]
-# Including the run_and_submit_all function and Gradio interface
+# --- Evaluation Runner ---
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    if not profile:
+        return "Please login first", None
+    
+    space_id = os.getenv("SPACE_ID", "local-test")
+    api_url = os.getenv("API_URL", DEFAULT_API_URL)
+    
+    try:
+        agent = LocalAgent()
+        response = requests.get(f"{api_url}/questions", timeout=15)
+        response.raise_for_status()
+        questions = response.json()
+        
+        results = []
+        answers = []
+        for q in questions:
+            try:
+                answer = agent(q["question"])
+                answers.append({
+                    "task_id": q["task_id"], 
+                    "submitted_answer": answer
+                })
+                results.append({
+                    "Task ID": q["task_id"], 
+                    "Question": q["question"], 
+                    "Answer": answer
+                })
+            except Exception as e:
+                results.append({
+                    "Task ID": q["task_id"], 
+                    "Question": q["question"], 
+                    "Answer": f"Error: {e}"
+                })
+        
+        submission = {
+            "username": profile.username,
+            "agent_code": f"https://huggingface.co/spaces/{space_id}",
+            "answers": answers
+        }
+        
+        response = requests.post(f"{api_url}/submit", json=submission, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+        
+        return (
+            f"Success! Score: {result.get('score', 'N/A')}%\n"
+            f"Correct: {result.get('correct_count', '?')}/{result.get('total_attempted', '?')}",
+            pd.DataFrame(results)
+        )
+        
+    except Exception as e:
+        return f"Evaluation failed: {str(e)}", pd.DataFrame(results if 'results' in locals() else [])
+
+# --- Gradio Interface ---
+with gr.Blocks(title="Local Agent Evaluator") as app:
+    gr.Markdown("""
+    ## Local Agent Evaluation
+    Uses smolagents with local Hugging Face models
+    """)
+    
+    gr.LoginButton()
+    run_btn = gr.Button("Start Evaluation")
+    output = gr.Textbox(label="Results")
+    results = gr.DataFrame(label="Details")
+    
+    run_btn.click(
+        fn=run_and_submit_all,
+        outputs=[output, results]
+    )
+
+if __name__ == "__main__":
+    app.launch()