Update app.py

app.py

@@ -24,184 +24,144 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 load_dotenv()
 
 
-from langgraph.graph import END, StateGraph
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
-from langchain_core.tools import tool
-from typing import Dict, List, TypedDict, Annotated
-import operator
-from langchain_community.llms import HuggingFaceHub
-from langchain_community.chat_models import ChatHuggingFace
-
-
-from langchain.schema import HumanMessage  # Or your framework's equivalent
-
-def init_state(question: str):
-    return {
-        "question": question,
-        "history": [HumanMessage(content=question)],
-        "context": {}  # <- Add this line
-    }
+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_core.tools import BaseTool, Tool
+
+# Hugging Face local model imports
+from langchain_community.llms import HuggingFacePipeline 
+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
+# --- Tool Definitions ---
+@Tool
 def duckduckgo_search(query: str) -> str:
     """Search web using DuckDuckGo. Returns top 3 results."""
-    from duckduckgo_search import DDGS
-    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)
-        )
+    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
+@Tool
 def wikipedia_search(query: str) -> str:
     """Get Wikipedia summaries. Returns first 3 sentences."""
-    import wikipedia
+    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 "Page not found"
+        return "Wikipedia page not found."
+    except Exception as e:
+        return f"Error performing Wikipedia search: {str(e)}"
 
-@tool
+@Tool
 def arxiv_search(query: str) -> str:
     """Search academic papers on arXiv. Returns top 3 results."""
-    import arxiv
-    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
-    )
+    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
+@Tool
 def document_qa(input_str: str) -> str:
     """Answer questions from documents. Input format: 'document_text||question'"""
-    from transformers import pipeline
-    if '||' not in input_str:
-        return "Invalid format. Use: 'document_text||question'"
-    
-    context, question = input_str.split('||', 1)
-    qa_model = pipeline('question-answering', model='deepset/roberta-base-squad2')
-    return qa_model(question=question, context=context)['answer']
+    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
+        # This makes it a bit slow on first call, but avoids re-loading.
+        # For production, consider loading this outside the tool function.
+        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
+@Tool
 def python_execution(code: str) -> str:
-    """Execute Python code and return output."""
+    """Execute Python code and return output.
+    The code should assign its final result to a variable named 'result'.
+    Example: 'result = 1 + 1'
+    """
+    print(f"DEBUG: python_execution called with: {code}")
     try:
         # Create isolated environment
         env = {}
-        exec(f"def __exec_fn__():\n    {indent_code(code)}\nresult = __exec_fn__()", env)
-        return str(env.get('result', 'No output'))
+        # Wrap code in a function to isolate scope and capture 'result'
+        exec(f"def __exec_fn__():\n{indent_code(code)}\nresult = __exec_fn__()", globals(), env)
+        return str(env.get('result', 'No explicit result assigned to "result" variable.'))
     except Exception as e:
-        return f"Error: {str(e)}"
-
-from typing import Optional
-from langchain_core.tools import BaseTool
-from youtube_transcript_api import YouTubeTranscriptApi
+        return f"Python execution error: {str(e)}"
 
 class VideoTranscriptionTool(BaseTool):
     name: str = "transcript_video"
-    description: str = "Fetch text transcript from YouTube videos using URL or ID. Optionally include timestamps."
+    description: "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: str, include_timestamps: Optional[bool] = False) -> str:
-        # Extract video ID
+    def _run(self, url_or_id: str) -> str:
+        print(f"DEBUG: transcript_video called with: {url_or_id}")
         video_id = None
-        if "youtube.com/watch?v=" in url:
-            video_id = url.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in url:
-            video_id = url.split("youtu.be/")[1].split("?")[0]
-        elif len(url.strip()) == 11 and not ("http://" in url or "https://" in url):
-            video_id = url.strip()
+        # Basic parsing for common YouTube URL formats
+        if "youtu.be/" in url_or_id:
+            video_id = url_or_id.split("youtu.be/")[1].split("?")[0]
+        elif "youtube.com/watch?v=" in url_or_id:
+            video_id = url_or_id.split("v=")[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}"
+            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)
-
-            if include_timestamps:
-                formatted = []
-                for part in transcription:
-                    timestamp = f"{int(part['start']//60)}:{int(part['start']%60):02d}"
-                    formatted.append(f"[{timestamp}] {part['text']}")
-                return "\n".join(formatted)
-            else:
-                return " ".join([part['text'] for part in transcription])
+            # You can add include_timestamps logic here if needed,
+            # but for simplicity, let's just return the text.
+            return " ".join([part['text'] for part in transcription])
 
         except Exception as e:
-            return f"Error fetching transcript: {str(e)}"
+            # Catch specific errors for better messages, e.g., NoTranscriptFound
+            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.")
 
-
-
-
-
-
-
-import os
-import time
-import json
-from typing import TypedDict, List, Union, Any, Dict
-from langchain_huggingface import ChatHuggingFace
-from langchain_huggingface.llms import HuggingFaceEndpoint
-from langchain.schema import HumanMessage, AIMessage, SystemMessage
-from langchain.prompts import ChatPromptTemplate
-from langgraph.graph import StateGraph, END
-from langchain.tools import Tool
-
-# Assume these tools are defined elsewhere and imported
-# Placeholder for your actual tool implementations
-def duckduckgo_search(query: str) -> str:
-    """Performs a DuckDuckGo search for current events or general facts."""
-    print(f"DEBUG: duckduckgo_search called with: {query}")
-    return f"Search result for '{query}': Example relevant information from web."
-
-def wikipedia_search(query: str) -> str:
-    """Searches Wikipedia for encyclopedic information."""
-    print(f"DEBUG: wikipedia_search called with: {query}")
-    return f"Wikipedia result for '{query}': Found detailed article."
-
-def arxiv_search(query: str) -> str:
-    """Searches ArXiv for scientific preprints and papers."""
-    print(f"DEBUG: arxiv_search called with: {query}")
-    return f"ArXiv result for '{query}': Found relevant research paper."
-
-def document_qa(document_path: str, question: str) -> str:
-    """Answers questions based on the content of a given document file (PDF, DOCX, TXT)."""
-    print(f"DEBUG: document_qa called with: {document_path}, question: {question}")
-    return f"Document QA result for '{question}': Answer extracted from document."
-
-def python_execution(code: str) -> str:
-    """Executes Python code in a sandboxed environment for calculations or data manipulation."""
-    try:
-        exec_globals = {}
-        exec_locals = {}
-        # WARNING: This is a highly insecure way to execute arbitrary Python code.
-        # For production, use a secure, sandboxed environment (e.g., Docker container, dedicated service).
-        exec(code, exec_globals, exec_locals)
-        return str(exec_locals.get('result', 'Code executed, no explicit result assigned to "result" variable.'))
-    except Exception as e:
-        return f"Python execution error: {str(e)}"
-
-class VideoTranscriptionTool:
-    """Transcribes and analyzes video content from a URL or ID."""
-    def __call__(self, video_id_or_url: str) -> str:
-        print(f"DEBUG: VideoTranscriptionTool called with: {video_id_or_url}")
-        return f"Video transcription/analysis result for '{video_id_or_url}': Summary of video content."
-
-
 # --- Agent State Definition ---
 class AgentState(TypedDict):
     question: str
@@ -212,8 +172,7 @@ class AgentState(TypedDict):
     final_answer: Union[str, float, int, None]
     current_task: str
     current_thoughts: str
-    tools: List[Tool]
-
+    tools: List[Tool] # Make sure tools are passed via state
 
 # --- Utility Functions ---
 def parse_agent_response(response_content: str) -> tuple[str, str, str]:
@@ -240,15 +199,13 @@ def parse_agent_response(response_content: str) -> tuple[str, str, str]:
         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()
-            # Clean up leading/trailing quotes if present
             if reasoning.startswith('"') and reasoning.endswith('"'):
                 reasoning = reasoning[1:-1]
-        elif reasoning_idx != -1: # If only reasoning is found
+        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)
@@ -259,15 +216,14 @@ def parse_agent_response(response_content: str) -> tuple[str, str, str]:
             else:
                 action = response_content[action_idx + len("Action:"):].strip()
             
-            # Clean up action and action_input
             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() # Stop at first quote for safety if it's "Action": "tool_name",
-        action_input = action_input.split('"', 1)[0].strip() # Similar for input
+        action = action.split('"', 1)[0].strip() 
+        action_input = action_input.split('"', 1)[0].strip() 
 
         return reasoning, action, action_input
 
@@ -300,10 +256,6 @@ def reasoning_node(state: AgentState) -> AgentState:
     print(f"DEBUG: Entering reasoning_node. Iteration: {state['iterations']}")
     print(f"DEBUG: Current history length: {len(state.get('history', []))}")
 
-    HF_TOKEN = os.getenv("HF_TOKEN")
-    if not HF_TOKEN:
-        raise ValueError("HF_TOKEN not set in environment variables.")
-
     state.setdefault("context", {})
     state.setdefault("reasoning", "")
     state.setdefault("iterations", 0)
@@ -312,21 +264,45 @@ def reasoning_node(state: AgentState) -> AgentState:
     
     state["context"].pop("pending_action", None) 
 
-    model_id = "mistralai/Mistral-7B-Instruct-v0.2" 
+    # --- Initialize local HuggingFacePipeline ---
+    # Using Mistral-7B-Instruct-v0.2 for better agent performance
+    model_name = "mistralai/Mistral-7B-Instruct-v0.2" 
     
-    llm = ChatHuggingFace(
-        llm=HuggingFaceEndpoint(
-            repo_id=model_id,
-            max_new_tokens=1024, # Increased max_new_tokens
-            temperature=0.1,
-            huggingfacehub_api_token=HF_TOKEN,
-        )
+    print(f"DEBUG: Loading local model: {model_name}...")
+    
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    
+    # Load model with optimal settings for GPU if available, else CPU
+    # Use bfloat16 for GPUs that support it (NVIDIA Ampere architecture and newer)
+    # else float16 for older GPUs or float32 for CPU/fallback.
+    # device_map="auto" intelligently distributes the model across available devices.
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name, 
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, 
+        device_map="auto"
+    )
+
+    # Create a transformers pipeline
+    pipe = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        max_new_tokens=1024, # Increased max_new_tokens for potentially longer JSON
+        temperature=0.1,    # Keep low for factual, tool-use tasks
+        do_sample=True,     # Allow some sampling
+        top_p=0.9,
+        repetition_penalty=1.1, # Help avoid repetitive output
+        # device_map handled by model loading
     )
 
+    llm = HuggingFacePipeline(pipeline=pipe)
+    # --- END LOCAL LLM INITIALIZATION ---
+
     tool_descriptions = "\n".join([
         f"- **{t.name}**: {t.description}" for t in state.get("tools", [])
     ])
 
+    # Enhanced system prompt for better JSON adherence
     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, "
@@ -334,12 +310,12 @@ def reasoning_node(state: AgentState) -> AgentState:
         "**Available Tools:**\n"
         f"{tool_descriptions}\n\n"
         "**Tool Usage Guidelines:**\n"
-        "- Use **duckduckgo_search** for current events, general facts, or quick lookups.\n"
-        "- Use **wikipedia_search** for encyclopedic information, historical context, or detailed topics.\n"
-        "- Use **arxiv_search** for scientific papers, research, or cutting-edge technical information.\n"
-        "- Use **document_qa** when the question explicitly refers to a specific document file (e.g., 'Analyze this PDF').\n"
+        "- Use **duckduckgo_search** for current events, general facts, or quick lookups. Provide a concise search query.\n"
+        "- Use **wikipedia_search** for encyclopedic information, historical context, or detailed topics. Provide a concise search term.\n"
+        "- Use **arxiv_search** for scientific papers, research, or cutting-edge technical information. Provide a concise search query.\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'.\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' if applicable.\n"
-        "- Use **VideoTranscriptionTool** for any question involving video or audio content. Provide the full YouTube URL or video ID.\n\n"
+        "- Use **transcript_video** for any question involving video or audio content (e.g., YouTube). Provide the full YouTube URL or video ID.\n\n"
         "**Current Context:**\n{context}\n\n"
         "**Previous Reasoning Steps:**\n{reasoning}\n\n"
         "**Current Task:** {current_task}\n"
@@ -347,14 +323,14 @@ def reasoning_node(state: AgentState) -> AgentState:
         "**Your Response MUST be a valid JSON object with the following keys:**\n"
         "```json\n"
         "{\n"
-        "  \"Reasoning\": \"Your detailed analysis of the question and why you chose a specific action.\",\n"
+        "  \"Reasoning\": \"Your detailed analysis of the question and why you chose a specific action. Focus on the logical steps.\",\n"
         "  \"Action\": \"[Tool name OR 'Final Answer']\",\n"
-        "  \"Action Input\": \"[Input for the selected tool OR the final response]\"\n"
+        "  \"Action Input\": \"[Input for the selected tool OR the complete final answer]\"\n"
         "}\n"
         "```\n"
-        "**CRITICAL RULE: 'Action' and 'Action Input' MUST NOT be empty, unless 'Action' is 'Final Answer' and 'Action Input' is the conclusive response.**\n"
-        "If you cannot determine a suitable tool or a final answer, return Action: 'Final Answer' with a message like 'I cannot answer this question with the available tools.' or 'More information is needed.'\n"
-        "Ensure 'Action Input' is appropriate for the chosen 'Action'. If 'Action' is 'Final Answer', provide the complete, concise answer."
+        "**CRITICAL RULE: 'Action' and 'Action Input' MUST NOT be empty strings, unless 'Action' is 'Final Answer' and 'Action Input' is the conclusive response.**\n"
+        "If you cannot determine a suitable tool or a conclusive final answer after exhausting options, return Action: 'Final Answer' with a message like 'I cannot answer this question with the available tools.' or 'More information is needed.'\n"
+        "Ensure 'Action Input' is always the complete, valid input for the chosen 'Action'. If 'Action' is 'Final Answer', provide the complete, concise answer."
     )
 
     prompt = ChatPromptTemplate.from_messages([
@@ -362,45 +338,61 @@ def reasoning_node(state: AgentState) -> AgentState:
         *state["history"] 
     ])
 
-    chain = prompt | llm
+    formatted_messages = prompt.format_messages(
+        context=state["context"],
+        reasoning=state["reasoning"],
+        question=state["question"],
+        current_task=state["current_task"],
+        current_thoughts=state["current_thoughts"]
+    )
+    
+    # Use tokenizer's chat template for optimal formatting with chat models
+    try:
+        full_input_string = tokenizer.apply_chat_template(
+            formatted_messages, 
+            tokenize=False, 
+            add_generation_prompt=True # Adds the assistant's turn start token
+        )
+    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(inputs, retries=3, delay=30): 
+    def call_with_retry_local(inputs, retries=3): # Reduced retries for local models as network isn't primary issue
         for attempt in range(retries):
             try:
-                response = chain.invoke(inputs)
-                # --- NEW DEBUGGING PRINT ---
-                print(f"DEBUG: RAW LLM Response (Attempt {attempt+1}):\n---\n{response.content}\n---")
-                # --- END NEW DEBUGGING PRINT ---
-                json.loads(response.content) # Attempt to parse to validate structure
-                return response
+                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}] LLM returned invalid JSON. Error: {e}. Retrying...")
-                print(f"Invalid JSON content (partial): {response.content[:200]}...")
-                # Add specific error message to history to guide LLM
+                print(f"[Retry {attempt+1}/{retries}] Local LLM returned invalid JSON. Error: {e}. Retrying...")
+                print(f"Invalid JSON content (partial): {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(5) 
             except Exception as e: 
-                print(f"[Retry {attempt+1}/{retries}] An unexpected error occurred during LLM call: {e}. Waiting {delay}s...")
-                state["history"].append(AIMessage(content=f"[API Error] Failed to get a response from the LLM due to an API error: {e}. Trying again."))
-                time.sleep(delay)
-        raise RuntimeError("Failed after multiple retries due to Hugging Face API issues or invalid JSON.")
-
-    response = call_with_retry({
-        "context": state["context"],
-        "reasoning": state["reasoning"],
-        "question": state["question"],
-        "current_task": state["current_task"],
-        "current_thoughts": state["current_thoughts"]
-    })
+                print(f"[Retry {attempt+1}/{retries}] An unexpected error occurred during local LLM call: {e}.")
+                state["history"].append(AIMessage(content=f"[Local LLM Error] Failed to get a response from the local LLM: {e}. Trying again."))
+                time.sleep(10) 
+        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)
     
     print(f"DEBUG: Parsed Action: '{action}', Action Input: '{action_input[:100]}...'")
 
-    # Only append the LLM's raw output if it was valid JSON and processed successfully
-    # Otherwise, the specific error message from the retry loop will already be in history.
-    if isinstance(response, AIMessage) and content == response.content: # Check if it's the original response, not an error message
+    if isinstance(response, AIMessage) and content == response.content: 
         state["history"].append(AIMessage(content=content)) 
         
     state["reasoning"] += f"\nStep {state['iterations'] + 1}: {reasoning}"
@@ -414,8 +406,6 @@ def reasoning_node(state: AgentState) -> AgentState:
             "tool": action,
             "input": action_input
         }
-        # Add a message to history to indicate the agent's intent for the LLM
-        # This will be shown to the LLM in the next turn.
         state["history"].append(AIMessage(content=f"Agent decided to use tool: {action} with input: {action_input}"))
 
 
@@ -440,14 +430,15 @@ def tool_node(state: AgentState) -> AgentState:
     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. LLM needs to provide valid 'Action' and 'Action Input'."
-        print(f"ERROR: {error_output}") # Print the error message for debugging
+    if not tool_name or tool_input is None: # Check for None as empty string "" might be valid input for some tools
+        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", [])
+    # Use Tool.name to match, which is what @Tool decorator sets
     tool_fn = next((t for t in available_tools if t.name == tool_name), None)
 
     if tool_fn is None:
@@ -457,7 +448,7 @@ def tool_node(state: AgentState) -> AgentState:
         try:
             print(f"DEBUG: Invoking tool '{tool_name}' with input: '{tool_input[:100]}...'")
             tool_output = tool_fn.run(tool_input)
-            if not tool_output and tool_output is not False: 
+            if not tool_output and tool_output is not False: # Ensure 'False' or 0 are not treated as empty
                 tool_output = f"[{tool_name} output] No specific result found for '{tool_input}'. The tool might have returned an empty response."
         except Exception as e:
             tool_output = f"[Tool Error] An error occurred while running '{tool_name}': {str(e)}"
@@ -497,13 +488,14 @@ def create_agent_workflow(tools: List[Tool]):
 # ====== Agent Interface ======
 class BasicAgent:
     def __init__(self):
+        # Instantiate tools
         self.tools = [
-            Tool(name="duckduckgo_search", func=duckduckgo_search, description="Performs a DuckDuckGo search for current events or general facts."),
-            Tool(name="wikipedia_search", func=wikipedia_search, description="Searches Wikipedia for encyclopedic information."),
-            Tool(name="arxiv_search", func=arxiv_search, description="Searches ArXiv for scientific preprints and papers."),
-            Tool(name="document_qa", func=document_qa, description="Answers questions based on the content of a given document file (PDF, DOCX, TXT). Requires 'document_path' and 'question' as input."),
-            Tool(name="python_execution", func=python_execution, description="Executes Python code in a sandboxed environment for complex calculations or data manipulation."),
-            Tool(name="VideoTranscriptionTool", func=VideoTranscriptionTool(), description="Transcribes and analyzes video content from a URL or ID. Use for any question involving video or audio.")
+            duckduckgo_search,
+            wikipedia_search,
+            arxiv_search,
+            document_qa,
+            python_execution,
+            VideoTranscriptionTool() # Instantiate the class-based tool
         ]
         self.workflow = create_agent_workflow(self.tools)
 
@@ -519,9 +511,10 @@ class BasicAgent:
             "final_answer": None,
             "current_task": "Understand the question and plan the next step.",
             "current_thoughts": "",
-            "tools": self.tools
+            "tools": self.tools # Pass tools through state
         }
 
+        # The invoke method returns the final state after execution
         final_state = self.workflow.invoke(state)
 
         if final_state.get("final_answer") is not None:
@@ -530,7 +523,6 @@ class BasicAgent:
             return answer
         else:
             print(f"--- ERROR: Agent finished without setting 'final_answer' for question: {question} ---")
-            # You might want to return the last message from history if no final answer was set
             if final_state["history"]:
                 last_message = final_state["history"][-1].content
                 print(f"Last message in history: {last_message}")