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}")
        # Current time is Friday, June 7, 2025 at 1:06:13 PM NZST.
        if "current year" in query.lower():
            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"
    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 = {}
            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 ---
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]

# --- 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
        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]}...")
        reasoning = ""
        action = ""
        action_input = ""

        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]

        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]

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

    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=100
    )
    chunks = text_splitter.split_documents(documents)

    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.
    """
    # --- Defensive checks at the start of the node ---
    if state is None:
        raise ValueError("reasoning_node received a None state object.")

    # Ensure context is a dictionary
    if not isinstance(state.get("context"), dict):
        print("WARNING: state['context'] is not a dictionary on entry to reasoning_node. Re-initializing to empty dict.")
        state["context"] = {}
    
    # Ensure history is a list
    if not isinstance(state.get("history"), list):
        print("WARNING: state['history'] is not a list on entry to reasoning_node. Re-initializing to empty list.")
        state["history"] = []

    # Ensure tools is a list
    if not isinstance(state.get("tools"), list):
        print("WARNING: state['tools'] is not a list on entry to reasoning_node. This might cause issues downstream.")
        # If tools become None or corrupted, the tool_descriptions part will fail.
        # It's better to log and proceed, assuming agent init sets them correctly.

    print(f"DEBUG: Entering reasoning_node. Iteration: {state['iterations']}")
    # Use .get() for safety when printing history length
    print(f"DEBUG: Current history length: {len(state.get('history', []))}")

    # Set defaults for state components that might be missing, although TypedDict implies presence
    state.setdefault("context", {}) # Redundant if check above re-initializes, but harmless
    state.setdefault("reasoning", "")
    state.setdefault("iterations", 0)
    state.setdefault("current_task", "Understand the question and plan the next step.")
    state.setdefault("current_thoughts", "")

    state["iterations"] += 1
    if state["iterations"] > should_continue.__defaults__[0]:
        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

    # Now that context is guaranteed a dict, this is safe
    state["context"].pop("pending_action", None) 

    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)

    # Ensure state.get("tools") returns a list before iterating and that items are not None
    tool_descriptions = "\n".join([
        f"- **{t.name}**: {t.description}" for t in state.get("tools", []) if t is not None
    ])

    if "vector_store" not in state["context"]:
        state["context"]["vector_store"] = create_vector_store()
    
    # Ensure vector_store is not None before using it
    vector_store = state["context"].get("vector_store")
    if vector_store is None:
        print("ERROR: Vector store is None after creation/retrieval in reasoning_node. Cannot perform similarity search.")
        state["final_answer"] = "Internal error: Vector store not available."
        return state

    # Ensure question is a string for similarity_search
    query_for_docs = state["question"] if isinstance(state.get("question"), str) else str(state["question"])
    relevant_docs = vector_store.similarity_search(
        query_for_docs,
        k=3
    )
    
    # Filter out any None documents before joining page_content
    rag_context = "\n\n[Relevant Knowledge]\n"
    rag_context += "\n---\n".join([doc.page_content for doc in relevant_docs if doc is not None])


    system_prompt_template = ( 
        "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_template), 
        *state["history"] # This assumes state["history"] is a list. The check at the start of the node handles if it's None.
    ])

    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"]
    )
    
    # Filter out any None messages if they somehow appeared before tokenization
    filtered_messages = [msg for msg in formatted_messages if msg is not None]

    try:
        full_input_string = tokenizer.apply_chat_template(
            filtered_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 filtered_messages if msg is not None])

    def call_with_retry_local(inputs, retries=3):
        for attempt in range(retries):
            try:
                response_text = llm.invoke(inputs)
                if response_text is None: 
                    raise ValueError("LLM invoke returned None response_text.")
                
                content = response_text.replace(inputs, "").strip() if isinstance(response_text, str) else str(response_text).replace(inputs, "").strip()

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

                reasoning, action, action_input = parse_agent_response(content)
                return AIMessage(content=content)
            except Exception as e:
                print(f"[Retry {attempt+1}/{retries}] Local LLM returned invalid content or an error. Error: {e}. Retrying...")
                safe_content_preview = content[:200] if isinstance(content, str) else "Content was not a string or is None."
                print(f"Invalid content (partial): {safe_content_preview}...")
                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 

    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}"
    state["current_thoughts"] = reasoning

    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
        }
        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."))
             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 re-think my next step."
                 state["context"].pop("pending_action", None)

    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.
    """
    # --- Defensive checks at the start of the node ---
    if state is None:
        raise ValueError("tool_node received a None state object.")
    
    # Ensure context is a dictionary
    if not isinstance(state.get("context"), dict):
        print("WARNING: state['context'] is not a dictionary on entry to tool_node. Re-initializing to empty dict.")
        state["context"] = {}

    # Ensure history is a list
    if not isinstance(state.get("history"), list):
        print("WARNING: state['history'] is not a list on entry to tool_node. Re-initializing to empty list.")
        state["history"] = []

    print(f"DEBUG: Entering tool_node. Iteration: {state['iterations']}")

    # Safely access tool_call_dict. Context is guaranteed to be a dict here.
    tool_call_dict = state["context"].pop("pending_action", None) 

    if tool_call_dict is None:
        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))
        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) 
        return state

    available_tools = state.get("tools", [])
    # Filter out any None tools before iterating
    tool_fn = next((t for t in available_tools if t is not None and t.name == tool_name), None) 

    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 if t is not None])}"
        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}")

    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]):
    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):
        self.tools = [
            DuckDuckGoSearchTool(),
            WikipediaSearchTool(),
            ArxivSearchTool(),
            DocumentQATool(),
            PythonExecutionTool(),
            VideoTranscriptionTool()
        ]

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

            # It's highly unlikely final_state would be None if invoke completes,
            # but this check is harmless and covers an extreme edge case.
            if final_state is None:
                return "Agent workflow completed but returned a None state. This is unexpected."

            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} ---")
                current_history = final_state.get("history", []) # Safely get history
                
                if current_history: 
                    last_message = current_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)