Update app.py

app.py

@@ -3,74 +3,83 @@ 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"
 
-# --- Custom Tools ---
+# --- Custom Tools with Proper Input/Output Specifications ---
 class CalculatorTool(Tool):
     name = "calculator"
     description = "Performs mathematical calculations"
-    inputs = {"expression": {"type": "text"}}
-    outputs = {"result": {"type": "text"}}
-    output_type = "text"  # Added required attribute
-    
-    def __call__(self, expression: str) -> str:
+    input_schema = {
+        "expression": {
+            "type": "string",
+            "description": "Mathematical expression to evaluate (e.g., '2+2')"
+        }
+    }
+    output_schema = {
+        "result": {
+            "type": "string",
+            "description": "The calculated result of the expression"
+        }
+    }
+
+    def use(self, expression: str) -> dict:
         try:
-            return str(eval(expression))
-        except:
-            return "Error: Could not evaluate the expression"
+            return {"result": str(eval(expression))}
+        except Exception as e:
+            return {"result": f"Error: {str(e)}"}
 
 class TimeTool(Tool):
     name = "current_time"
     description = "Gets current UTC time"
-    inputs = {}
-    outputs = {"time": {"type": "text"}}
-    output_type = "text"  # Added required attribute
-    
-    def __call__(self) -> str:
-        return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
+    input_schema = {}  # No inputs needed
+    output_schema = {
+        "time": {
+            "type": "string",
+            "description": "Current time in UTC (YYYY-MM-DD HH:MM:SS)"
+        }
+    }
+
+    def use(self) -> dict:
+        return {"time": 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...")
-        self.tools = {
-            "calculator": CalculatorTool(),
-            "time": TimeTool()
-        }
+        print("Initializing agent with smolagents...")
+        self.tools = [CalculatorTool(), 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 free Hugging Face model
+        self.agent = ToolCallingAgent(
+            tools=self.tools,
+            model=InferenceClientModel(
+                model_id="HuggingFaceH4/zephyr-7b-beta",
+                api_base="https://api-inference.huggingface.co/models"
+            )
         )
         
     def __call__(self, question: str) -> str:
         print(f"Processing: {question[:100]}...")
         question_lower = question.lower()
         
-        # Math questions
+        # Direct tool usage for simple queries
         if any(word in question_lower for word in ["calculate", "what is", "how much is", "+", "-", "*", "/"]):
-            return self.tools["calculator"](question.replace("?", ""))
+            result = CalculatorTool().use(question.replace("?", ""))
+            return result["result"]
         
-        # Time questions
         if any(word in question_lower for word in ["time", "current time"]):
-            return self.tools["time"]()
+            result = TimeTool().use()
+            return result["time"]
         
-        # Fallback to local LLM
+        # Use full agent for complex questions
         try:
-            response = self.llm(
-                f"Answer concisely: {question}",
-                max_new_tokens=100,
-                temperature=0.7
-            )
-            return response[0]['generated_text'].split(":")[-1].strip()
+            response = self.agent.run(question)
+            return str(response)
         except Exception as e:
-            print(f"LLM error: {e}")
+            print(f"Agent error: {e}")
             return "I couldn't process this question."
 
 # --- Evaluation Runner ---
@@ -82,7 +91,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     api_url = os.getenv("API_URL", DEFAULT_API_URL)
     
     try:
-        agent = HFLocalAgent()
+        agent = LocalAgent()
         response = requests.get(f"{api_url}/questions", timeout=15)
         response.raise_for_status()
         questions = response.json()
@@ -128,20 +137,20 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return f"Evaluation failed: {str(e)}", pd.DataFrame(results if 'results' in locals() else [])
 
 # --- Gradio Interface ---
-with gr.Blocks(title="Local HF Agent Evaluator") as app:
+with gr.Blocks(title="Agent Evaluation Runner") as app:
     gr.Markdown("""
-    ## Local Hugging Face Agent Evaluation
-    Uses completely free/local models - no API keys required
+    ## Advanced Agent Evaluation
+    Uses smolagents with proper tool schemas
     """)
     
     gr.LoginButton()
-    run_btn = gr.Button("Start Evaluation")
+    run_btn = gr.Button("Run Evaluation")
     output = gr.Textbox(label="Results")
-    results = gr.DataFrame(label="Details")
+    results_table = gr.DataFrame(label="Question Log")
     
     run_btn.click(
         fn=run_and_submit_all,
-        outputs=[output, results]
+        outputs=[output, results_table]
     )
 
 if __name__ == "__main__":