First commit

app.py

@@ -0,0 +1,158 @@
+import os
+import gradio as gr
+import requests
+import pandas as pd
+from dotenv import load_dotenv
+from functions import *
+from langchain_core.messages import HumanMessage
+
+load_dotenv()
+
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    space_id = os.getenv("SPACE_ID")
+
+    if not profile:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+    username = profile.username
+    print(f"User logged in: {username}")
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    try:
+        graph = build_graph()
+        agent = graph.invoke
+    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" if space_id else "Repo URL not available"
+    print(f"Agent code repo: {agent_code}")
+
+    # Fetch questions
+    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 Exception as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+
+    results_log = []
+    answers_payload = []
+
+    print(f"Running agent on {len(questions_data)} questions...")
+    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:
+            input_messages = [HumanMessage(content=question_text)]
+
+            result = agent({"messages": input_messages})
+
+            if "messages" in result and result["messages"]:
+                last_valid = next(
+                    (m for m in reversed(result["messages"]) if hasattr(m, "content") and isinstance(m.content, str)), 
+                    None
+                )
+                if last_valid:
+                    answer = last_valid.content.strip()
+                else:
+                    answer = "UNKNOWN"
+            else:
+                answer = "UNKNOWN"
+                
+            print("Answered with:", answer)
+            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": 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}
+    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
+
+    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 Exception as e:
+        status_message = f"Submission Failed: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        Modify the code here to define your agent's logic, the tools, the necessary packages, etc...
+        """
+    )
+
+    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)

custom_tools.py

@@ -0,0 +1,96 @@
+import requests
+from duckduckgo_search import DDGS
+from langchain_core.tools import tool
+
+@tool
+def reverse_text(input: str) -> str:
+    """Reverse the characters in a text or string.
+
+    Args:
+        query: The text or string to reverse.
+    """
+    return input[::-1]
+
+@tool
+def web_search(query: str) -> str:
+    """Perform a web search using DuckDuckGo and return the top 3 summarized results.
+
+    Args:
+        query: The search query to look up.
+    """
+    try:
+        results = []
+        with DDGS() as ddgs:
+            for r in ddgs.text(query, max_results=3):
+                title = r.get("title", "")
+                snippet = r.get("body", "")
+                url = r.get("href", "")
+                if title and snippet:
+                    results.append(f"{title}: {snippet} (URL: {url})")
+        if not results:
+            return "No results found."
+        return "\n\n---\n\n".join(results)
+    except Exception as e:
+        return f"Web search error: {e}"
+
+@tool
+def calculate(expression: str) -> str:
+    """Evaluate a simple math expression and return the result.
+
+    Args:
+        expression: A string containing the math expression to evaluate.
+    """
+    try:
+        allowed_names = {
+            "abs": abs,
+            "round": round,
+            "min": min,
+            "max": max,
+            "pow": pow,
+        }
+        result = eval(expression, {"__builtins__": None}, allowed_names)
+        return str(result)
+    except Exception as e:
+        return f"Calculation error: {e}"
+
+@tool
+def wikipedia_summary(query: str) -> str:
+    """Retrieve a summary of a topic from Wikipedia.
+
+    Args:
+        query: The subject or topic to summarize.
+    """
+    try:
+        response = requests.get(
+            f"https://en.wikipedia.org/api/rest_v1/page/summary/{query}", timeout=10
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data.get("extract", "No summary found.")
+    except Exception as e:
+        return f"Wikipedia error: {e}"
+
+@tool
+def define_term(term: str) -> str:
+    """Provide a dictionary-style definition of a given term using an online API.
+
+    Args:
+        term: The word or term to define.
+    """
+    try:
+        response = requests.get(
+            f"https://api.dictionaryapi.dev/api/v2/entries/en/{term}", timeout=10
+        )
+        response.raise_for_status()
+        data = response.json()
+        meanings = data[0].get("meanings", [])
+        if meanings:
+            defs = meanings[0].get("definitions", [])
+            if defs:
+                return defs[0].get("definition", "Definition not found.")
+        return "Definition not found."
+    except Exception as e:
+        return f"Definition error: {e}"
+
+# List of tools to register with your agent
+TOOLS = [web_search, calculate, wikipedia_summary, define_term, reverse_text]

functions.py

@@ -0,0 +1,140 @@
+import os
+import re
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode
+from langchain_core.messages import HumanMessage, SystemMessage
+from huggingface_hub import InferenceClient
+from custom_tools import TOOLS
+from langchain_core.messages import AIMessage
+
+HF_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
+client = InferenceClient(token=HF_TOKEN)
+
+planner_prompt = SystemMessage(content="""
+    You are a planning assistant. Your job is to decide how to answer a question.
+
+    - If the answer is easy and factual, answer it directly.
+    - If you are not 100% certain or the answer requires looking up real-world information, say:
+        I need to search this.
+
+    - If the question contains math or expressions like +, -, /, ^, say:
+        I need to calculate this.
+
+    - If a word should be explained, say:
+        I need to define this.
+    
+    -If the question asks about a person, historical event, or specific topic, say: 
+        I need to look up wikipedia.
+    
+    -If the questions asks for backwards pronounciation or reversing text, say:
+        I need to reverse text.
+
+    Only respond with one line explaining what you will do.
+    Do not try to answer yet.
+                               
+    e.g: 
+        Q: How many studio albums did Mercedes Sosa release between 2000 and 2009?
+        A: I need to search this.
+
+        Q: What does the word 'ephemeral' mean?
+        A: I need to define this.
+
+        Q: What is 23 * 6 + 3?
+        A: I need to calculate this.
+
+        Q: Reverse this: 'tfel drow eht'
+        A: I need to reverse text.
+
+        Q: What bird species are seen in this video?
+        A: UNKNOWN
+    """)
+
+def planner_node(state: MessagesState):
+    hf_messages = [planner_prompt] + state["messages"]
+
+    # Properly map LangChain message objects to dicts
+    messages_dict = []
+    for msg in hf_messages:
+        if isinstance(msg, SystemMessage):
+            role = "system"
+        elif isinstance(msg, HumanMessage):
+            role = "user"
+        else:
+            raise ValueError(f"Unsupported message type: {type(msg)}")
+        messages_dict.append({"role": role, "content": msg.content})
+
+    response = client.chat.completions.create(
+        model="mistralai/Mistral-7B-Instruct-v0.2",
+        messages=messages_dict,
+    )
+
+    text = response.choices[0].message.content.strip()
+    print("Planner output:\n", text)
+
+    return {"messages": [SystemMessage(content=text)]}
+
+answer_prompt = SystemMessage(content="""
+    You are now given the result of a tool (like a search, calculator, or text reversal).
+    Use the tool result and the original question to give the final answer.
+    If the tool result is unhelpful or unclear, respond with 'UNKNOWN'.
+    Respond with only the answer — no explanations.
+    """)
+
+def assistant_node(state: MessagesState):
+    hf_messages = [answer_prompt] + state["messages"]
+
+    messages_dict = []
+    for msg in hf_messages:
+        if isinstance(msg, SystemMessage):
+            role = "system"
+        elif isinstance(msg, HumanMessage):
+            role = "user"
+        else:
+            raise ValueError(f"Unsupported message type: {type(msg)}")
+        messages_dict.append({"role": role, "content": msg.content})
+
+    response = client.chat.completions.create(
+        model="mistralai/Mistral-7B-Instruct-v0.2",
+        messages=messages_dict,
+    )
+
+    text = response.choices[0].message.content.strip()
+    print("Final answer output:\n", text)
+
+    return {"messages": [AIMessage(content=text)]}
+
+def tools_condition(state: MessagesState) -> str:
+    last_msg = state["messages"][-1].content.lower()
+
+    if any(trigger in last_msg for trigger in [
+        "i need to search",
+        "i need to calculate",
+        "i need to define",
+        "i need to reverse text",
+        "i need to look up wikipedia"
+    ]):
+        return "tools"
+
+    return "end"
+
+class PatchedToolNode(ToolNode):
+    def invoke(self, state: MessagesState, config) -> dict:
+        result = super().invoke(state)
+        tool_output = result.get("messages", [])[0].content if result.get("messages") else "UNKNOWN"
+
+        # Append tool result as a HumanMessage so assistant sees it
+        new_messages = state["messages"] + [HumanMessage(content=f"Tool result:\n{tool_output}")]
+        return {"messages": new_messages}
+    
+def build_graph():
+    builder = StateGraph(MessagesState)
+
+    builder.add_node("planner", planner_node)
+    builder.add_node("assistant", assistant_node)
+    builder.add_node("tools", PatchedToolNode(TOOLS))
+
+    builder.add_edge(START, "planner")
+    builder.add_conditional_edges("planner", tools_condition)
+    builder.add_edge("tools", "assistant")
+
+    return builder.compile()

index.html

@@ -1,19 +0,0 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}