Update app.py

app.py

@@ -1,642 +1,78 @@
-
 import os
+import time
+
 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
-
+import requests
+from smolagents import (
+    CodeAgent,
+    DuckDuckGoSearchTool,
+    LiteLLMModel,
+    WikipediaSearchTool,
+    FinalAnswerTool
+)
+
+from agent import (
+    analyze_audio_file,
+    analyze_image_file,
+    analyze_xlsx_file,
+    analyze_youtube_video,
+    download_file_of_task_id,
+)
 
-# (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 langchain.schema import HumanMessage, AIMessage, SystemMessage
-from langchain.prompts import ChatPromptTemplate
-from langgraph.graph import StateGraph, END
-from langchain_community.llms import HuggingFacePipeline 
-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
-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
-
-# 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
-
-# --- 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 ---
-@tool 
-def duckduckgo_search(query: str) -> str:
-    """Search web using DuckDuckGo. Returns top 3 results."""
-    print(f"DEBUG: duckduckgo_search called with: {query}")
-    try:
-        with DDGS() as ddgs:
-            return "\n\n".join(
-                f"Title: {res['title']}\nURL: {res['href']}\nSnippet: {res['body']}"
-                for res in ddgs.text(query, max_results=3)
-            )
-    except Exception as e:
-        return f"Error performing DuckDuckGo search: {str(e)}"
-
-@tool 
-def wikipedia_search(query: str) -> str:
-    """Get Wikipedia summaries. Returns first 3 sentences."""
-    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])}"
-    except wikipedia.PageError:
-        return "Wikipedia page not found."
-    except Exception as e:
-        return f"Error performing Wikipedia search: {str(e)}"
-
-@tool 
-def arxiv_search(query: str) -> str:
-    """Search academic papers on arXiv. Returns top 3 results."""
-    print(f"DEBUG: arxiv_search called with: {query}")
-    try:
-        results = arxiv.Search(
-            query=query, 
-            max_results=3,
-            sort_by=arxiv.SortCriterion.Relevance
-        ).results()
-        
-        return "\n\n".join(
-            f"Title: {r.title}\nAuthors: {', '.join(a.name for a in r.authors)}\n"
-            f"Published: {r.published.strftime('%Y-%m-%d')}\nSummary: {r.summary[:250]}..."
-            for r in results
-        )
-    except Exception as e:
-        return f"Error performing ArXiv search: {str(e)}"
-
-@tool 
-def document_qa(input_str: str) -> str:
-    """Answer questions from documents. Input format: 'document_text||question'"""
-    print(f"DEBUG: document_qa called with: {input_str}")
-    try:
-        if '||' not in input_str:
-            return "Invalid format. Input must be: 'document_text||question'"
-        
-        context, question = input_str.split('||', 1)
-        # Load QA model on first call or ensure it's loaded once globally.
-        # It's better to load once in __init__ for BasicAgent if possible,
-        # but this lazy loading prevents initial heavy load if tool is not used.
-        qa_model = hf_pipeline('question-answering', model='deepset/roberta-base-squad2')
-        return qa_model(question=question, context=context)['answer']
-    except Exception as e:
-        return f"Error answering question from document: {str(e)}"
-
-@tool 
-def python_execution(code: str) -> str:
-    """Execute Python code and return output.
-    The code should assign its final result to a variable named '_result_value'.
-    Example: '_result_value = 1 + 1'
-    """
-    print(f"DEBUG: python_execution called with: {code}")
-    try:
-        # Create isolated environment
-        env = {}
-        # Wrap code in a function to isolate scope and capture '_result_value'
-        # The exec function is used carefully here. In a production environment,
-        # consider a more robust and secure sandbox (e.g., Docker, dedicated service).
-        exec(f"def __exec_fn__():\n{indent_code(code)}\n_result_value = __exec_fn__()", globals(), env)
-        return str(env.get('_result_value', 'No explicit result assigned to "_result_value" variable.'))
-    except Exception as e:
-        return f"Python execution error: {str(e)}"
-
-class VideoTranscriptionTool(Tool):
-    name: str = "transcript_video"
-    # CORRECTED LINE BELOW: Added '=' for assignment
-    description: str = "Fetch text transcript from YouTube videos using URL or ID. Use for any question involving video or audio. Input is the YouTube URL or ID." 
-
-    def _run(self, url_or_id: str) -> str:
-        print(f"DEBUG: transcript_video called with: {url_or_id}")
-        video_id = None
-        # Basic parsing for common YouTube URL formats
-        if "youtube.com/watch?v=" in url_or_id:
-            video_id = url_or_id.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in url_or_id:
-            video_id = url_or_id.split("youtu.be/")[1].split("?")[0]
-        elif len(url_or_id.strip()) == 11 and not ("http://" in url_or_id or "https://" in url_or_id):
-            video_id = url_or_id.strip() # Assume it's just the ID
-
-        if not video_id:
-            return f"Invalid or unsupported YouTube URL/ID: {url_or_id}. Please provide a valid YouTube URL or 11-character ID."
-
-        try:
-            transcription = YouTubeTranscriptApi.get_transcript(video_id)
-            return " ".join([part['text'] for part in transcription])
-
-        except Exception as e:
-            return f"Error fetching transcript for video ID '{video_id}': {str(e)}. It might not have an English transcript, or the video is unavailable."
-
-    def _arun(self, *args, **kwargs):
-        raise NotImplementedError("Async not supported for this tool.")
-
-
-# ====== IMPORTS ======
-import json
-import time
-from typing import Dict, List, Tuple, Any, Optional
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
-from langchain_core.prompts import ChatPromptTemplate
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-import torch
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_core.documents import Document
-
-# ====== TYPE DEFINITIONS ======
-AgentState = Dict[str, Any]
-
-# ====== DOCUMENT PROCESSING ======
-def create_vector_store() -> Optional[FAISS]:
-    """Create vector store with predefined documents using FAISS"""
-    try:
-        # 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"}),
-        ]
-        
-        # Initialize embedding model
-        embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
-        
-        # Split documents into chunks
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=500,
-            chunk_overlap=100
-        )
-        chunks = text_splitter.split_documents(documents)
-        
-        # Create FAISS vector store
-        return FAISS.from_documents(
-            documents=chunks,
-            embedding=embeddings
-        )
-    except Exception as e:
-        print(f"ERROR creating vector store: {str(e)}")
-        return None
-
-# ====== AGENT HELPER FUNCTIONS ======
-def parse_agent_response(content: str) -> Tuple[str, str, str]:
-    """Parse the agent's JSON response"""
-    try:
-        # Extract JSON from content
-        json_start = content.find('{')
-        json_end = content.rfind('}') + 1
-        json_str = content[json_start:json_end]
-        
-        # Parse JSON
-        response_dict = json.loads(json_str)
-        
-        reasoning = response_dict.get("Reasoning", "No reasoning provided")
-        action = response_dict.get("Action", "No action specified")
-        action_input = response_dict.get("Action Input", "No input provided")
-        
-        return reasoning, action, action_input
-    except json.JSONDecodeError:
-        print(f"WARNING: Failed to parse JSON from response: {content[:200]}...")
-        return "Failed to parse response", "Final Answer", "Error: Could not parse agent response"
-    except Exception as e:
-        print(f"ERROR parsing agent response: {str(e)}")
-        return "Error in parsing", "Final Answer", f"Internal error: {str(e)}"
-
-def should_continue(state: AgentState) -> str:
-    """Determine if we should continue processing or end"""
-    if state.get("final_answer"):
-        return "end"
-    if state.get("context", {}).get("pending_action"):
-        return "action"
-    return "reason"
-
-# ====== REASONING NODE ======
-def reasoning_node(state: AgentState) -> AgentState:
-    """Node for analyzing questions and determining next steps"""
-    print(f"DEBUG: Entering reasoning_node. Iteration: {state.get('iterations', 0)}")
-    
-    # Safely initialize state components
-    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", "")
-    state.setdefault("history", [])
-    
-    # Safely remove pending_action
-    state["context"].pop("pending_action", None) 
-
-    # Initialize local HuggingFacePipeline
-    model_name = "mistralai/Mistral-7B-Instruct-v0.2"
-    
-    try:
-        print(f"DEBUG: Loading local model: {model_name}...")
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        
-        # Determine torch dtype based on available hardware
-        if torch.cuda.is_available():
-            torch_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
-        else:
-            torch_dtype = torch.float32
-            
-        model = AutoModelForCausalLM.from_pretrained(
-            model_name, 
-            torch_dtype=torch_dtype,
-            device_map="auto"
-        )
-
-        # Create transformers pipeline
-        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,
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
+
+        # Initialize the model
+        model = LiteLLMModel(model_id=os.getenv("MODEL_ID"),
+                             api_key=os.getenv("API_KEY"))
+
+        # Initialize the searchs tool
+        duck_duck_go_search_tool = DuckDuckGoSearchTool()
+        wikipedia_search_tool = WikipediaSearchTool()
+
+        # Initialize Agent
+        self.agent = CodeAgent(
+            model = model,
+            tools=[download_file_of_task_id, analyze_audio_file, analyze_image_file,
+                   analyze_xlsx_file, duck_duck_go_search_tool, wikipedia_search_tool,
+                   analyze_youtube_video, FinalAnswerTool()]
         )
 
-        llm = HuggingFacePipeline(pipeline=pipe)
-    except Exception as e:
-        print(f"ERROR loading model: {str(e)}")
-        state["history"].append(AIMessage(content=f"[ERROR] Failed to load model: {str(e)}"))
-        state["final_answer"] = "Error: Failed to initialize language model"
-        return state
-
-    # Prepare tool descriptions
-    tool_descriptions = "\n".join([
-        f"- **{t.name}**: {t.description}" for t in state.get("tools", [])
-    ])
-
-    # RAG Retrieval
-    rag_context = ""
-    vector_store = state["context"].get("vector_store")
-    
-    if vector_store:
-        try:
-            # Perform retrieval
-            relevant_docs = vector_store.similarity_search(
-                state.get("question", ""), 
-                k=3
-            )
+    def __call__(self, question: str, task_id: str) -> str:
+        task = f"""
+            You are a general AI assistant. 
+            I will ask you a question and you can use 8 steps to answer it.
+            You can use the tools I provided to you to answer the question.
+            Every time you use a tool, the number of steps will decrease by one.
+            If you have a list of possible pages to visit, prefer the wikipedia ones.
+            If a page does not allow visit, skip it.
+            Report your thoughts, and finish your answer with the following template: 
+            FINAL ANSWER: [YOUR FINAL ANSWER]. 
+            YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. 
+            If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. 
+            If the answer is a number, represent it with digits.
+            If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. 
+            If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
             
-            # Format context for LLM
-            rag_context = "\n\n[Relevant Knowledge]\n"
-            rag_context += "\n---\n".join([doc.page_content for doc in relevant_docs])
-        except Exception as e:
-            print(f"WARNING: RAG retrieval failed: {str(e)}")
-            rag_context = "\n\n[Relevant Knowledge] Retrieval failed. Proceeding without additional context."
-    else:
-        print("WARNING: No vector store available for RAG")
-        rag_context = "\n\n[Relevant Knowledge] No knowledge base available."
-
-    # Renamed the variable to emphasize it's a template string, not a SystemMessage object
-    system_prompt_template_str = ( 
-        "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([
-        # --- CHANGE THIS LINE ---
-        # Pass the system message as a tuple (role, content_template_string)
-        ("system", system_prompt_template_str), 
-        *state["history"] 
-    ])
-
-    # Format messages safely
-    formatted_messages = prompt.format_messages(
-        rag_context=rag_context,
-        context=state.get("context", {}),
-        reasoning=state.get("reasoning", ""),
-        question=state.get("question", ""),
-        current_task=state.get("current_task", ""),
-        current_thoughts=state.get("current_thoughts", "")
-    )
-    
-    # Format full input string
-    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}. Using simple join.")
-        full_input_string = "\n".join([msg.content for msg in formatted_messages])
-
-    # Call LLM with retry
-    def call_with_retry_local(inputs: str, retries: int = 3) -> AIMessage:
-        for attempt in range(retries):
-            try:
-                response_text = llm.invoke(inputs) 
-                
-                # Strip the prompt from the generated text
-                if response_text.startswith(inputs):
-                    content = response_text[len(inputs):].strip()
-                else:
-                    content = response_text.strip() 
-
-                print(f"DEBUG: RAW LOCAL LLM Response (Attempt {attempt+1}):\n---\n{content}\n---")
-                
-                # Attempt to parse to validate structure
-                json.loads(content) 
-                return AIMessage(content=content)
-            except json.JSONDecodeError as e:
-                print(f"[Retry {attempt+1}/{retries}] Invalid JSON. Error: {e}.")
-                print(f"Invalid content: {content[:200]}...")
-                state["history"].append(AIMessage(content=f"[Parsing Error] The previous LLM output was not valid JSON. Expected format: ```json{{\"Reasoning\": \"...\", \"Action\": \"...\", \"Action Input\": \"...\"}}```. Please ensure your response is ONLY valid JSON and strictly follows the format. Error: {e}"))
-                time.sleep(3) 
-            except Exception as e: 
-                print(f"[Retry {attempt+1}/{retries}] Error: {e}.")
-                state["history"].append(AIMessage(content=f"[LLM Error] Failed to get response: {e}. Trying again."))
-                time.sleep(5) 
-        return AIMessage(content='{"Reasoning": "Max retries exceeded", "Action": "Final Answer", "Action Input": "Error: Failed after multiple retries"}')
-
-    response = call_with_retry_local(full_input_string) 
-    content = response.content
-
-    # Parse response
-    reasoning, action, action_input = parse_agent_response(content)
-    
-    print(f"DEBUG: Parsed Action: '{action}', Action Input: '{action_input[:100]}...'")
-
-    # Update state
-    state["history"].append(AIMessage(content=content)) 
-    state["reasoning"] += f"\nStep {state['iterations'] + 1}: {reasoning}"
-    state["iterations"] += 1
-    state["current_thoughts"] = reasoning 
-
-    if "final answer" in action.lower():
-        state["final_answer"] = action_input 
-    else:
-        state["context"]["pending_action"] = {
-            "tool": action,
-            "input": action_input
-        }
-        state["history"].append(AIMessage(content=f"Agent decided to use tool: {action} with input: {action_input}"))
-
-    print(f"DEBUG: Exiting reasoning_node. New history length: {len(state['history'])}")
-    return state
+            The taskid is {task_id} in case you need to get extra files, use taskid and not name of the file 
+            and the question is {question}
+            """
 
-# ====== TOOL NODE ======
-def tool_node(state: AgentState) -> AgentState:
-    """Node for executing the chosen tool"""
-    print(f"DEBUG: Entering tool_node. Iteration: {state.get('iterations', 0)}")
-    
-    # Safely get pending action
-    tool_call_dict = state.get("context", {}).pop("pending_action", None)
+        fixed_answer = self.agent.run(task)
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        time.sleep(50)
 
-    if not tool_call_dict:
-        error_message = "[Tool Error] No pending_action found in context."
-        print(f"ERROR: {error_message}")
-        state.setdefault("history", []).append(AIMessage(content=error_message))
-        return state
+        return fixed_answer
 
-    tool_name = tool_call_dict.get("tool", "")
-    tool_input = tool_call_dict.get("input", "")
 
-    if not tool_name or not tool_input: 
-        error_message = f"[Tool Error] Invalid action: Tool name '{tool_name}' or input '{tool_input}' was empty."
-        print(f"ERROR: {error_message}") 
-        state["history"].append(AIMessage(content=error_message))
-        return state
-
-    # Find and execute tool
-    available_tools = state.get("tools", [])
-    tool_fn = next((t for t in available_tools if t.name == tool_name), None)
-
-    if tool_fn is None:
-        tool_output = f"[Tool Error] Tool '{tool_name}' not found. Available: {', '.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]}...'")
-            tool_output = tool_fn.run(tool_input)
-            if tool_output is None:
-                tool_output = f"[{tool_name} output] No result returned for '{tool_input}'."
-        except Exception as e:
-            tool_output = f"[Tool Error] Error running '{tool_name}': {str(e)}"
-            print(f"ERROR: {tool_output}")
-
-    state["history"].append(AIMessage(content=f"[{tool_name} output]\n{tool_output}"))
-    
-    print(f"DEBUG: Exiting tool_node. Tool output added to history.")
-    return state
-
-# ====== AGENT GRAPH ======
-class StateGraph:
-    """Simple state graph implementation"""
-    def __init__(self, state: AgentState):
-        self.nodes = {}
-        self.entry_point = None
-        self.edges = {}
-        self.conditional_edges = {}
-        
-    def add_node(self, name: str, func: callable):
-        self.nodes[name] = func
         
-    def set_entry_point(self, name: str):
-        self.entry_point = name
-        
-    def add_conditional_edges(self, source: str, condition: callable, path_map: Dict[str, str]):
-        self.conditional_edges[source] = (condition, path_map)
-        
-    def add_edge(self, source: str, dest: str):
-        self.edges[source] = dest
-        
-    def compile(self):
-        def app(state: AgentState) -> AgentState:
-            current_node = self.entry_point
-            
-            while current_node != END:
-                if current_node in self.nodes:
-                    state = self.nodes[current_node](state)
-                    
-                if current_node in self.conditional_edges:
-                    condition, path_map = self.conditional_edges[current_node]
-                    next_node_key = condition(state)
-                    current_node = path_map.get(next_node_key, END)
-                elif current_node in self.edges:
-                    current_node = self.edges[current_node]
-                else:
-                    current_node = END
-                    
-            return state
-            
-        return app
-
-END = "__END__"
-
-# ====== AGENT INTERFACE ======
-class BasicAgent:
-    def __init__(self):
-        # Instantiate tools (implementation not shown - should be defined elsewhere)
-        self.tools = [
-            duckduckgo_search, 
-            wikipedia_search,
-            arxiv_search,
-            document_qa,
-            python_execution,
-            VideoTranscriptionTool()
-        ]
-        
-        # Pre-initialize RAG vector store
-        try:
-            self.vector_store = create_vector_store()
-            if not self.vector_store:
-                print("WARNING: Vector store creation failed. Proceeding without RAG.")
-        except Exception as e:
-            print(f"ERROR creating vector store: {str(e)}")
-            self.vector_store = None
-            
-        self.workflow = create_agent_workflow(self.tools)
-    
-    def __call__(self, question: str) -> str:
-        print(f"\n--- Agent received question: {question[:80]}{'...' if len(question) > 80 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)
-            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("--- ERROR: Agent finished without setting 'final_answer' ---")
-                if final_state.get("history"):
-                    last_message = final_state["history"][-1].content
-                    print(f"Last message: {last_message}")
-                    return f"Agent could not answer. Last message: {last_message}"
-                return "Error: Agent failed to provide an answer"
-        except Exception as e:
-            print(f"FATAL ERROR during agent execution: {str(e)}")
-            return f"Agent encountered a fatal error: {str(e)}"
-
-def create_agent_workflow(tools: List[Any]):
-    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
-
-
-
-
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,