50% mark

poetry.lock

@@ -5935,6 +5935,18 @@ files = [
     {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"},
 ]
 
+[[package]]
+name = "simpleeval"
+version = "1.0.3"
+description = "A simple, safe single expression evaluator library."
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "simpleeval-1.0.3-py3-none-any.whl", hash = "sha256:e3bdbb8c82c26297c9a153902d0fd1858a6c3774bf53ff4f134788c3f2035c38"},
+    {file = "simpleeval-1.0.3.tar.gz", hash = "sha256:67bbf246040ac3b57c29cf048657b9cf31d4e7b9d6659684daa08ca8f1e45829"},
+]
+
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -7317,19 +7329,26 @@ multidict = ">=4.0"
 propcache = ">=0.2.1"
 
 [[package]]
-name = "youtube-search-python"
-version = "1.6.6"
-description = "Search for YouTube videos, channels & playlists & get video information using link WITHOUT YouTube Data API v3"
+name = "yt-dlp"
+version = "2025.9.26"
+description = "A feature-rich command-line audio/video downloader"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "youtube-search-python-1.6.6.tar.gz", hash = "sha256:4568d1d769ecd7eb4bb8365f04eec6e364c5f70eec7b3765f543daebb135fcf5"},
-    {file = "youtube_search_python-1.6.6-py3-none-any.whl", hash = "sha256:f0d835278bc32335f2ded48ba119bef39cafb290d98648a64deb22f6c4a705f2"},
+    {file = "yt_dlp-2025.9.26-py3-none-any.whl", hash = "sha256:36f5fbc153600f759abd48d257231f0e0a547a115ac7ffb05d5b64e5c7fdf8a2"},
+    {file = "yt_dlp-2025.9.26.tar.gz", hash = "sha256:c148ae8233ac4ce6c5fbf6f70fcc390f13a00f59da3776d373cf88c5370bda86"},
 ]
 
-[package.dependencies]
-httpx = ">=0.14.2"
+[package.extras]
+build = ["build", "hatchling (>=1.27.0)", "pip", "setuptools (>=71.0.2,<81)", "wheel"]
+curl-cffi = ["curl-cffi (>=0.5.10,<0.6.dev0 || >=0.10.dev0,<0.14) ; implementation_name == \"cpython\""]
+default = ["brotli ; implementation_name == \"cpython\"", "brotlicffi ; implementation_name != \"cpython\"", "certifi", "mutagen", "pycryptodomex", "requests (>=2.32.2,<3)", "urllib3 (>=2.0.2,<3)", "websockets (>=13.0)"]
+dev = ["autopep8 (>=2.0,<3.0)", "pre-commit", "pytest (>=8.1,<9.0)", "pytest-rerunfailures (>=14.0,<15.0)", "ruff (>=0.13.0,<0.14.0)"]
+pyinstaller = ["pyinstaller (>=6.13.0)"]
+secretstorage = ["cffi", "secretstorage"]
+static-analysis = ["autopep8 (>=2.0,<3.0)", "ruff (>=0.13.0,<0.14.0)"]
+test = ["pytest (>=8.1,<9.0)", "pytest-rerunfailures (>=14.0,<15.0)"]
 
 [[package]]
 name = "zipp"
@@ -7466,4 +7485,4 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11,<3.12"
-content-hash = "2905668a22145f92f7e5e93be056bef26befc214f63d5a75b4cd908b651c50ab"
+content-hash = "1da4648fb3d6c5c1af29971f0aa8c9eb7defb6895ab8962aedd627d6d8344ce4"

pyproject.toml

@@ -16,7 +16,8 @@ langchain_huggingface = "*"
 langchain_community = "*"
 langchain_google_genai = "*"
 wikipedia = "*"
-youtube-search-python = "*"
+yt-dlp = "*"
+youtube-transcript-api = "*"
 pillow = "*"
 langchain_experimental = "*"
 langchain-tavily = ">=0.2.11,<0.3.0"
@@ -32,6 +33,7 @@ langchain = "*"
 tesseract = ">=0.1.3,<0.2.0"
 unstructured = {extras = ["all-docs"], version = "*"}
 langchain-google-community = "^2.0.10"
+simpleeval = "^1.0.3"
 
 
 [build-system]

src/flexible_agent.py

@@ -13,13 +13,13 @@ try:
     # Try relative imports first (when used as package)
     from .tools import (
         wikipedia_search, youtube_search, decode_text,
-        download_and_process_file, web_search
+        download_and_process_file, web_search, evaluate_computation
     )
 except ImportError:
     # Fall back to absolute imports (when run directly)
     from tools import (
         wikipedia_search, youtube_search, decode_text,
-        download_and_process_file, web_search
+        download_and_process_file, web_search, evaluate_computation
     )
 
 from langchain_google_genai import ChatGoogleGenerativeAI
@@ -27,8 +27,8 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 
 # --- Agent State following LangGraph pattern ---
 class AgentState(TypedDict):
-    # The original question from the user
-    question: str
+    # Messages for LLM interactions (includes question and all conversation)
+    messages: Annotated[List[BaseMessage], add_messages]
     
     # Task ID for file downloads
     task_id: Optional[str]
@@ -36,17 +36,8 @@ class AgentState(TypedDict):
     # File classification results
     requires_file: Optional[bool]
     
-    # File content if downloaded and processed
-    file_content: Optional[str]
-    
-    # Search attempt counter to prevent infinite loops
-    search_attempts: int
-    
     # Final answer
     final_answer: Optional[str]
-    
-    # Messages for LLM interactions (for logging)
-    messages: Annotated[List[BaseMessage], add_messages]
 
 
 # --- Flexible Tool-Based Agent ---
@@ -55,16 +46,19 @@ class FlexibleAgent:
         
         # Initialize Gemini chat model for LangChain integration
         self.chat = ChatGoogleGenerativeAI(
-            # google_api_key=os.getenv("GEMINI_API_KEY"),
-            # model="gemini-2.0-flash-lite",
-            model="gemini-2.5-flash-lite",
+            model="gemini-2.5-flash",
             temperature=0.0,
             max_tokens=None
         )
         
-        # Define available tools (excluding file detection - now handled by graph nodes)
+        # Define available tools
         self.tools = [
-            wikipedia_search, youtube_search, decode_text, web_search
+            wikipedia_search, 
+            youtube_search, 
+            decode_text, 
+            web_search,
+            download_and_process_file,
+            evaluate_computation
         ]
         
         # Bind tools to the LLM
@@ -141,270 +135,112 @@ class FlexibleAgent:
         print(f"Logged full conversation to: {filename}")
     
     def classify_file_requirement(self, state: AgentState):
-        """LLM-based classification of whether the question requires a file attachment"""
-        question = state["question"]
+        """Check if question mentions an attached file"""
+        messages = state["messages"]
         
-        # For the first message, include the question
-        if not state.get("messages"):
-            # Initial message with question
-            first_message = HumanMessage(content=question)
-            
-            # Classification prompt - no need to repeat the question
-            classification_prompt = """
-            Analyze the question above and determine if it requires accessing an attached file.
-            
-            Determine if the question mentions attached files (like "I've attached", "attached as", "see attached", etc.)
-            
-            If the question requires a file, answer "yes". If not, answer "no".
-            If a url is provided, answer "no".
-            """
-            
-            # Call the LLM with both messages
-            messages = [first_message, HumanMessage(content=classification_prompt)]
-            response = self.chat.invoke(messages)
-            
-            # Update messages for tracking
-            new_messages = [first_message, HumanMessage(content=classification_prompt), response]
-        else:
-            # Subsequent call - messages already exist
-            classification_prompt = """
-            Analyze the question and determine if it requires accessing an attached file.
+        # Get the original question from first message
+        if messages and isinstance(messages[0], HumanMessage):
+            question = messages[0].content.lower()
             
-            If the question requires a file, answer "yes". If not, answer "no".
-            If a url is provided, answer "no".
-            """
-            
-            # Call the LLM
-            messages = state["messages"] + [HumanMessage(content=classification_prompt)]
-            response = self.chat.invoke(messages)
+            # Simple keyword check for file attachments
+            file_keywords = ["attached", "attachment", "see the file", "in the file", 
+                           "i've attached", "attached as", "attached file"]
+            requires_file = any(keyword in question for keyword in file_keywords)
             
-            # Update messages for tracking
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=classification_prompt),
-                response
-            ]
-        
-        # Parse the response to determine if file is required
-        response_text = response.content.lower()
-        requires_file = response_text == "yes"
-        
-        # Return state updates
-        return {
-            "requires_file": requires_file,
-            "messages": new_messages
-        }
+            return {"requires_file": requires_file}
+        
+        return {"requires_file": False}
     
     def download_file_content(self, state: AgentState):
-        """Download and process the file content"""
-        task_id = state["task_id"]
+        """Download and add file content to messages"""
+        task_id = state.get("task_id")
         
         if not task_id:
-            error_msg = "Error: No task_id provided for file download"
-            # Add error message to conversation
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=error_msg)
-            ]
+            # Add error message
             return {
-                "file_content": error_msg,
-                "messages": new_messages
+                "messages": [HumanMessage(content="Error: No task_id provided for file download")]
             }
         
         try:
-            # Use the download tool (but call it directly instead of as a tool)
-            file_result = download_and_process_file(task_id)
-            
-            # Add file content to conversation without repeating the question
-            file_message = f"File Content:\n{file_result}"
-            
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=file_message)
-            ]
+            # Use the download tool directly
+            file_result = download_and_process_file.invoke({"task_id": task_id})
             
+            # Add file content as a system message
             return {
-                "file_content": file_result,
-                "messages": new_messages
+                "messages": [HumanMessage(content=f"File content:\n{file_result}")]
             }
             
         except Exception as e:
-            error_msg = f"Error downloading file: {str(e)}"
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=error_msg)
-            ]
             return {
-                "file_content": error_msg,
-                "messages": new_messages
+                "messages": [HumanMessage(content=f"Error downloading file: {str(e)}")]
             }
     
-    def answer_with_tools(self, state: AgentState):
-        """Use tools to answer the question (with or without file content)"""
-        # Increment search attempts
-        search_attempts = state.get("search_attempts", 0) + 1
-        
-        # Create system prompt for tool usage - question is already in conversation
-        system_prompt = f"""
-Use your tools to answer the question above.
-"""
-        
-        # Use existing conversation context
-        messages = state.get("messages", []) + [HumanMessage(content=system_prompt)]
-        
-        # Let the LLM decide what tools to use
+    def call_model(self, state: AgentState):
+        """Call the model with tools - it will decide what to do"""
+        messages = state["messages"]
         response = self.chat_with_tools.invoke(messages)
-        
-        # Update messages for tracking
-        new_messages = state.get("messages", []) + [
-            HumanMessage(content=system_prompt),
-            response
-        ]
-        
-        return {"messages": new_messages, "search_attempts": search_attempts}
+        return {"messages": [response]}
     
-    def plan_approach(self, state: AgentState):
-        """Decide whether to use tools or answer directly"""
-        # Create system prompt for decision making - no need to repeat the question
-        planning_prompt = """Now you need to decide how to answer the question above.
+    def analyze_tool_results(self, state: AgentState):
+        """Analyze if tool results are sufficient to answer the question"""
+        analysis_prompt = """Based on the tool results above, think through the following:
 
-Should you use tools to answer this question? Respond with ONLY "tools" or "direct":
+1. Do you have enough information to answer the original question?
+2. Are the tool results relevant and helpful?
+3. Do you need to use another tool to get more information?
 
-- ALWAYS use "tools" if:
-  * The user explicitly mentions "search", "Wikipedia", "YouTube", or any tool name
-  * The question asks about factual information that would benefit from Wikipedia search
-  * The question mentions YouTube videos or asks about video content
-  * The question provides image URLs to analyze
-  * The question involves encoded/backwards text
-  * The user specifically requests using external sources
+If you consider that you don't need to use another tool, then try to answer the question based on what infos you have, the best you can. 
+Think about the fact that the answer may formulated using synonyms or similar words to the ones used in the question.
+Even if you are not able to youtube video, the result may be in the description of the video.
 
-- Use "direct" if:
-  * It's a simple math calculation AND no search is requested
-  * It's a general knowledge question you can answer confidently AND no search is requested
-  * It's asking for an opinion or creative content
-  * No tools would significantly improve the answer AND no search is requested
-"""
-        
-        # Get LLM decision using existing conversation context
-        messages = state.get("messages", []) + [HumanMessage(content=planning_prompt)]
-        response = self.chat.invoke(messages)
-        
-        # Update messages for tracking
-        new_messages = state.get("messages", []) + [
-            HumanMessage(content=planning_prompt),
-            response
-        ]
-        
-        return {"messages": new_messages}
+Provide your reasoning and conclude with either:
+- "READY_TO_ANSWER" if you have sufficient information
+- "NEED_MORE_TOOLS" if you need additional tool calls
 
-    def answer_directly(self, state: AgentState):
-        """Answer the question directly without tools"""
-        # Create system prompt - question is already in conversation
-        system_prompt = "You are a helpful assistant. Answer the question above directly and accurately."
-        
-        # Use existing conversation context
-        messages = state.get("messages", []) + [AIMessage(content=system_prompt)]
+Format your response as:
+REASONING: [your analysis here]
+CONCLUSION: [READY_TO_ANSWER or NEED_MORE_TOOLS]"""
         
-        # Get response
+        messages = state["messages"] + [HumanMessage(content=analysis_prompt)]
         response = self.chat.invoke(messages)
         
-        # Update messages for tracking
-        new_messages = state.get("messages", []) + [
-            AIMessage(content=system_prompt),
-            response
-        ]
-        
-        return {"messages": new_messages}
+        # Add the analysis to messages
+        return {"messages": [response]}
     
-    def provide_final_answer(self, state: AgentState):
-        """Provide a final answer based on tool results, or request more searches if needed"""
-        search_attempts = state.get("search_attempts", 0)
-        
-        # If we've reached the search limit, force a final answer
-        if search_attempts >= 5:
-            final_prompt = """You have reached the maximum number of search attempts (5). 
-            
-Based on all the information gathered in this conversation, provide the best possible answer to the original question. 
-If you could not find the specific information requested, clearly state that the information could not be found."""
-            
-            # Use regular chat (without tools) to force a final answer
-            messages = state.get("messages", []) + [HumanMessage(content=final_prompt)]
-            response = self.chat.invoke(messages)
-            
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=final_prompt),
-                response
-            ]
-            
-            return {"messages": new_messages}
-        else:
-            # Allow more searches if under the limit
-            final_prompt = f"""Based on the conversation above and any tool results, either:
-
-1. Provide a clear and direct answer to the original question if you have enough information, OR
-2. Use additional tools to search for missing information
-
-SEARCH ATTEMPTS: {search_attempts}/5 (Maximum 5 attempts)
-
-SEARCH STRATEGY FOR COMPLEX QUESTIONS:
-- If you couldn't find information with one search, try breaking it down:
-  * For questions about actors in different shows, search each show/movie separately
-  * For questions about adaptations, search for the original work first, then the adaptation
-  * Use simpler, more specific search terms
-  * Try different keyword combinations if first search fails
-
-CURRENT SITUATION:
-- Review what searches you've already tried
-- If previous searches failed, try different, simpler search terms
-- Break complex questions into their component parts and search each separately
-
-If you need more information, use the tools. If you have enough information, provide the final answer."""
-            
-            # Use the chat with tools so it can decide to search more
-            messages = state.get("messages", []) + [HumanMessage(content=final_prompt)]
-            response = self.chat_with_tools.invoke(messages)
-            
-            # Update messages for tracking
-            new_messages = state.get("messages", []) + [
-                HumanMessage(content=final_prompt),
-                response
-            ]
-            
-            return {"messages": new_messages}
-    
-    def route_after_classification(self, state: AgentState) -> str:
-        """Determine the next step based on file requirement classification"""
-        if state["requires_file"]:
-            return "file_required"
-        else:
-            return "no_file_required"
-    
-    def route_after_planning(self, state: AgentState) -> str:
-        """Determine whether to use tools or answer directly based on LLM decision"""
-        messages = state.get("messages", [])
-        
-        # Get the last AI message (the planning decision)
-        for msg in reversed(messages):
-            if isinstance(msg, AIMessage):
-                decision = msg.content.lower().strip()
-                if "tools" in decision:
-                    return "use_tools"
-                elif "direct" in decision:
-                    return "answer_direct"
-                break
-        
-        # Default to direct if unclear
-        return "answer_direct"
+    def route_after_analysis(self, state: AgentState) -> str:
+        """Route based on whether we can answer or need more tools"""
+        messages = state["messages"]
+        
+        # Get the last message (should be the analysis)
+        if messages:
+            last_message = messages[-1]
+            if isinstance(last_message, AIMessage):
+                content = last_message.content.upper()
+                
+                # Check if ready to answer
+                if "READY_TO_ANSWER" in content:
+                    return "extract_answer"
+                elif "NEED_MORE_TOOLS" in content:
+                    return "call_model"
+        
+        # Default: try to answer
+        return "extract_answer"
     
     def extract_final_answer(self, state: AgentState):
         """Extract ONLY the final answer from the conversation"""
         # Create a dedicated extraction prompt that looks at the entire conversation
-        extraction_prompt = """Look at the entire conversation above and extract ONLY the final answer to the original question. 
-Return just the answer with no extra words, explanations, or formatting.
+        extraction_prompt = """Based on all the information gathered above, provide ONLY the final answer to the original question.
 
-If the answer is a number, write it in digits.
+Rules:
+- Return ONLY the answer with NO explanations, sentences, or extra words
+- If the answer is a number, write it in digits only
+- No punctuation unless it's part of the answer
+- No phrases like "The answer is" or "Based on..."
 
 Examples:
-- If the conversation concludes "The capital is Paris", return: Paris
-- If the conversation concludes "2 + 2 equals 4", return: 4  
-- If the conversation concludes "The opposite of left is right", return: right
-- If the conversation concludes "Based on search results, the answer is 42", return: 42
+- Question: "What is the capital of France?" → Answer: Paris
+- Question: "How much is 2+2?" → Answer: 4
+- Question: "What is the opposite of left?" → Answer: right
 
 Final answer only:"""
         
@@ -413,110 +249,96 @@ Final answer only:"""
             messages = state["messages"] + [HumanMessage(content=extraction_prompt)]
             response = self.chat.invoke(messages)
             answer = response.content.strip()
-            return answer
+            # Return dict to update state (LangGraph requirement)
+            return {"final_answer": answer}
         except Exception as e:
             print(f"Answer extraction error: {e}")
             # Fallback: get the last AI message content
             messages = state["messages"]
             for msg in reversed(messages):
                 if isinstance(msg, AIMessage) and not getattr(msg, 'tool_calls', None):
-                    return msg.content.strip()
-            return "No answer found"
+                    return {"final_answer": msg.content.strip()}
+            return {"final_answer": "No answer found"}
+    
+    def route_after_classification(self, state: AgentState) -> str:
+        """Route based on file requirement"""
+        if state.get("requires_file"):
+            return "download_file"
+        else:
+            return "call_model"
     
     def _build_graph(self):
-        """Build the LangGraph workflow with proper planning approach"""
+        """Build LangGraph workflow with reasoning/analysis step"""
         graph = StateGraph(AgentState)
         
         # Add nodes
-        graph.add_node("classify_file_requirement", self.classify_file_requirement)
-        graph.add_node("download_file_content", self.download_file_content)
-        graph.add_node("plan_approach", self.plan_approach)
-        graph.add_node("answer_with_tools", self.answer_with_tools)
-        graph.add_node("answer_directly", self.answer_directly)
+        graph.add_node("classify_file", self.classify_file_requirement)
+        graph.add_node("download_file", self.download_file_content)
+        graph.add_node("call_model", self.call_model)
         graph.add_node("tools", ToolNode(self.tools))
+        graph.add_node("analyze_results", self.analyze_tool_results)
+        graph.add_node("extract_answer", self.extract_final_answer)
         
-        # Define the flow - Start with file classification
-        graph.add_edge(START, "classify_file_requirement")
+        # Define the flow
+        graph.add_edge(START, "classify_file")
         
-        # Add conditional branching after classification
+        # After classification, either download file or go to model
         graph.add_conditional_edges(
-            "classify_file_requirement",
+            "classify_file",
             self.route_after_classification,
             {
-                "file_required": "download_file_content",
-                "no_file_required": "plan_approach"
+                "download_file": "download_file",
+                "call_model": "call_model"
             }
         )
         
-        # After downloading file, plan the approach
-        graph.add_edge("download_file_content", "plan_approach")
+        # After downloading file, call model
+        graph.add_edge("download_file", "call_model")
         
-        # After planning, decide whether to use tools or answer directly
+        # After model call, check if tools were called
         graph.add_conditional_edges(
-            "plan_approach",
-            self.route_after_planning,
+            "call_model",
+            tools_condition,  # Built-in function that checks for tool calls
             {
-                "use_tools": "answer_with_tools",
-                "answer_direct": "answer_directly"
+                "tools": "tools",  # If tools called, execute them
+                END: "extract_answer",  # No tools, go straight to answer
             }
         )
         
-        # From answer_with_tools, either use tools or end
-        graph.add_conditional_edges(
-            "answer_with_tools",
-            tools_condition,
-            {
-                "tools": "tools",
-                END: END,
-            }
-        )
+        # After tools execute, analyze the results
+        graph.add_edge("tools", "analyze_results")
         
-        # From answer_directly, just end (no tool checking after direct answer)
-        graph.add_edge("answer_directly", END)
-        
-        # After tools, check if more tools are needed or provide final answer
-        graph.add_node("provide_final_answer", self.provide_final_answer)
+        # After analysis, decide next step
         graph.add_conditional_edges(
-            "tools",
-            tools_condition,
+            "analyze_results",
+            self.route_after_analysis,
             {
-                "tools": "tools",  # Allow multiple tool cycles
-                END: "provide_final_answer",
+                "extract_answer": "extract_answer",  # Ready to answer
+                "call_model": "call_model",  # Need more tools
             }
         )
         
-        # Allow provide_final_answer to also use more tools if needed
-        graph.add_conditional_edges(
-            "provide_final_answer",
-            tools_condition,
-            {
-                "tools": "tools",  # Can go back to tools for more searches
-                END: END,
-            }
-        )
+        # After extracting answer, we're done
+        graph.add_edge("extract_answer", END)
         
         # Compile the graph
         self.compiled_graph = graph.compile()
-        # self.compiled_graph.get_graph().draw_mermaid_png()
     
     def __call__(self, question: str, task_id: Optional[str] = None) -> str:
         """Process question using LangGraph workflow"""
         print(f"Processing: {question[:50]}...")
         
-        # Create initial state following the new structure
+        # Create initial state with just the question as a message
         initial_state = {
-            "question": question,
+            "messages": [HumanMessage(content=question)],
             "task_id": task_id,
             "requires_file": None,
-            "file_content": None,
-            "search_attempts": 0,
-            "final_answer": None,
-            "messages": []
+            "final_answer": None
         }
         
         try:
-            # Run the graph with recursion limit configuration and Langfuse tracing
-            config = {"recursion_limit": 25}  # Higher limit for multiple tool usage
+            # Run the graph with Langfuse tracing
+            config = {"recursion_limit": 25}
             
             # Add Langfuse callback handler if available
             if self.langfuse_handler:
@@ -525,8 +347,8 @@ Final answer only:"""
             
             result = self.compiled_graph.invoke(initial_state, config=config)
             
-            # Extract the final answer
-            answer = self.extract_final_answer(result)
+            # Extract the final answer from the state
+            answer = result.get("final_answer", "No answer found")
             print(f"Answer: {answer[:50]}...")
             
             # Log the complete conversation for review
@@ -577,10 +399,18 @@ if __name__ == "__main__":
             print("✅ Test passed! The agent correctly answered the question.")
         else:
             print("❌ Test failed. Expected the answer to contain 'Louvrier'.")
+
+        answer = agent("In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?")
+        print(f"Answer: {answer}")
+
+        if answer == "3":
+            print("✅ Test passed! The agent correctly answered the question.")
+        else:
+            print("❌ Test failed. Expected the answer to be '3'.")
         
             
     except Exception as e:
         import traceback
         print(f"❌ Test failed with error: {e}")
         print("Full traceback:")
-        traceback.print_exc()
+        traceback.print_exc()

src/tools.py

@@ -28,11 +28,19 @@ from langchain_core.tools import Tool
 from langchain_google_community import GoogleSearchAPIWrapper
 from langchain_community.tools import DuckDuckGoSearchResults
 from langchain_community.document_loaders import WebBaseLoader
+from simpleeval import simple_eval
 
 
 @tool
 def wikipedia_search(query: str) -> str:
-    """Search Wikipedia for information. Use this for factual information and encyclopedic content.
+    """Search Wikipedia for factual information and encyclopedic content.
+    
+    Use this tool when you need:
+    - Historical facts, dates, or events
+    - Biographical information about people
+    - Definitions and explanations of concepts
+    - General factual knowledge
+    - Information about places, organizations, or scientific topics
     
     Args:
         query: The search query."""
@@ -60,25 +68,98 @@ def wikipedia_search(query: str) -> str:
 
 @tool  
 def youtube_search(query: str) -> str:
-    """Search YouTube for videos and get video information. Use this when you need YouTube-specific content."""
+    """Search YouTube for videos and get video information, or extract information from a specific YouTube URL.
+    
+    Use this tool when:
+    - The question explicitly mentions YouTube or videos
+    - You need to find video content on a specific topic
+    - You have a YouTube URL and need to get information about it
+    - Looking for tutorials, demonstrations, or visual content
+    - The user asks about video creators or channels
+    
+    When analyzing a YouTube URL, this tool provides:
+    - Video title, channel, duration, views, upload date
+    - Full description (contains key information about video content)
+    - Tags (keywords related to the video)
+    
+    IMPORTANT: Use the title, description, and tags to answer questions about the video content.
+    The description often contains detailed information about what happens in the video.
+    
+    Args:
+        query: The YouTube search query or direct YouTube URL."""
     try:
-        from youtubesearchpython import VideosSearch
-        search = VideosSearch(query, limit=3)
-        results = search.result()
-        
-        output = f"YouTube search results for '{query}':\n"
-        for video in results['result']:
-            output += f"- {video['title']} by {video['channel']['name']}\n"
-            output += f"  Duration: {video['duration']}, Views: {video['viewCount']['text']}\n"
-            output += f"  URL: {video['link']}\n\n"
+        import yt_dlp
         
-        return output
+        # Check if query is a direct YouTube URL
+        if 'youtube.com' in query or 'youtu.be' in query:
+            # Extract information from the specific video
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'extract_flat': False,
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(query, download=False)
+                
+                output = f"YouTube Video Information:\n"
+                output += f"Title: {info.get('title', 'N/A')}\n"
+                output += f"Channel: {info.get('uploader', 'N/A')}\n"
+                output += f"Duration: {info.get('duration', 0)} seconds\n"
+                output += f"Views: {info.get('view_count', 'N/A')}\n"
+                output += f"Upload Date: {info.get('upload_date', 'N/A')}\n\n"
+                
+                # Get full description (contains key information about video content)
+                description = info.get('description', 'N/A')
+                if description and description != 'N/A':
+                    output += f"Description:\n{description}\n\n"
+                else:
+                    output += f"Description: Not available\n\n"
+                
+                # Add tags if available (help identify content)
+                tags = info.get('tags', [])
+                if tags:
+                    output += f"Tags: {', '.join(tags[:10])}\n"
+                
+                return output
+        else:
+            # Search for videos
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'extract_flat': True,
+            }
+            
+            search_query = f"ytsearch3:{query}"
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                results = ydl.extract_info(search_query, download=False)
+                
+                output = f"YouTube search results for '{query}':\n"
+                for entry in results.get('entries', []):
+                    output += f"- {entry.get('title', 'N/A')} by {entry.get('uploader', 'N/A')}\n"
+                    output += f"  Duration: {entry.get('duration', 0)} seconds\n"
+                    output += f"  URL: {entry.get('url', 'N/A')}\n\n"
+                
+                return output
     except Exception as e:
         return f"YouTube search failed: {str(e)}"
 
 @tool
 def web_search(query: str) -> str:
-    """Search the web for a query and return the first results.
+    """Search the web for current information and load full webpage content.
+    
+    Use this tool when:
+    - You need current/recent information not available in Wikipedia
+    - Looking for news, updates, or time-sensitive content
+    - Wikipedia doesn't have the specific information
+    - Need detailed content from specific web pages
+    - Looking for niche or specialized information
+    
+    This tool performs a web search and loads the full content of the top 3 results.
+
+    If the question refers to an article, use this tool to query for the specific article mentioned in the question.
+    
     Args:
         query: The search query."""
 
@@ -101,7 +182,16 @@ def web_search(query: str) -> str:
 
 @tool
 def decode_text(text: str) -> str:
-    """Decode or reverse text that might be encoded backwards or in other ways."""
+    """Decode or reverse text that might be encoded backwards or in other ways.
+    
+    Use this tool when:
+    - Text appears to be reversed or encoded
+    - Words are spelled backwards
+    - The question mentions "decode", "reverse", or "backwards"
+    - Text looks scrambled or encoded
+    
+    Args:
+        text: The text to decode or reverse."""
     try:
         # Try reversing words
         words = text.split()
@@ -116,10 +206,49 @@ def decode_text(text: str) -> str:
         return f"Text decoding failed: {str(e)}"
 
 
+@tool
+def evaluate_computation(expression: str) -> str:
+    """Safely evaluate mathematical expressions and computations.
+    
+    Use this tool when:
+    - You need to perform mathematical calculations
+    - The question involves arithmetic operations (+, -, *, /, **, %)
+    - You need to evaluate numeric expressions
+    - Computing formulas or mathematical operations
+    
+    Supports:
+    - Basic arithmetic: +, -, *, /, **, %
+    - Mathematical functions: abs, max, min, round, sum
+    - Comparison operators: <, <=, >, >=, ==, !=
+    - Logical operators: and, or, not
+    - Constants: True, False, None
+    
+    Args:
+        expression: The mathematical expression to evaluate (e.g., "2 + 2", "3.14 * 5**2")."""
+    try:
+        result = simple_eval(expression)
+        return f"Result of '{expression}': {result}"
+    except Exception as e:
+        return f"Computation failed for '{expression}': {str(e)}"
+
+
 @tool
 def download_and_process_file(task_id: str) -> str:
     """Download and process a file from the GAIA API using the task_id.
-    Use this tool when detect_file_requirement indicates a file is needed."""
+    
+    Use this tool when:
+    - The question explicitly mentions an "attached file" or "attachment"
+    - The question says "see the attached", "I've attached", "attached as", etc.
+    - A task_id has been provided for file access
+    
+    This tool downloads and processes various file types including:
+    - PDF, Word, PowerPoint, Excel documents
+    - Images (extracts text via OCR)
+    - Audio files (transcribes speech to text)
+    - CSV, text, and markdown files
+    
+    Args:
+        task_id: The GAIA task ID used to download the file."""
     api_url = "https://agents-course-unit4-scoring.hf.space"
     try:
         # Download file from API