app.py

import os
import gradio as gr
import requests
import inspect
import pandas as pd
from smolagents import tool, Tool, CodeAgent, DuckDuckGoSearchTool, HfApiModel, VisitWebpageTool, SpeechToTextTool, FinalAnswerTool
from dotenv import load_dotenv
import heapq
from collections import Counter
import re
from io import BytesIO
from youtube_transcript_api import YouTubeTranscriptApi
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.document_loaders import WikipediaLoader
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.document_loaders import ArxivLoader

from typing import List, Union, Dict, Any, TypedDict # Ensure all types are imported

import torch
from langchain_core.messages import AIMessage, HumanMessage # Corrected import for message types
from langchain_core.tools import BaseTool
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.documents import Document
# No longer needed: from langchain.chains.Youtubeing import load_qa_chain (as it's unused)
from langchain_community.llms import HuggingFacePipeline
from langchain.prompts import ChatPromptTemplate # SystemMessage moved to langchain_core.messages
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langgraph.graph import END, StateGraph

# --- Import for actual YouTube transcription (if you make the tool functional) ---
# from youtube_transcript_api import YouTubeTranscriptApi


# (Keep Constants as is)
# --- Constants ---
DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"

#Load environment variables
load_dotenv()


import os
import time
import json
from typing import TypedDict, List, Union, Any, Dict, Optional

# LangChain and LangGraph imports
from langgraph.graph import StateGraph, END
from langchain_community.llms import HuggingFacePipeline 

# Corrected Tool import: Use 'tool' (lowercase)
from langchain_core.tools import BaseTool, tool 

# Hugging Face local model imports
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch 

# Tool-specific imports
from duckduckgo_search import DDGS
import wikipedia
import arxiv
from transformers import pipeline as hf_pipeline # Renamed to avoid clash with main pipeline
from youtube_transcript_api import YouTubeTranscriptApi

from typing import List, Literal, TypedDict



# --- Helper function for python_execution tool ---
def indent_code(code: str, indent: str = "    ") -> str:
    """Indents multi-line code for execution within a function."""
    return "\n".join(indent + line for line in code.splitlines())

# --- Tool Definitions ---
import wikipedia # <--- Make sure you have this installed: pip install wikipedia

# --- Dummy Tools (replace with actual, robust implementations for full functionality) ---
class DuckDuckGoSearchTool(BaseTool):
    name: str = "duckduckgo_search"
    description: str = "Performs a DuckDuckGo web search for current events, general facts, or quick lookups."
    def _run(self, query: str) -> str:
        print(f"DEBUG: Executing duckduckgo_search with query: {query}")
        if "current year" in query.lower():
            # Current time is Saturday, June 7, 2025 at 12:21:08 PM NZST.
            return "The current year is 2025."
        if "capital of france" in query.lower():
            return "The capital of France is Paris."
        if "python creator" in query.lower():
            return "Python was created by Guido van Rossum."
        return f"Search result for '{query}': Information about {query}."
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")

class WikipediaSearchTool(BaseTool):
    name: str = "wikipedia_search"
    description: str = "Performs a Wikipedia search for encyclopedic information, historical context, or detailed topics. Returns the first 3 sentences of the summary."
    def _run(self, query: str) -> str:
        print(f"DEBUG: wikipedia_search called with: {query}")
        try:
            return wikipedia.summary(query, sentences=3)
        except wikipedia.DisambiguationError as e:
            return f"Disambiguation options: {', '.join(e.options[:3])}. Please refine your query."
        except wikipedia.PageError:
            return "Wikipedia page not found for your query."
        except Exception as e:
            return f"Error performing Wikipedia search: {str(e)}"
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")

class ArxivSearchTool(BaseTool):
    name: str = "arxiv_search"
    description: str = "Searches ArXiv for scientific papers, research, or cutting-edge technical information."
    def _run(self, query: str) -> str:
        print(f"DEBUG: Executing arxiv_search with query: {query}")
        return f"ArXiv result for '{query}': Scientific papers related to {query}."
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")

class DocumentQATool(BaseTool):
    name: str = "document_qa"
    description: str = "Answers questions based on provided document text. Input format: 'document_text||question'."
    def _run(self, input_str: str) -> str:
        print(f"DEBUG: Executing document_qa with input: {input_str}")
        if "||" not in input_str:
            return "[Error] Invalid input for document_qa. Expected 'document_text||question'."
        doc_text, question = input_str.split("||", 1)
        if "Paris" in doc_text and "capital" in question:
            return "The capital of France is Paris."
        return f"Answer to '{question}' from document: '{doc_text[:50]}...' is not directly found."
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")

class PythonExecutionTool(BaseTool):
    name: str = "python_execution"
    # Option 1: Single line string (preferred for brevity)
    description: str = "Executes Python code for complex calculations, data manipulation, or logical operations. Always assign the final result to a variable named '_result_value'."
    
    # Option 2: Multi-line string using triple quotes (also valid)
    # description: str = """Executes Python code for complex calculations,
    # data manipulation, or logical operations. Always assign the final result
    # to a variable named '_result_value'."""

    def _run(self, code: str) -> str:
        print(f"DEBUG: Executing python_execution with code: {code}")
        try:
            local_vars = {}
            # It's generally unsafe to use `exec` with arbitrary user input due to security risks.
            # For a real application, consider a sandboxed environment or a more restricted approach.
            exec(code, globals(), local_vars)
            if '_result_value' in local_vars:
                return str(local_vars['_result_value'])
            return "Python code executed successfully, but no _result_value was assigned."
        except Exception as e:
            return f"[Python Error] {str(e)}"
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")
        
class VideoTranscriptionTool(BaseTool):
    name: str = "transcript_video"
    description: str = "Transcribes video content from a given YouTube URL or video ID."
    def _run(self, query: str) -> str:
        print(f"DEBUG: Executing transcript_video with query: {query}")
        if "youtube.com" in query or "youtu.be" in query:
            return f"Transcription of YouTube video '{query}': This is a sample transcription of the video content."
        return "[Error] Invalid input for transcript_video. Please provide a valid YouTube URL or video ID."
    async def _arun(self, query: str) -> str:
        raise NotImplementedError("Asynchronous execution not supported for now.")


# --- Agent State Definition ---
# --- Agent State ---
class AgentState(TypedDict):
    question: str
    history: List[Union[HumanMessage, AIMessage]]
    context: Dict[str, Any]
    reasoning: str
    iterations: int
    final_answer: Union[str, float, int, None]
    current_task: str
    current_thoughts: str
    tools: List[BaseTool] # Make sure tools are passed via state, using BaseTool type

# --- Utility Functions ---
def parse_agent_response(response_content: str) -> tuple[str, str, str]:
    """
    Parses the LLM's JSON output for reasoning, action, and action input.
    Returns (reasoning, action, action_input).
    If JSON parsing fails, it attempts heuristic parsing.
    """
    try:
        # Attempt to find the first valid JSON block
        # This is robust to surrounding text that some LLMs might generate
        json_start = response_content.find('{')
        json_end = response_content.rfind('}')
        if json_start != -1 and json_end != -1 and json_end > json_start:
            json_str = response_content[json_start : json_end + 1]
            response_json = json.loads(json_str)
            reasoning = response_json.get("Reasoning", "").strip()
            action = response_json.get("Action", "").strip()
            action_input = response_json.get("Action Input", "").strip()
            return reasoning, action, action_input
        else:
            raise json.JSONDecodeError("No valid JSON object found within the response.", response_content, 0)
    except json.JSONDecodeError:
        print(f"WARNING: JSONDecodeError: LLM response was not valid JSON. Attempting heuristic parse: {response_content[:200]}...")
        # Heuristic parsing for non-JSON or partial JSON responses
        reasoning = ""
        action = ""
        action_input = ""

        # Attempt to find Reasoning
        reasoning_idx = response_content.find("Reasoning:")
        action_idx = response_content.find("Action:")
        if reasoning_idx != -1 and action_idx != -1 and reasoning_idx < action_idx:
            reasoning = response_content[reasoning_idx + len("Reasoning:"):action_idx].strip()
            if reasoning.startswith('"') and reasoning.endswith('"'):
                reasoning = reasoning[1:-1]
        elif reasoning_idx != -1:
            reasoning = response_content[reasoning_idx + len("Reasoning:"):].strip()
            if reasoning.startswith('"') and reasoning.endswith('"'):
                reasoning = reasoning[1:-1]

        # Attempt to find Action and Action Input
        if action_idx != -1:
            action_input_idx = response_content.find("Action Input:", action_idx)
            if action_input_idx != -1:
                action_part = response_content[action_idx + len("Action:"):action_input_idx].strip()
                action = action_part
                action_input = response_content[action_input_idx + len("Action Input:"):].strip()
            else:
                action = response_content[action_idx + len("Action:"):].strip()

            if action.startswith('"') and action.endswith('"'):
                action = action[1:-1]
            if action_input.startswith('"') and action_input.endswith('"'):
                action_input = action_input[1:-1]

        # Final cleanup for any trailing JSON artifacts if heuristic grabs too much
        action = action.split('"', 1)[0].strip()
        action_input = action_input.split('"', 1)[0].strip()

        return reasoning, action, action_input

# --- Graph Nodes ---
def should_continue(state: AgentState) -> str:
    """
    Determines if the agent should continue reasoning, use a tool, or end.
    Includes a maximum iteration limit to prevent infinite loops.
    """
    MAX_ITERATIONS = 8 # Set a sensible limit to prevent infinite loops
    print(f"DEBUG: Entering should_continue. Iteration: {state['iterations']}. Current context: {state.get('context', {})}")

    if state.get("final_answer") is not None:
        print("DEBUG: should_continue -> END (Final Answer set in state)")
        return "end"

    if state["iterations"] >= MAX_ITERATIONS:
        print(f"DEBUG: should_continue -> END (Max iterations {MAX_ITERATIONS} reached)")
        # Optionally, set a final answer here indicating failure or current progress
        if not state.get("final_answer"):
            state["final_answer"] = "Agent terminated due to maximum iteration limit without finding a conclusive answer."
        return "end"

    if state.get("context", {}).get("pending_action"):
        print("DEBUG: should_continue -> ACTION (Pending action in context)")
        return "action"

    print("DEBUG: should_continue -> REASON (Default to reasoning)")
    return "reason"

# ====== DOCUMENT PROCESSING SETUP ======
def create_vector_store():
    """Create vector store with predefined documents using FAISS"""
    # Define the documents
    documents = [
        Document(page_content="The capital of France is Paris.", metadata={"source": "geography"}),
        Document(page_content="Python is a popular programming language created by Guido van Rossum.", metadata={"source": "tech"}),
        Document(page_content="The Eiffel Tower is located in Paris, France.", metadata={"source": "landmarks"}),
        Document(page_content="The highest mountain in New Zealand is Aoraki/Mount Cook.", metadata={"source": "geography"}),
        Document(page_content="Wellington is the capital city of New Zealand.", metadata={"source": "geography"}),
    ]

    # Initialize embedding model
    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

    # Split documents into chunks
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,  # Smaller chunks for better precision
        chunk_overlap=100
    )
    chunks = text_splitter.split_documents(documents)

    # Create FAISS vector store
    return FAISS.from_documents(
        documents=chunks,
        embedding=embeddings
    )

def reasoning_node(state: AgentState) -> AgentState:
    """
    Node for the agent to analyze the question, determine next steps,
    and select tools.
    """
    print(f"DEBUG: Entering reasoning_node. Iteration: {state['iterations']}")
    print(f"DEBUG: Current history length: {len(state.get('history', []))}")

    state.setdefault("context", {})
    state.setdefault("reasoning", "")
    state.setdefault("iterations", 0)
    state.setdefault("current_task", "Understand the question and plan the next step.")
    state.setdefault("current_thoughts", "")

    # Increment iterations here to track them for the current step
    state["iterations"] += 1
    if state["iterations"] > should_continue.__defaults__[0]: # Accessing MAX_ITERATIONS from should_continue
        print(f"DEBUG: Max iterations reached in reasoning_node. Exiting gracefully.")
        state["final_answer"] = "Agent halted due to exceeding maximum allowed reasoning iterations."
        return state

    state["context"].pop("pending_action", None)

    # --- Initialize local HuggingFacePipeline ---
    model_name = "mistralai/Mistral-7B-Instruct-v0.2"

    print(f"DEBUG: Loading local model: {model_name}...")

    tokenizer = AutoTokenizer.from_pretrained(model_name)

    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
        device_map="auto"
    )

    pipe = pipeline(
        "text-generation",
        model=model,
        tokenizer=tokenizer,
        max_new_tokens=1024,
        temperature=0.1,
        do_sample=True,
        top_p=0.9,
        repetition_penalty=1.1,
    )

    llm = HuggingFacePipeline(pipeline=pipe)
    # --- END LOCAL LLM INITIALIZATION ---

    tool_descriptions = "\n".join([
        f"- **{t.name}**: {t.description}" for t in state.get("tools", [])
    ])

    # ====== RAG RETRIEVAL ======
    if "vector_store" not in state["context"]:
        state["context"]["vector_store"] = create_vector_store()

    vector_store = state["context"]["vector_store"]

    relevant_docs = vector_store.similarity_search(
        state["question"],
        k=3
    )

    rag_context = "\n\n[Relevant Knowledge]\n"
    rag_context += "\n---\n".join([doc.page_content for doc in relevant_docs])

    # ====== MODIFIED PROMPT ======
    system_prompt = (
        "You are an expert problem solver, designed to provide concise and accurate answers. "
        "Your process involves analyzing the question, intelligently selecting and using tools, "
        "and synthesizing information.\n\n"
        "**Available Tools:**\n"
        f"{tool_descriptions}\n\n"
        "**Tool Usage Guidelines:**\n"
        "- Use **duckduckgo_search** for current events, general facts, or quick lookups. Provide a concise search query. Example: `What is the population of New York?`\n"
        "- Use **wikipedia_search** for encyclopedic information, historical context, or detailed topics. Provide a concise search term. Example: `Eiffel Tower history`\n"
        "- Use **arxiv_search** for scientific papers, research, or cutting-edge technical information. Provide a concise search query. Example: `Large Language Models recent advances`\n"
        "- Use **document_qa** when the question explicitly refers to a specific document or when you have content to query. Input format: 'document_text||question'. Example: `The capital of France is Paris.||What is the capital of France?`\n"
        "- Use **python_execution** for complex calculations, data manipulation, or logical operations that cannot be done with simple reasoning. Always provide the full Python code, ensuring it's valid and executable, and assign the final result to a variable named '_result_value'. Example: `_result_value = 1 + 1`\n"
        "- Use **transcript_video** for any question involving video or audio content (e.g., YouTube). Provide the full YouTube URL or video ID. Example: `youtube.com`\n\n"
        "**Crucial Instructions:**\n"
        "1. **Always aim to provide a definitive answer.** If you have enough information, use the 'final answer' action.\n"
        "2. **To provide a final answer, use the Action 'final answer' with the complete answer in 'Action Input'.** This is how you tell me you're done. Example:\n"
        "   ```json\n"
        "   {\n"
        "     \"Reasoning\": \"I have found the capital of France.\",\n"
        "     \"Action\": \"final answer\",\n"
        "     \"Action Input\": \"The capital of France is Paris.\"\n"
        "   }\n"
        "   ```\n"
        "3. **If you need more information or cannot answer yet, select an appropriate tool and provide a clear, concise query.**\n"
        "4. **Think step-by-step.** Reflect on previous tool outputs and the question.\n"
        "5. **Do NOT repeat actions or search queries unless the previous attempt yielded an error.**\n\n"
        "**Retrieved Context:**\n{rag_context}\n\n"
        "**Current Context (Tool Outputs/Intermediate Info):**\n{context}\n\n"
        "**Previous Reasoning Steps:**\n{reasoning}\n\n"
        "**Current Task:** {current_task}\n"
        "**Current Thoughts:** {current_thoughts}\n\n"
        "**Question:** {question}\n\n"
        "**Expected JSON Output Format:**\n"
        "```json\n"
        "{\n"
        "  \"Reasoning\": \"Your reasoning process to decide the next step, including why a tool is chosen or how an answer is derived.\",\n"
        "  \"Action\": \"The name of the tool to use (e.g., duckduckgo_search, final answer, No Action), if no tool is needed yet, use 'No Action'.\",\n"
        "  \"Action Input\": \"The input for the tool (e.g., 'What is the capital of France?', 'The final answer is Paris.').\"\n"
        "}\n"
        "```\n"
        "Ensure your response is ONLY valid JSON and strictly follows this format. Begin your response with ````json`."
    )

    prompt = ChatPromptTemplate.from_messages([
        SystemMessage(content=system_prompt), # SystemMessage is imported from langchain_core.messages
        *state["history"]
    ])

    formatted_messages = prompt.format_messages(
        rag_context=rag_context,
        context=state["context"],
        reasoning=state["reasoning"],
        question=state["question"],
        current_task=state["current_task"],
        current_thoughts=state["current_thoughts"]
    )

    try:
        full_input_string = tokenizer.apply_chat_template(
            formatted_messages,
            tokenize=False,
            add_generation_prompt=True
        )
    except Exception as e:
        print(f"WARNING: Failed to apply chat template: {e}. Falling back to simple string join. Model performance may be affected.")
        full_input_string = "\n".join([msg.content for msg in formatted_messages])

    def call_with_retry_local(inputs, retries=3):
        for attempt in range(retries):
            try:
                response_text = llm.invoke(inputs)
                # Ensure the LLM response is processed correctly, removing the input prompt
                content = response_text.replace(inputs, "").strip() # More robust stripping

                print(f"DEBUG: RAW LOCAL LLM Response (Attempt {attempt+1}):\n---\n{content}\n---")

                # Attempt to parse to validate structure
                # The parse_agent_response handles JSONDecodeError, so just call it
                reasoning, action, action_input = parse_agent_response(content)
                # If parsing succeeded, return AIMessage
                return AIMessage(content=content)
            except Exception as e: # Catch any exception, including json.JSONDecodeError from parse_agent_response
                print(f"[Retry {attempt+1}/{retries}] Local LLM returned invalid content or an error. Error: {e}. Retrying...")
                print(f"Invalid content (partial): {content[:200]}...")
                state["history"].append(AIMessage(content=f"[Parsing Error] The previous LLM output was not valid. Expected format: ```json{{\"Reasoning\": \"...\", \"Action\": \"...\", \"Action Input\": \"...\"}}```. Please ensure your response is ONLY valid JSON and strictly follows the format. Error: {e}"))
                time.sleep(5)
        raise RuntimeError("Failed after multiple retries due to local Hugging Face model issues or invalid JSON.")

    response = call_with_retry_local(full_input_string)

    content = response.content
    reasoning, action, action_input = parse_agent_response(content) # Use the improved parser

    print(f"DEBUG: Parsed Action: '{action}', Action Input: '{action_input[:100]}...'")

    # Only append the LLM's raw response if it's not a retry message
    if not content.startswith("[Parsing Error]") and not content.startswith("[Local LLM Error]"):
        state["history"].append(AIMessage(content=content))

    state["reasoning"] += f"\nStep {state['iterations']}: {reasoning}" # Use iteration number for clarity
    state["current_thoughts"] = reasoning

    # --- FIX: Set final_answer directly if the action is "final answer" ---
    if action.lower() == "final answer":
        state["final_answer"] = action_input
        print(f"DEBUG: Final answer set in state: {state['final_answer']}")
    else:
        state["context"]["pending_action"] = {
            "tool": action,
            "input": action_input
        }
        # Only append tool decision message if it's a valid action, not if LLM failed to decide
        if action and action != "No Action":
            state["history"].append(AIMessage(content=f"Agent decided to use tool: {action} with input: {action_input}"))
        elif action == "No Action":
             state["history"].append(AIMessage(content=f"Agent decided to take 'No Action' but needs to proceed.")) # Indicate no action taken for visibility
             # If "No Action" is taken, but no final answer, it indicates a potential stuck state
             # We might want to force a re-reason or provide a default answer based on current context
             if not state.get("final_answer"):
                 state["current_task"] = "Re-evaluate the situation and attempt to find a final answer or a new tool."
                 state["current_thoughts"] = "The previous step resulted in 'No Action'. I need to find a way forward."
                 # This might lead to another reasoning cycle, which is covered by MAX_ITERATIONS
                 state["context"].pop("pending_action", None) # Clear pending action if it was "No Action"

    print(f"DEBUG: Exiting reasoning_node. New history length: {len(state['history'])}")
    return state

def tool_node(state: AgentState) -> AgentState:
    """
    Node for executing the chosen tool and returning its output.
    """
    print(f"DEBUG: Entering tool_node. Iteration: {state['iterations']}")

    tool_call_dict = state["context"].pop("pending_action", None)

    if not tool_call_dict:
        error_message = "[Tool Error] No pending_action found in context. This indicates an issue with graph flow or a previous error."
        print(f"ERROR: {error_message}")
        state["history"].append(AIMessage(content=error_message))
        # If no pending action, and we just came from reasoning, it means LLM failed to set one.
        # Force it back to reasoning, but prevent infinite loops.
        # This will be caught by MAX_ITERATIONS in should_continue.
        state["current_task"] = "Re-evaluate the situation; previous tool selection failed or was missing."
        state["current_thoughts"] = "No tool action was found. I need to re-think my next step."
        return state

    tool_name = tool_call_dict.get("tool")
    tool_input = tool_call_dict.get("input")

    if not tool_name or tool_input is None:
        error_message = f"[Tool Error] Invalid action request from LLM: Tool name '{tool_name}' or input '{tool_input}' was empty or None. LLM needs to provide valid 'Action' and 'Action Input'."
        print(f"ERROR: {error_message}")
        state["history"].append(AIMessage(content=error_message))
        state["context"].pop("pending_action", None) # Clear invalid pending action
        return state

    available_tools = state.get("tools", [])
    tool_fn = next((t for t in available_tools if t.name == tool_name), None)

    tool_output = "" # Initialize tool_output

    if tool_fn is None:
        tool_output = f"[Tool Error] Tool '{tool_name}' not found or not available. Please choose from: {', '.join([t.name for t in available_tools])}"
        print(f"ERROR: {tool_output}")
    else:
        try:
            print(f"DEBUG: Invoking tool '{tool_name}' with input: '{tool_input[:100]}...'")
            raw_tool_output = tool_fn.run(tool_input)
            if raw_tool_output is None or raw_tool_output is False or raw_tool_output == "":
                tool_output = f"[{tool_name} output] No specific result found for '{tool_input}'. The tool might have returned an empty response."
            else:
                tool_output = f"[{tool_name} output]\n{raw_tool_output}"
        except Exception as e:
            tool_output = f"[Tool Error] An error occurred while running '{tool_name}': {str(e)}"
            print(f"ERROR: {tool_output}")

    # Append tool output to history for LLM to see in next reasoning step
    state["history"].append(AIMessage(content=tool_output))

    print(f"DEBUG: Exiting tool_node. Tool output added to history. New history length: {len(state['history'])}")
    return state

# ====== Agent Graph ======
def create_agent_workflow(tools: List[BaseTool]): # Use BaseTool for consistency
    workflow = StateGraph(AgentState)

    workflow.add_node("reason", reasoning_node)
    workflow.add_node("action", tool_node)

    workflow.set_entry_point("reason")

    workflow.add_conditional_edges(
        "reason",
        should_continue,
        {
            "action": "action",
            "reason": "reason",
            "end": END
        }
    )

    workflow.add_edge("action", "reason")

    app = workflow.compile()
    return app

# ====== Agent Interface ======
class BasicAgent:
    def __init__(self):
        # Instantiate tools - using the specific BaseTool subclasses now
        self.tools = [
            DuckDuckGoSearchTool(),
            WikipediaSearchTool(),
            ArxivSearchTool(),
            DocumentQATool(),
            PythonExecutionTool(),
            VideoTranscriptionTool()
        ]

        # Pre-initialize RAG vector store
        self.vector_store = create_vector_store()
        self.workflow = create_agent_workflow(self.tools)

    def __call__(self, question: str) -> str:
        print(f"\n--- Agent received question: {question[:50]}{'...' if len(question) > 50 else ''} ---")

        state = {
            "question": question,
            "context": {
                "vector_store": self.vector_store
            },
            "reasoning": "",
            "iterations": 0, # Initialize iterations to 0
            "history": [HumanMessage(content=question)],
            "final_answer": None,
            "current_task": "Understand the question and plan the next step.",
            "current_thoughts": "",
            "tools": self.tools
        }

        try:
            final_state = self.workflow.invoke(state, {"recursion_limit": 20}) # Increased recursion limit for LangGraph

            if final_state.get("final_answer") is not None:
                answer = final_state["final_answer"]
                print(f"--- Agent returning FINAL ANSWER: {answer} ---")
                return answer
            else:
                print(f"--- ERROR: Agent finished without setting 'final_answer' for question: {question} ---")
                if final_state["history"]:
                    last_message = final_state["history"][-1].content
                    print(f"Last message in history: {last_message}")
                    return f"Agent could not fully answer. Last message: {last_message}"
                else:
                    return "Agent finished without providing a final answer and no history messages."
        except Exception as e:
            print(f"--- FATAL ERROR during agent execution: {e} ---")
            return f"An unexpected error occurred during agent execution: {str(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.
    """
    # --- Determine HF Space Runtime URL and Repo URL ---
    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code

    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"

    # 1. Instantiate Agent ( modify this part to create your agent)
    try:
        agent = BasicAgent()
    except Exception as e:
        print(f"Error instantiating agent: {e}")
        return f"Error initializing agent: {e}", None
    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
    print(agent_code)

    # 2. Fetch Questions
    print(f"Fetching questions from: {questions_url}")
    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
    except Exception as e:
        print(f"An unexpected error occurred fetching questions: {e}")
        return f"An unexpected error occurred fetching questions: {e}", None

    # 3. Run your Agent
    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:
            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)

    # 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
    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
    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)
    # Removed max_rows=10 from DataFrame constructor
    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)
    # Check for SPACE_HOST and SPACE_ID at startup for information
    space_host_startup = os.getenv("SPACE_HOST")
    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup

    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 repo URLs if SPACE_ID is found
        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)