added more functionality

app.py

@@ -3,12 +3,12 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-from smolagents import CodeAgent, OpenAIServerModel, DuckDuckGoSearchTool, WikipediaSearchTool, HfApiModel, GoogleSearchTool
+from smolagents import CodeAgent, OpenAIServerModel, DuckDuckGoSearchTool, WikipediaSearchTool, HfApiModel, GoogleSearchTool, LiteLLMModel
 from dotenv import find_dotenv, load_dotenv
-from  tools import WikipediaSearch, ExcelReader, download_files, get_images, FileReader, AudioTransciber, YouTubeTranscipt, YouTubeVideoUnderstanding
+from  tools import WikipediaSearch, ExcelReader, ChessSolver, download_files, get_images, FileReader, AudioTransciber, YouTubeTranscipt, YouTubeVideoUnderstanding, VegetableFruitClassification
 from pathlib import Path
 from PIL import Image
-
+import time
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -16,18 +16,24 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
-    def __init__(self):
+    def __init__(self, model):
         load_dotenv(find_dotenv())
         os.environ["SERPER_API_KEY"] = os.getenv('SERPER_API_KEY')
-        model = OpenAIServerModel(model_id="gpt-4o",
-                                 api_key=os.getenv("OPEN_AI_KEY"))
+        # model = OpenAIServerModel(model_id="gpt-4o",
+        #                          api_key=os.getenv("OPEN_AI_KEY"))
+        # model = LiteLLMModel(model_id="gemini/gemini-2.0-flash",
+        #                          api_key=os.getenv("GEMINI_API_KEY"))
         #model=HfApiModel(api_key=os.getenv('HUGGING_FACE_API_KEY'))
         # Instantiate the agent
         self.agent = CodeAgent(
                     tools=[
                            GoogleSearchTool(provider="serper"), 
+                           ChessSolver(),
                            #DuckDuckGoSearchTool(),
-                           WikipediaSearch(), ExcelReader(),  FileReader(), AudioTransciber(), YouTubeTranscipt(),
+                           VegetableFruitClassification(), 
+                           WikipediaSearch(), 
+                           ExcelReader(),  FileReader(),
+                          AudioTransciber(), YouTubeTranscipt(),
                            YouTubeVideoUnderstanding()],
                     model=model,
                     add_base_tools=True,
@@ -43,7 +49,8 @@ class BasicAgent:
         digits in plain text unless specified otherwise. Never include currency symbols in the response.
         If you are asked for a comma separated list, apply the above rules depending of whether the element
         to be put in the list is a number or a string. For question that contain phrases like `what is the number` or 
-        `what is the highest number` return just the number, e.g., 2.
+        `what is the highest number` return just the number, e.g., 2. For questions around currency, 
+        include just the number, not the currency sign. 
         """
         self.agent.prompt_templates["system_prompt"] = self.agent.prompt_templates["system_prompt"] + SYSTEM_PROMPT
     def __call__(self, question: str) -> str:
@@ -91,7 +98,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return f"An unexpected error occurred fetching questions: {e}", None
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        model = LiteLLMModel(model_id= "gemini/gemini-2.0-flash",
+                                  api_key=os.getenv("GEMINI_API_KEY"))
+        # model = OpenAIServerModel(model_id="gpt-4o",
+        #                          api_key=os.getenv("OPEN_AI_KEY"))
+        agent = BasicAgent(model=model)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -105,35 +116,37 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    #questions_data = [i for i in questions_data if i['task_id'] == 'f918266a-b3e0-4914-865d-4faa564f1aef']
+    #questions_data = [i for i in questions_data if i['task_id'] == '5a0c1adf-205e-4841-a666-7c3ef95def9d']
     images = []
     #added limit for testing
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question") + 'You can use wikipedia.'
-        file_name = item.get('file_name')
-        if file_name:
-            file_path = download_files(task_id, file_name)
-            file_format = file_name.split('.')[-1]
-            question_text = question_text + f"This question has an associated file at path: {file_path}. The file is in the {file_format} format"
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
-        try:
-            print(images)
-            submitted_answer = agent(question_text)
-            print(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})
-        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}"})
+    for req_num, item in enumerate(questions_data):
+        if req_num % 2 == 0:
+            time.sleep(30)
+        else:
+            task_id = item.get("task_id")
+            question_text = item.get("question") + ' You can use wikipedia. Do not change original names or omit name parts.'
+            file_name = item.get('file_name')
+            if file_name:
+                file_path = download_files(task_id, file_name)
+                file_format = file_name.split('.')[-1]
+                question_text = question_text + f"This question has an associated file at path: {file_path}. The file is in the {file_format} format"
+            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)
+                print(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})
+            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}"})
 
         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)
 
-    # 4. Prepare Submission 
+    #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)
@@ -235,7 +248,7 @@ if __name__ == "__main__":
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=True)
 
 if __name__ == "__main__":
     run_and_submit_all()

chess.py

@@ -0,0 +1,44 @@
+import requests
+import json
+import base64
+
+def get_base64(file_path: str) -> str:
+        with open(file_path, "rb") as f:
+            base64_data = base64.b64encode(f.read()).decode('utf-8')
+            return base64_data
+
+def fen_notation(image_path:str, current_player:str)->str:
+    chessvisionai_url = "http://app.chessvision.ai/predict"
+    base64_image = get_base64(image_path)
+    base64_image_encoded = f"data:image/png;base64,{base64_image}"
+    current_player = 'black'
+    if current_player not in ["black", "white"]:
+        raise ValueError("current_player must be 'black' or 'white'")
+    payload = {
+        "board_orientation": "predict",
+        "cropped": False,
+        "current_player": current_player,
+        "image": base64_image_encoded,
+        "predict_turn": False
+    }
+    response = requests.post(chessvisionai_url
+                                , json=payload)
+    if response.status_code == 200:
+        fen_notation = response.json()['result'].replace('_', ' ')
+        return fen_notation
+    else:
+        raise Exception('Error retrieving fen' + response.status_code + response.text)
+        
+def chess_analysis(fen_notation:str)->str:
+    chess_api = "https://chess-api.com/v1"
+    url = chess_api
+    payload = {
+        "fen": fen_notation
+            }
+    chess_response = requests.post(url, json=payload)
+    if chess_response.status_code == 200:
+        best_move = chess_response.json().get('san')
+        return best_move
+    else:
+        raise Exception(f'Error occurred {chess_response.status_code} {chess_response.text}')
+

tools.py

@@ -15,7 +15,7 @@ from openai import OpenAI
 from llama_index.readers.youtube_transcript import YoutubeTranscriptReader
 from google import genai
 from google.genai import types
-
+import chess
 class WikipediaSearch(Tool):
     name = "wikipedia_search"
     description = "Fetches wikipedia pages."
@@ -143,7 +143,7 @@ class YouTubeVideoUnderstanding(Tool):
         load_dotenv(find_dotenv())
         client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
         response = client.models.generate_content(
-         model='models/gemini-2.5-flash-preview-04-17',
+         model='models/gemini-2.0-flash',
             contents=types.Content(
                 parts=[
                     types.Part(
@@ -153,4 +153,54 @@ class YouTubeVideoUnderstanding(Tool):
                 ]
             )
         )
-        return response.text
+        return response.text
+    
+class VegetableFruitClassification(Tool):
+    name = 'vegetable_fruit_classificaiton'
+    description = "a tool that can help classify fruits and vegetables"
+    inputs = {
+        "prompt": {
+            "type": "string",
+            "description": "user prompt about fruits or vegetables"
+
+        }
+        }
+    output_type = "string"
+  
+    def forward(self, prompt:str)->str:
+        load_dotenv(find_dotenv())
+        client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+        additional_context = """
+        The botanical distinction between fruits and vegetables is anatomical of the plant in question. 
+        For example, a tomato has seeds, which would result in reproduction.  Rhubarb is the stalk of a plant, and has no means of proliferation after consumption. 
+        A tomato is a botanical fruit and rhubarb is botanically a vegetable. """
+        extended_prompt = prompt + additional_context
+        response = client.models.generate_content(
+        model='models/gemini-2.5-flash-preview-05-20',
+            contents=types.Content(
+                parts=[
+                    types.Part(text=extended_prompt)
+                ]
+            )
+        )
+        return response.text
+    
+class ChessSolver(Tool):
+    name = "chess_analysis_tool"
+    description = "analyzes the chess board to determine the best next move."
+    inputs = {
+        "image_path": {
+            "type": "string",
+            "description": "path to the image showing a chess board."
+        },
+        "current_player":{
+            "type": "string",
+            "description": "player whose turn it is. Acceptable inputs are 'black' or 'white'"
+        },
+        }
+    output_type = "string"
+        
+    def forward(self, image_path:str, current_player:str)->str:
+        fen = chess.fen_notation(image_path, current_player)
+        best_move = chess.chess_analysis(fen)
+        return best_move