feat: improving agent

.gitignore

@@ -1,2 +1,8 @@
 .env
 .venv
+
+model_answer.json
+
+__pycache__
+
+

app.py

@@ -3,20 +3,47 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel
+import json
+from pathlib import Path
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel,WebSearchTool, VisitWebpageTool, ToolCallingAgent,LiteLLMModel,OpenAIServerModel
+from dotenv import load_dotenv
+load_dotenv()
 
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+model = OpenAIServerModel(
+    model_id="gemini-2.5-flash-lite-preview-06-17",
+    # Google Gemini OpenAI-compatible API base URL
+    api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
+    api_key=GEMINI_API_KEY,
+)
+# web_agent = ToolCallingAgent(
+#     tools=[WebSearchTool(), visit_webpage],
+#     model=model,
+#     max_steps=10,
+#     name="web_search_agent",
+#     description="Runs web searches for you.",
+# )
+
+# manager_agent = CodeAgent(
+#     tools=[],
+#     model=model,
+#     managed_agents=[web_agent],
+#     additional_authorized_imports=["time", "numpy", "pandas"],
+# )
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
 agent = CodeAgent(
-    tools=[DuckDuckGoSearchTool()], 
-    model=InferenceClientModel(),
-    planning_interval=3
+    tools=[WebSearchTool(), VisitWebpageTool()], 
+    model=model,
+    planning_interval=3,
+    additional_authorized_imports=["time", "numpy", "pandas", "requests", "bs4", "re", "markdownify"],
+    max_steps=5
     )
 
-
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
@@ -24,7 +51,22 @@ class BasicAgent:
         print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        final_answer = agent.run(question)
+        PROMPT = """
+        You are a helpful assistant that can answer questions and help with tasks. 
+        You will receive a question that can be either a question, a task, some common knowledge, some information related to documents, combination of all. 
+
+        You can use the following tools to help you:
+        - DuckDuckGoSearchTool: Search the web for information.
+        - WebSearchTool: Search the web for information.
+        - VisitWebpageTool: Visit a webpage and return the content.
+
+        You will the answer only, no other text.    
+        Provide the answer as a string. Do not include any other text. Provide the answer in <answer> tags.
+        Question: {question}
+        Answer:
+        """
+        agent_answer = agent.run(PROMPT.format(question=question))
+        final_answer = agent_answer.split("<answer>")[1].split("</answer>")[0]
         print(f"Agent returning fixed answer: {final_answer}")
         return final_answer
 
@@ -78,75 +120,121 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
 
-    # 3. Run your Agent
+    # 3. Load cached answers from model_answer.json (if present)
+    answers_file = Path(__file__).with_name("model_answer.json")
+    cached_answers = []
+    if answers_file.exists():
+        try:
+            cached_answers = json.loads(answers_file.read_text(encoding="utf-8"))
+            print(f"Loaded {len(cached_answers)} cached answers from {answers_file.name}.")
+        except json.JSONDecodeError as e:
+            print(f"Warning: Could not parse {answers_file.name}: {e}. Continuing without cached answers.")
+            cached_answers = []
+    else:
+        print(f"No cached answers file found at {answers_file}. Will rely entirely on the agent.")
+
+    # Make a lookup dict by task_id for quick access
+    cached_by_task_id = {item.get("task_id"): item.get("answer") for item in cached_answers if item.get("task_id")}
+
+    # 4. Run your Agent OR use cached answers
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+    print(f"Answering {len(questions_data)} questions (cached answers will be used when available)...")
     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}"})
+
+        # Prefer cached answer if we have one
+        submitted_answer = cached_by_task_id.get(task_id)
+        if submitted_answer is None:
+            try:
+                submitted_answer = agent(question_text)
+                print(f"Generated answer for task {task_id}: {submitted_answer}")
+            except Exception as e:
+                print(f"Error running agent on task {task_id}: {e}")
+                submitted_answer = f"AGENT ERROR: {e}"
+        else:
+            print(f"Using cached answer for task {task_id}: {submitted_answer}")
+
+        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})
 
     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)
+        print("No answers produced to submit.")
+        return "No answers produced to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
-    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)
+    # 5. Submit each answer individually
+    print(f"Submitting {len(answers_payload)} answers one-by-one to: {submit_url}")
+    successes = 0
+    submission_results = []
+    
+    for answer_item in answers_payload:
+        submission_data = {
+            "username": username.strip(),
+            "agent_code": agent_code,
+            "answers": [answer_item],  # single answer per request
+        }
+        try:
+            response = requests.post(submit_url, json=submission_data, timeout=60)
+            response.raise_for_status()
+            result_json = response.json()
+            successes += 1
+            score = result_json.get('score', 0)
+            message = result_json.get('message', 'No message')
+            print(f"Submitted task {answer_item['task_id']} ✓ Score: {score} Message: {message}")
+            submission_results.append({
+                "task_id": answer_item['task_id'],
+                "score": score,
+                "success": True,
+                "message": message
+            })
+        except Exception as e:
+            print(f"Failed to submit task {answer_item['task_id']}: {e}")
+            submission_results.append({
+                "task_id": answer_item['task_id'],
+                "score": 0,
+                "success": False,
+                "message": str(e)
+            })
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # Calculate overall statistics
+    total_score = sum(result['score'] for result in submission_results if result['success'])
+    successful_submissions = len([r for r in submission_results if r['success']])
+    correct_answers = len([r for r in submission_results if r['score'] > 0])
+    
+    # ALSO do a batch submission for leaderboard purposes
+    print(f"\n--- BATCH SUBMISSION FOR LEADERBOARD ---")
+    batch_submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {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.')}"
+        batch_response = requests.post(submit_url, json=batch_submission_data, timeout=60)
+        batch_response.raise_for_status()
+        batch_result = batch_response.json()
+        batch_status = (
+            f"BATCH SUBMISSION:\n"
+            f"User: {batch_result.get('username')}\n"
+            f"Overall Score: {batch_result.get('score', 'N/A')}% "
+            f"({batch_result.get('correct_count', '?')}/{batch_result.get('total_attempted', '?')} correct)\n"
+            f"Message: {batch_result.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    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
+        print(batch_status)
     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
+        batch_status = f"Batch submission failed: {e}"
+        print(batch_status)
+    
+    final_status = (
+        f"Individual Submission Results:\n"
+        f"Successfully submitted: {successful_submissions}/{len(answers_payload)} answers\n"
+        f"Total accumulated score: {total_score}\n"
+        f"Average score per question: {total_score/len(answers_payload):.1f}\n"
+        f"Questions answered correctly: {correct_answers}/{len(answers_payload)}\n\n"
+        f"{batch_status}"
+    )
+    
+    results_df = pd.DataFrame(results_log)
+    return final_status, results_df
 
 
 # --- Build Gradio Interface using Blocks ---

requirements.txt

@@ -1,4 +1,6 @@
 gradio
 requests
 smolagents[toolkit]
-smolagents
+smolagents
+smolagents[litellm]
+smolagents[openai]

tools.py

@@ -0,0 +1,33 @@
+import re
+import requests
+from markdownify import markdownify
+from requests.exceptions import RequestException
+from smolagents import tool
+
+@tool
+def visit_webpage(url: str) -> str:
+    """Visits a webpage at the given URL and returns its content as a markdown string.
+
+    Args:
+        url: The URL of the webpage to visit.
+
+    Returns:
+        The content of the webpage converted to Markdown, or an error message if the request fails.
+    """
+    try:
+        # Send a GET request to the URL
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for bad status codes
+
+        # Convert the HTML content to Markdown
+        markdown_content = markdownify(response.text).strip()
+
+        # Remove multiple line breaks
+        markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)
+
+        return markdown_content
+
+    except RequestException as e:
+        return f"Error fetching the webpage: {str(e)}"
+    except Exception as e:
+        return f"An unexpected error occurred: {str(e)}"