app.py

import json
import faiss
import numpy as np
import requests
from sentence_transformers import SentenceTransformer
import gradio as gr
import pandas as pd
import requests
import os

from smolagents import CodeAgent, tool, InferenceClientModel, DuckDuckGoSearchTool

# --- Constants ---
DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
GLOBAL_AGENT = None
search_tool = DuckDuckGoSearchTool()


# -----------------------
# TOOL IMPLEMENTATIONS
# -----------------------


@tool
def rag_search(query: str) -> str:
    """
    Retrieve relevant information from the local FAISS knowledge base.

    Args:
        query: The question or search query to retrieve relevant documents for.

    Returns:
        A string containing the most relevant question-answer pairs from the knowledge base.
    """

    agent = GLOBAL_AGENT

    if agent.index is None:
        return "Knowledge base empty."

    query_embedding = agent.embed_model.encode([query])

    distances, indices = agent.index.search(np.array(query_embedding), 3)

    results = []

    for idx in indices[0]:
        item = agent.metadata[idx]

        question = item.get("Question", "")
        answer = item.get("Final answer", "")

        results.append(
            f"Question: {question}\nAnswer: {answer}"
        )

    return "\n\n".join(results)

@tool
def calculator(expression: str) -> str:
    """
    Evaluate a mathematical expression.

    Args:
        expression: A mathematical expression such as "5*23+12".

    Returns:
        The computed result as a string.
    """

    try:
        return str(eval(expression))
    except Exception as e:
        return f"CALCULATION_ERROR:{e}"


@tool
def web_search(query: str) -> str:
    """
    Search the web for up-to-date information.

    Args:
        query: The search query.

    Returns:
        A short text snippet of the web search results.
    """

    try:
        results = search_tool.run(query)
        return str(results)[:1000]

    except Exception as e:
        return f"WEB_SEARCH_FAILED:{e}"


@tool
def image_reader(image_path: str) -> str:
    """
    Analyze an image.

    Args:
        image_path: Path to the image file.

    Returns:
        A placeholder message since image analysis is not implemented.
    """

    return "IMAGE_ANALYSIS_NOT_IMPLEMENTED"


class BasicAgent:

    def __init__(self, metadata_path="metadata.jsonl"):
        self.metadata = self._load_metadata(metadata_path)
        print("BasicAgent initialized with metadata")
        global GLOBAL_AGENT
        GLOBAL_AGENT = self
        self.embed_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

        documents = [item.get("Question", "") for item in self.metadata]

        if documents:
            embeddings = self.embed_model.encode(documents)
            dimension = len(embeddings[0])
            self.index = faiss.IndexFlatL2(dimension)
            self.index.add(np.array(embeddings))
        else:
            self.index = None

        self.agent = CodeAgent(
            tools=[rag_search, calculator, web_search, image_reader],
            model=InferenceClientModel(),
            max_steps=6,
        )

    def _load_metadata(self, file_path):
        """Load metadata from a JSONL file, parsing each line as a JSON object."""
        data = []
        try:
            with open(file_path, "r", encoding="utf-8") as f:
                for line_number, line in enumerate(f, 1):
                    line = line.strip()
                    if not line:
                        continue
                    try:
                        obj = json.loads(line)
                        if isinstance(obj, dict):
                            data.append(obj)
                        else:
                            print(f"Skipping line {line_number}: not a dictionary")
                    except json.JSONDecodeError as e:
                        print(f"Error parsing line {line_number}: {e}")
            print(f"Loaded metadata from '{file_path}' with {len(data)} entries")
            return data
        except FileNotFoundError:
            print(
                f"Metadata file '{file_path}' not found. Proceeding without metadata."
            )
            return []
        except Exception as e:
            print(f"Unexpected error loading metadata from '{file_path}': {e}")
            return []

    def think(self, question, context):

        if "FOUND:" in context:
            return "I found the answer, I should return it"

        if "search" not in context:
            return "I should search metadata for this question"

        return "The search did not help, answer unknown"

    def decide_action(self, thought):

        if "search" in thought.lower():
            return "search_metadata"

        if "return" in thought.lower():
            return "answer"

        return "answer"

    def run_action(self, action):

        if action == "search_metadata":

            for item in self.metadata:
                if item.get("Question") == self.current_question:
                    return f"FOUND:{item.get('Final answer')}"

            return "NOT_FOUND"

        if action == "answer":

            for item in self.metadata:
                if item.get("Question") == self.current_question:
                    return f"FINAL_ANSWER:{item.get('Final answer')}"

            return "FINAL_ANSWER:unknown"

        return "No action executed"

    def __call__(self, question: str) -> str:

        print(f"Agent received question: {question}")

        try:
            response = self.agent.run(
                f"""
                You are a reasoning agent solving benchmark questions.

                Use tools when needed:
                - rag_search for local knowledge
                - web_search for internet lookup
                - calculator for math

                Question: {question}

                Return only the final answer.
                """
            )

            return str(response)

        except Exception as e:
            return f"AGENT_ERROR:{e}"


def run_and_submit_all(profile: gr.OAuthProfile | None):
    """
    Fetches all questions, runs the BasicAgent on them, submits all answers,
    and displays the results.
    """
    space_id = os.getenv("SPACE_ID")

    if profile:
        username = f"{profile.username}"
        print(f"User logged in: {username}")
    else:
        print("User not logged in.")
        return "Please Login to Hugging Face with the button.", None

    api_url = DEFAULT_API_URL
    questions_url = f"{api_url}/questions"
    submit_url = f"{api_url}/submit"

    try:
        agent = BasicAgent()
    except Exception as e:
        print(f"Error instantiating agent: {e}")
        return f"Error initializing agent: {e}", None

    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
    print(agent_code)

    try:
        response = requests.get(questions_url, timeout=15)
        response.raise_for_status()
        questions_data = response.json()
        if not questions_data:
            print("Fetched questions list is empty.")
            return "Fetched questions list is empty or invalid format.", None
        print(f"Fetched {len(questions_data)} questions.")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching questions: {e}")
        return f"Error fetching questions: {e}", None
    except requests.exceptions.JSONDecodeError as e:
        print(f"Error decoding JSON response from questions endpoint: {e}")
        print(f"Response text: {response.text[:500]}")
        return f"Error decoding server response for questions: {e}", None

    results_log = []
    answers_payload = []

    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}",
                }
            )

    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)

    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)

    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.')}"
        )
        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
    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


# --- Build Gradio Interface using Blocks ---
with gr.Blocks() as demo:
    gr.Markdown("# Basic Agent Evaluation Runner")
    gr.Markdown(
        """
        **Instructions:**
        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
        ---
        **Disclaimers:**
        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
        """
    )

    gr.LoginButton()

    run_button = gr.Button("Run Evaluation & Submit All Answers")

    status_output = gr.Textbox(
        label="Run Status / Submission Result", lines=5, interactive=False
    )
    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)

    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])

if __name__ == "__main__":
    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
    space_host_startup = os.getenv("SPACE_HOST")
    space_id_startup = os.getenv("SPACE_ID")

    if space_host_startup:
        print(f"✅ SPACE_HOST found: {space_host_startup}")
        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
    else:
        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")

    if space_id_startup:
        print(f"✅ SPACE_ID found: {space_id_startup}")
        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
        print(
            f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main"
        )
    else:
        print(
            "ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined."
        )

    print("-" * (60 + len(" App Starting ")) + "\n")

    print("Launching Gradio Interface for Basic Agent Evaluation...")
    demo.launch(debug=True, share=False)