add read_jsonl, update websearch and calculate tools

agent.py

@@ -1,6 +1,7 @@
 import os
 import ast
 import re
+import json
 import operator as op
 from pathlib import Path
 from typing import List, TypedDict, Annotated, Optional
@@ -38,37 +39,51 @@ YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma sepa
 
 @tool
 def calculate(expr: str) -> str:
-    """Evaluate a simple math expression and return the result."""
-    _OPERATORS = {
-        ast.Add: op.add,
-        ast.Sub: op.sub,
-        ast.Mult: op.mul,
-        ast.Div: op.truediv,
-        ast.Pow: op.pow,
-        ast.USub: op.neg,
-    }
-    def _eval(node):
-        if isinstance(node, ast.Num):
-            return node.n
-        elif isinstance(node, ast.BinOp):
-            return _OPERATORS[type(node.op)](_eval(node.left), _eval(node.right))
-        elif isinstance(node, ast.UnaryOp):
-            return _OPERATORS[type(node.op)](_eval(node.operand))
-        else:
-            raise ValueError(f"Unsupported expression: {ast.dump(node)}")
+    """Evaluate a math expression. Supports basic operations (+,-,*,/,**) and functions (sin,cos,sqrt,etc)."""
     try:
-        parsed = ast.parse(expr, mode='eval').body
-        result = _eval(parsed)
-        return str(result)
+        import math
+        # Create safe math namespace
+        safe_dict = {
+            k: v for k, v in math.__dict__.items() 
+            if not k.startswith('_')
+        }
+        safe_dict.update({
+            'abs': abs,
+            'round': round,
+            'max': max,
+            'min': min
+        })
+        
+        # Evaluate expression in safe environment
+        result = eval(expr, {"__builtins__": {}}, safe_dict)
+        return str(float(result))
     except Exception as e:
         return f"Error calculating expression: {e}"
 
 @tool
 def web_search(query: str) -> str:
-    """Search the web for current information using DuckDuckGo."""
+    """Search the web using DuckDuckGo and SerpAPI for comprehensive results."""
     try:
         from langchain.utilities import DuckDuckGoSearchRun
-        return DuckDuckGoSearchRun().run(query)
+        from langchain_community.utilities import SerpAPIWrapper
+        
+        # Try multiple search engines
+        results = []
+        
+        # DuckDuckGo search
+        ddg = DuckDuckGoSearchRun()
+        ddg_results = ddg.run(query)
+        results.append(ddg_results)
+        
+        # SerpAPI search if API key available
+        if os.getenv("SERPAPI_API_KEY"):
+            serpapi = SerpAPIWrapper()
+            serp_results = serpapi.run(query)
+            results.append(serp_results)
+            
+        # Combine and summarize results
+        combined_results = "\n\n".join(results)
+        return combined_results[:1000]  # Limit length for better handling
     except Exception as e:
         return f"Error performing web search: {e}"
 
@@ -150,18 +165,25 @@ def transcribe_audio(audio_path: str) -> str:
         return "\n".join(doc.page_content for doc in docs)
     except Exception as e:
         return f"Error transcribing audio: {e}"
-    
-    
-#o3_mini = init_chat_model("openai:o3-mini", temperature=0)
-#claude_sonnet = init_chat_model(anthropic:claude-3-5-sonnet-latest", temperature=0)
-#gemini_2_flash = init_chat_model("google_vertexai:gemini-2.0-flash", temperature=0)
 
 
+@tool
+def read_jsonl(jsonl_path: str) -> str:
+    """Read and extract data from a JSONL (JSON Lines) file."""
+    try:
+        data = []
+        with open(jsonl_path, 'r', encoding='utf-8') as file:
+            for line in file:
+                data.append(json.loads(line))
+        return json.dumps(data, indent=2)
+    except Exception as e:
+        return f"Error reading JSONL file: {e}"
 
+# Update tools list
 tools: List[StructuredTool] = [
     calculate, web_search, wikipedia_search, image_recognition,
     read_pdf, read_csv, read_spreadsheet, transcribe_audio,
-    youtube_transcript_tool, youtube_transcript_api
+    youtube_transcript_tool, youtube_transcript_api, read_jsonl  # Add read_jsonl
 ]
 
 class AgentState(TypedDict):