Enhance README with detailed Google Custom Search API cost information and automatic fallback to DuckDuckGo. Introduce a new TEST_QUESTIONS.md file with comprehensive sample queries for various functionalities, including math, web search, and algorithms. Update agent configuration to improve news query handling and enhance calculator capabilities with natural language processing for percentages, divisions, and geometry queries. Improve logging for better debugging and user experience.

README.md

@@ -252,6 +252,41 @@ meeTARA Agent supports multiple search providers for web searches:
 - Search Engine ID is not sensitive (designed to be public)
 - No risk of hackers accessing your credentials through the Space URL
 
+### 💰 Google Custom Search API - Cost Information
+
+**Free Tier:**
+- ✅ **100 queries per day** - **FREE** (no credit card needed initially, but billing account required)
+- ⚠️ **Billing account required** even for free tier (you won't be charged for first 100/day)
+
+**Automatic Fallback (When Quota Exceeded):**
+- 🔄 **Automatic fallback to DuckDuckGo** when Google quota is exceeded (429 or quota-related 403 errors)
+- DuckDuckGo is **free and unlimited** (no API key required)
+- Seamless transition - users won't notice interruption
+- Logs will indicate: `⚠️ Google Search quota exceeded → Auto-fallback to DuckDuckGo`
+- **No code changes needed** - fallback happens automatically
+- **No paid subscription required** - system gracefully handles quota limits
+
+**Paid Tier (Optional - Beyond 100 queries/day):**
+- 💵 **$5 per 1,000 queries** (after free tier)
+- 📊 **Maximum**: 10,000 queries per day (requires billing enabled)
+- **Note**: If you don't set up paid billing, the system automatically falls back to DuckDuckGo after 100 queries/day
+
+**Cost Examples:**
+- **100 queries/day** (3,000/month): **FREE** ✅ (auto-fallback after quota)
+- **500 queries/day** (15,000/month): ~$70/month (14,000 additional queries × $5/1,000 = $70) OR use DuckDuckGo (free)
+- **1,000 queries/day** (30,000/month): ~$145/month (29,000 additional queries × $5/1,000 = $145) OR use DuckDuckGo (free)
+- **10,000 queries/day** (300,000/month): ~$1,485/month (299,000 additional queries × $5/1,000 = $1,485) OR use DuckDuckGo (free)
+
+**Comparison with DuckDuckGo:**
+- **DuckDuckGo**: ✅ **FREE, unlimited queries** (automatic fallback - excellent results!)
+- **Google Custom Search**: Free for 100/day, then $5 per 1,000 queries (optional upgrade)
+
+**Recommendation:**
+- ✅ **For Development/Testing**: DuckDuckGo is perfect (free, unlimited, good results)
+- 💰 **For Production**: Use Google API only if you need better results AND can afford $5 per 1,000 queries
+- ✅ **Current Setup**: Hybrid approach - tries Google first, automatically falls back to DuckDuckGo when quota exceeded (best of both worlds!)
+- 🎯 **Best Practice**: Let the system automatically fallback to DuckDuckGo - no paid subscription needed unless you specifically need Google's superior results
+
 ### Enabling Agent Mode
 
 Agent Mode is **always enabled by default**. Just select your preferred model from the dropdown and ask questions:
@@ -261,6 +296,25 @@ Agent Mode is **always enabled by default**. Just select your preferred model fr
 - **Combined**: *"What's 2^10 and search for news about quantum computing in 2025"*
 - **Real-time**: *"Tell me current US stock trends and present day crypto prices"*
 
+### 📝 Sample Test Questions
+
+For comprehensive test questions covering all areas (Math, Web Search, Current Events, Stock Market, Technology, etc.), see **[TEST_QUESTIONS.md](TEST_QUESTIONS.md)**.
+
+The test questions file includes:
+- 🧮 **Math & Calculator queries** (basic, geometry, advanced)
+- 📰 **Current Events & News** (today's news, specific topics, global news)
+- 💼 **Stock Market & Financial** (market trends, specific markets, combined queries)
+- 💻 **Technology & AI** (AI trends, tech news, emerging technologies)
+- 🎓 **Educational & Research** (science, academic topics, general knowledge)
+- 🔄 **Combined Queries** (Math + Search in one question)
+- 🌍 **Real-time Information** (time-sensitive queries, specific dates/years)
+- 🎯 **Edge Cases** (complex multi-part questions, natural language variations)
+
+**Quick Start Examples:**
+- *"Calculate 25 * 48"* - Tests calculator tool
+- *"Search for latest AI trends"* - Tests web search tool
+- *"What's 2^10 and also search for current stock market trends"* - Tests combined tool usage
+
 ## 🚀 Usage
 
 1. Click "Initialize" to load meeTARA (first time may take a few minutes to download models)

TEST_QUESTIONS.md

@@ -0,0 +1,696 @@
+# meeTARA Agent - Sample Test Questions
+
+This file contains sample questions organized by category to test all meeTARA Agent capabilities (Calculator + Web Search + AI Processing).
+
+---
+
+## 🧮 Math & Calculator Queries
+
+### Basic Calculations
+- "Calculate 25 * 48"
+- "What's 15% of 340?"
+- "Solve: 2^10 + 3^5"
+- "What is 144 divided by 12?"
+- "Multiply 123 by 456"
+- "What is 999 divided by 3?"
+- "Add 50, 25, and 75"
+- "Compute 1000 - 456 + 234 * 3"
+- "Solve: (12 + 8) * (15 - 7)"
+- "What is 2^8? Also calculate 3^4"
+
+### Percentage & Division
+- "What's 15% of 340?"
+- "Calculate 25% of 200"
+- "What is 20% times 150?"
+- "999 divided by 3"
+- "100 divided by 4"
+- "50 ÷ 2"
+- "What is 144 / 12?"
+
+### Geometry & Formulas
+- "Find the surface area of a rectangular prism with dimensions: length = 6 cm, width = 4 cm, height = 5 cm"
+- "Calculate the area of a circle with radius 7 cm"
+- "What's the volume of a cylinder with radius 5 cm and height 10 cm?"
+- "Find the perimeter of a rectangle with length 12 cm and width 8 cm"
+- "Calculate the circumference of a circle with radius 10 cm"
+- "What is the volume of a sphere with radius 5 cm?"
+
+### Powers & Roots
+- "What is the square root of 256?"
+- "Calculate square root of 144"
+- "Find the square root of 16"
+- "What is 2^8?"
+- "Calculate 2 to the power of 10"
+- "What's 3^4?"
+- "Find cube root of 27"
+- "Calculate cbrt(8)"
+
+### Scientific Functions
+
+#### Trigonometry
+- "Calculate sine of pi/2"
+- "What is sin(90)?" (Note: expects radians, but natural language may use degrees)
+- "Find cosine of 0"
+- "What is cos(pi/2)?"
+- "Calculate tangent of pi/4"
+- "What is tan(45)?"
+- "Find arcsin of 1"
+- "Calculate arccos(0)"
+- "What is arctan(1)?"
+- "Sine of pi/2"
+
+#### Hyperbolic Functions
+- "Calculate sinh(2)"
+- "What is cosh(3)?"
+- "Find tanh(1)"
+- "Compute asinh(1.5)"
+
+#### Logarithms
+- "What is log(10)?"
+- "Calculate natural log of e"
+- "Find ln(e)"
+- "What is log base 10 of 100?"
+- "Calculate log10(100)"
+- "What's log base 2 of 8?"
+- "Find log2(8)"
+- "What is exponential of 2?"
+- "Calculate exp(2)"
+- "What's e^2?"
+
+#### Advanced Functions
+- "Calculate factorial of 5"
+- "What is 5!?"
+- "Find factorial(5)"
+- "Calculate gcd of 48 and 18"
+- "What is gcd(48, 18)?"
+- "Find greatest common divisor of 48 and 18"
+- "Calculate lcm of 12 and 18"
+- "What is lcm(12, 18)?"
+- "Find least common multiple of 12 and 18"
+- "What is floor(3.7)?"
+- "Calculate ceil(3.2)"
+- "Find trunc(3.9)"
+- "Convert 180 degrees to radians"
+- "What is degrees(pi)?"
+- "Calculate radians(180)"
+
+---
+
+## 🧬 Algorithms & Data Structures (Calculator)
+
+### Fibonacci Sequence
+- "Calculate fibonacci of 10"
+- "What is the 10th fibonacci number?"
+- "Find fibonacci(10)"
+- "What is fib(10)?"
+- "Calculate the 15th fibonacci number"
+- "Find fibonacci of 20"
+
+### Permutations (nPr)
+- "Calculate permutations of 5 taken 3"
+- "What is npr(5, 3)?"
+- "Find 5P3"
+- "Calculate npr for 5 taken 3"
+- "What are the permutations of 5 items taken 3 at a time?"
+- "Compute perm(5, 3)"
+- "Calculate number of ways to arrange 5 items taken 3 at a time"
+
+### Combinations (nCr)
+- "Calculate combinations of 5 choose 3"
+- "What is ncr(5, 3)?"
+- "Find 5C3"
+- "Calculate ncr for 5 choose 3"
+- "What are the combinations of 5 items choose 3?"
+- "Compute comb(5, 3)"
+- "Calculate choose(5, 3)"
+- "How many ways to choose 3 items from 5?"
+
+### Base Conversions
+- "Convert 255 to binary"
+- "What is 255 in binary?"
+- "Calculate bin(255)"
+- "Find binary of 255"
+- "Convert 255 to hexadecimal"
+- "What is 255 in hex?"
+- "Calculate hex(255)"
+- "Find hexadecimal of 255"
+- "Convert 255 to octal"
+- "What is 255 in octal?"
+- "Calculate oct(255)"
+- "Find octal of 255"
+- "Convert 1010 from binary to decimal"
+- "What is hex('ff') in decimal?"
+- "Convert 377 from octal to decimal"
+
+### Factorial & Advanced
+- "Calculate factorial of 5"
+- "What is 5!?"
+- "Find factorial(5)"
+- "Calculate factorial of 10"
+- "What is 7!?"
+- "Calculate factorial(20)"
+
+### Complexity & Analysis (Detection Keywords)
+- "What is the time complexity of binary search?"
+- "Explain big O notation for merge sort"
+- "What is the space complexity of quick sort?"
+- "Analyze the complexity of bubble sort"
+- "What is the time complexity of binary tree traversal?"
+- "Explain big O for hash table operations"
+- "What is the complexity of heap insert?"
+- "Analyze tree height calculation complexity"
+- "What is the time complexity of graph traversal?"
+- "Explain complexity analysis for array operations"
+
+### Data Structure Operations (Detection Keywords)
+- "Calculate binary tree height with 15 nodes"
+- "What is the depth of a tree with 31 nodes?"
+- "Find the number of leaves in a binary tree"
+- "Explain hash table time complexity"
+- "What is the complexity of trie search?"
+- "Analyze heap operations complexity"
+- "What is binary search time complexity?"
+- "Explain linear search complexity"
+- "Calculate tree nodes for a given height"
+- "What is the complexity of stack operations?"
+
+### Algorithm Concepts
+- "Explain recursion depth for fibonacci"
+- "What is recursive complexity for factorial?"
+- "Analyze dynamic programming complexity"
+- "What is greedy algorithm time complexity?"
+- "Explain backtracking space complexity"
+- "What is divide and conquer complexity?"
+- "Analyze sorting algorithm complexity"
+- "What is searching algorithm complexity?"
+
+---
+
+## 📰 Current Events & News (Web Search)
+
+**Note**: meeTARA Agent is configured to extract ACTUAL NEWS HEADLINES and CONTENT, not just descriptions of news sources. The agent filters out meta pages about news websites and focuses on real headlines and stories.
+
+### Today's News (Headlines Extraction)
+- "What are today's top news headlines?"
+- "What happened in the news today?"
+- "Tell me the latest breaking news"
+- "Search for today's most important news stories"
+- "What are the latest news headlines?"
+- "Show me today's breaking news"
+- "What's happening in the news right now?"
+
+### Specific Topics
+- "What are the latest AI developments in 2025?"
+- "Search for news about quantum computing breakthroughs"
+- "What are current climate change updates?"
+- "Latest space exploration news"
+- "What's happening in renewable energy?"
+- "Current updates on electric vehicles"
+
+### Global News
+- "What are the latest global news stories?"
+- "Search for international news today"
+- "Tell me about current world events"
+
+---
+
+## 💼 Stock Market & Financial (Web Search)
+
+### Market Trends
+- "What is the current US stock market trend?"
+- "What are today's stock market trends?"
+- "Current stock market performance"
+- "How is the S&P 500 performing today?"
+- "What are the latest stock market trends?"
+- "Search for current market conditions"
+
+### Specific Markets
+- "What is the current oil price?"
+- "Tell me present day crypto prices"
+- "Current Bitcoin and Ethereum prices"
+- "What are the latest NASDAQ trends?"
+- "How is the Dow Jones performing?"
+- "Search for current commodity prices"
+- "What are today's forex rates?"
+
+### Combined Market Queries
+- "What are current US stock market trends and oil market prices?"
+- "Search for stock market news and cryptocurrency trends"
+- "Tell me about current stock trends and present day crypto prices"
+- "What are today's market trends and commodity prices?"
+
+---
+
+## 💻 Technology & AI (Web Search)
+
+### AI Trends
+- "What are the latest AI trends in 2025?"
+- "Search for latest AI developments"
+- "Current trends in artificial intelligence"
+- "What's new in machine learning?"
+- "Latest developments in neural networks"
+- "What are the current AI breakthroughs?"
+- "Search for recent AI research findings"
+
+### Tech News
+- "Latest technology news"
+- "What are current tech industry trends?"
+- "Search for quantum computing updates"
+- "Latest developments in cloud computing"
+- "What's new in software development?"
+- "Current trends in cybersecurity"
+
+### Emerging Technologies
+- "Search for latest developments in quantum computing"
+- "What are the newest trends in blockchain technology?"
+- "Latest updates on 5G and 6G networks"
+- "Current progress in autonomous vehicles"
+
+---
+
+## 🎓 Educational & Research (Web Search)
+
+### Science
+- "Latest research on climate change"
+- "Recent discoveries in space exploration"
+- "What are the newest medical breakthroughs?"
+- "Current research on renewable energy"
+- "Latest findings in marine biology"
+- "Recent discoveries in astronomy"
+
+### Academic Topics
+- "Search for latest research on quantum physics"
+- "What are recent findings in neuroscience?"
+- "Latest developments in biotechnology"
+- "Current research on artificial intelligence ethics"
+- "Recent studies on renewable energy"
+
+### General Knowledge
+- "Search for educational content about ancient civilizations"
+- "What are the latest findings in archaeology?"
+- "Current research on human psychology"
+
+---
+
+## 🔬 Science & Health (Web Search)
+
+### Health & Medicine
+- "What are the latest medical breakthroughs?"
+- "Search for current health research"
+- "Latest developments in cancer treatment"
+- "What's new in vaccine research?"
+- "Current trends in mental health research"
+
+### Science News
+- "Latest scientific discoveries"
+- "What are recent space exploration achievements?"
+- "Current research on climate solutions"
+- "Latest findings in physics"
+- "Recent breakthroughs in chemistry"
+
+---
+
+## 🏢 Business & Economics (Web Search)
+
+### Business News
+- "What are current business trends?"
+- "Latest corporate news"
+- "Search for startup news"
+- "What are today's business headlines?"
+- "Current trends in entrepreneurship"
+
+### Economic Data
+- "What are current economic conditions?"
+- "Search for latest economic indicators"
+- "Tell me about present day economic conditions"
+- "What are current inflation rates?"
+- "Latest GDP growth data"
+
+---
+
+## 🌍 Real-time Information (Web Search)
+
+### Time-Sensitive Queries
+- "What's happening right now in the stock market?"
+- "Current trends as of now"
+- "Present day market conditions"
+- "What are this week's tech trends?"
+- "This month's biggest news stories"
+- "What happened this year in AI?"
+- "Search for right now's top stories"
+- "As of now, what are the trends?"
+
+### Specific Dates/Years
+- "Latest news from 2025"
+- "What are the trends in 2026?"
+- "Search for 2025 technology predictions"
+- "Current 2025 market analysis"
+- "What's happening in January 2025?"
+
+---
+
+## 🔄 Combined Queries (Math + Search)
+
+### Business + Finance
+- "What are current market trends and stock prices? Also calculate ROI for an investment of $5000 with 8% return"
+- "If a company's stock price is $150 and it increased by 15%, what's the new price? Also search for current market trends"
+- "Search for today's stock market performance. Also calculate: if I invest $10,000 and it grows by 5%, what's my new total?"
+- "Find current commodity prices and calculate 15% of 5000"
+
+### Tech + Math
+- "Search for latest AI trends and calculate: if AI adoption grows by 25% annually, what's the growth after 5 years from a base of 100?"
+- "Calculate 100 * 45 and also search for current stock market trends"
+- "What's 2^8? Also tell me the latest AI news"
+- "Search for quantum computing updates and calculate factorial of 5"
+- "Find latest tech trends and calculate pow(2, 10)"
+
+### Scientific Calculator + Search
+- "Calculate sin(pi/2) and search for latest mathematics research"
+- "What is factorial(10)? Also find current computer science news"
+- "Calculate fibonacci(15) and search for algorithm research"
+- "Find permutations of 10 taken 3. Also search for combinatorics news"
+- "Calculate gcd(48, 18) and search for number theory developments"
+- "What is log10(1000)? Also find latest scientific discoveries"
+
+### Algorithms + Search
+- "Calculate fibonacci(20) and search for latest algorithm research"
+- "Find ncr(10, 3) and search for combinatorics applications"
+- "What is npr(5, 3)? Also find permutation algorithms in practice"
+- "Calculate factorial(7) and search for factorial applications"
+- "Find binary of 255 and search for binary computation methods"
+
+### Current Events + Math
+- "What's today's stock market performance? Also, if I invest $10,000 and it grows by 5%, what's my new total?"
+- "Search for today's crypto prices and calculate: if Bitcoin is $50,000 and I have 0.5 BTC, what's my total value?"
+- "Calculate 50 * 20 and search for today's cryptocurrency prices"
+- "What are today's news headlines? Also calculate 25 * 48"
+
+### Real-world Problems
+- "If a portfolio worth $100,000 grows by 12% this year, what's the new value? Also search for current investment trends"
+- "Calculate compound interest on $10,000 at 5% for 3 years, and search for investment trends"
+- "Search for current market conditions and calculate: if a stock increases by 8% from $200, what's the new price?"
+- "Find present day economic conditions and calculate 15% of 2500"
+
+---
+
+## 🎯 Edge Cases & Complex Queries
+
+### Complex Detection
+- "Calculate 100 * 5 and search for latest trends"
+- "What's 25 * 48? Also tell me about present day economic conditions"
+- "Solve 2^10 and search for current global market trends"
+
+### Multi-Part Questions
+- "Calculate the surface area of a 6x4x5 cm box. Also search for latest technology trends"
+- "What's 15% of 340? Also tell me about current stock market performance"
+- "Find the area of a circle with radius 7 cm. Also search for today's news"
+
+### Natural Language Variations
+- "Can you compute 123 * 456? Also find me the latest AI news"
+- "I need to know what 25 * 48 equals. Also search for current market trends"
+- "Please calculate 2^10 and tell me about present day trends"
+
+---
+
+## 🔍 Testing Specific Features
+
+### Calculator Detection Patterns - Basic Math
+- "What is 25 * 48?"
+- "Compute 100 / 4"
+- "Solve: 50 + 25 - 10"
+- "Calculate 2^8"
+- "What's the square root of 144?"
+- "Multiply 15 by 20"
+- "Divide 1000 by 25"
+- "What's 15% of 340?"
+- "999 divided by 3"
+
+### Calculator Detection Patterns - Scientific Functions
+- "Calculate sin(pi/2)"
+- "What is cosine of 0?"
+- "Find tangent of pi/4"
+- "Calculate log10(100)"
+- "What is natural log of e?"
+- "Find factorial of 5"
+- "Calculate sqrt(144)"
+- "What is pow(2, 8)?"
+- "Convert 180 degrees to radians"
+
+### Calculator Detection Patterns - Algorithms
+- "Calculate fibonacci of 10"
+- "What is npr(5, 3)?"
+- "Find ncr(10, 3)"
+- "Calculate permutations of 5 taken 3"
+- "What are combinations of 10 choose 3?"
+- "Convert 255 to binary"
+- "What is 255 in hexadecimal?"
+- "Find binary of 128"
+
+### Calculator Detection Patterns - Geometry
+- "Find the surface area of a rectangular prism with length = 6, width = 4, height = 5"
+- "Calculate the area of a circle with radius 7"
+- "What's the volume of a cylinder with radius 5 and height 10?"
+
+### Web Search Detection Patterns
+- "Search for latest AI trends"
+- "Find current stock market news"
+- "Tell me about today's events"
+- "What are present day conditions?"
+- "Search for 2025 technology predictions"
+- "Tell me the latest news"
+- "What's happening right now?"
+- "Current trends in technology"
+- "Presently, what are the top stories?"
+- "What are today's top news headlines?"
+- "Search for latest breaking news"
+- "Tell me about present day market conditions"
+
+### Combined Detection - Basic Math + Search
+- "Calculate 100 * 5 and search for latest trends"
+- "What's 25 * 48? Also find me current stock prices"
+- "Solve 2^10 and tell me about today's news"
+- "Compute 50 * 20 and search for latest AI developments"
+- "Calculate 15% of 340 and search for current trends"
+
+### Combined Detection - Scientific Calculator + Search
+- "Calculate sin(pi/2) and search for latest mathematics news"
+- "What is factorial(10)? Also find algorithm research"
+- "Calculate fibonacci(15) and search for computer science developments"
+- "Find ncr(10, 3) and search for combinatorics applications"
+- "Convert 255 to binary and search for binary computation methods"
+
+### Combined Detection - Multiple Tools
+- "Calculate 25 * 48, factorial of 5, and search for latest trends"
+- "What's fibonacci(10) and npr(5, 3)? Also find algorithm news"
+- "Calculate sqrt(144) and log10(100). Also search for current events"
+
+---
+
+## 📊 Performance Test Questions
+
+### Quick Tests - Basic
+1. "Calculate 25 * 48"
+2. "Search for latest AI trends"
+3. "What's 2^10 and also search for current stock market trends"
+
+### Quick Tests - Scientific Calculator
+1. "Calculate sin(pi/2)"
+2. "What is factorial(5)?"
+3. "Calculate fibonacci(10)"
+
+### Quick Tests - Algorithms
+1. "Calculate npr(5, 3)"
+2. "What is ncr(10, 3)?"
+3. "Convert 255 to binary"
+
+### Comprehensive Tests - Basic Math + Search
+1. "Find the surface area of a rectangular prism with dimensions: length = 6 cm, width = 4 cm, height = 5 cm. Also search for today's technology news"
+2. "Calculate compound interest on $10,000 at 5% for 3 years. Also tell me about present day market conditions"
+3. "What are current US stock market trends and oil market prices? Also calculate 100 * 45"
+
+### Comprehensive Tests - Scientific Calculator + Search
+1. "Calculate sin(pi/2), factorial(10), and gcd(48, 18). Also search for latest mathematics research"
+2. "Find fibonacci(15) and npr(5, 3). Also search for algorithm applications"
+3. "Calculate log10(1000), sqrt(144), and pow(2, 8). Also find current scientific developments"
+
+### Comprehensive Tests - Algorithms + Search
+1. "Calculate fibonacci(20), factorial(7), and ncr(10, 3). Also search for combinatorics research"
+2. "Find permutations of 10 taken 4 and combinations of 10 choose 4. Also search for algorithm complexity analysis"
+3. "Convert 255 to binary, hex, and octal. Also search for base conversion applications"
+
+### Edge Case Tests
+1. "Calculate 25 * 48, 15% of 340, and 999 divided by 3"
+2. "Calculate sin(pi/2), cos(0), tan(pi/4), and log10(100)"
+3. "Find fibonacci(10), npr(5, 3), ncr(5, 3), and factorial(5)"
+4. "Calculate sqrt(144), pow(2, 8), gcd(48, 18), and lcm(12, 18)"
+5. "Convert 255 to binary, hex, and octal. Also calculate factorial of 5"
+
+---
+
+## 🎓 Example Responses Expected
+
+### Example 1: Basic Math + Search
+When you ask: *"Calculate 25 * 48 and search for latest AI trends"*
+
+meeTARA should:
+1. ✅ Detect calculator need (matches "25 * 48")
+2. ✅ Detect web search need (matches "latest" + "trends")
+3. ✅ Execute calculator: `25 * 48 = 1200`
+4. ✅ Execute web search: Get current AI trends from Google/DuckDuckGo
+5. ✅ Feed both results to AI model
+6. ✅ Generate structured response:
+   ```
+   🎯 Answer: 25 × 48 = 1200. Based on recent search results...
+   📊 Details: Latest AI trends in 2025 include...
+   ⚡ Steps: [Calculation steps + key findings]
+   💡 Note: [Additional insights]
+   ```
+
+### Example 2: Scientific Calculator
+When you ask: *"Calculate sin(pi/2) and factorial of 5"*
+
+meeTARA should:
+1. ✅ Detect calculator need (matches "sin" and "factorial")
+2. ✅ Execute calculator: `sin(pi/2) = 1.0` and `factorial(5) = 120`
+3. ✅ Feed results to AI model
+4. ✅ Generate structured response:
+   ```
+   🎯 Answer: sin(π/2) = 1.0, factorial(5) = 120
+   📊 Details: [Mathematical context]
+   ⚡ Steps: [Calculation steps]
+   💡 Note: [Additional insights]
+   ```
+
+### Example 3: Algorithms
+When you ask: *"Calculate fibonacci(10) and npr(5, 3)"*
+
+meeTARA should:
+1. ✅ Detect calculator need (matches "fibonacci" and "npr")
+2. ✅ Execute calculator: `fibonacci(10) = 55` and `npr(5, 3) = 60`
+3. ✅ Feed results to AI model
+4. ✅ Generate structured response:
+   ```
+   🎯 Answer: fibonacci(10) = 55, npr(5, 3) = 60
+   📊 Details: [Algorithm context]
+   ⚡ Steps: [Calculation steps]
+   💡 Note: [Additional insights]
+   ```
+
+### Example 4: Base Conversion
+When you ask: *"Convert 255 to binary and hexadecimal"*
+
+meeTARA should:
+1. ✅ Detect calculator need (matches "convert" and "binary"/"hexadecimal")
+2. ✅ Execute calculator: `bin(255) = 0b11111111` and `hex(255) = 0xff`
+3. ✅ Feed results to AI model
+4. ✅ Generate structured response:
+   ```
+   🎯 Answer: 255 in binary = 0b11111111, in hexadecimal = 0xff
+   📊 Details: [Base conversion context]
+   ⚡ Steps: [Conversion steps]
+   💡 Note: [Additional insights]
+   ```
+
+### Example 5: Complex Combined Query
+When you ask: *"Calculate fibonacci(15), factorial(7), and search for latest algorithm research"*
+
+meeTARA should:
+1. ✅ Detect calculator need (matches "fibonacci" and "factorial")
+2. ✅ Detect web search need (matches "latest" + "research")
+3. ✅ Execute calculator: `fibonacci(15) = 610` and `factorial(7) = 5040`
+4. ✅ Execute web search: Get algorithm research from Google/DuckDuckGo
+5. ✅ Feed all results to AI model
+6. ✅ Generate structured response with all calculations and search results
+
+---
+
+## 📝 Notes for Testing
+
+### Calculator Testing
+- ✅ **Basic math queries** should return accurate results
+- ✅ **Percentage queries** should convert correctly (e.g., "15% of 340" → 51)
+- ✅ **Division text** should convert correctly (e.g., "999 divided by 3" → 333)
+- ✅ **Scientific functions** should handle radians, degrees, logarithms correctly
+- ✅ **Algorithm functions** should calculate Fibonacci, Permutations, Combinations accurately
+- ✅ **Base conversions** should return properly formatted results (0b, 0x, 0o prefixes)
+- ✅ **Geometry queries** should detect and provide context (model calculates formulas)
+- ✅ **Complex expressions** should respect order of operations (PEMDAS/BODMAS)
+
+### Web Search Testing
+- ✅ **Web search queries** should fetch current/recent information
+- ✅ **Time-sensitive queries** should trigger search (today, latest, current, present day)
+- ✅ **Stock market queries** should detect and search for market data
+- ✅ **News queries** should detect and search for current events
+- ✅ **Fallback behavior** should work if Google API is unavailable (DuckDuckGo)
+- ✅ **Error handling** should be graceful if search returns no results
+
+### Combined Queries Testing
+- ✅ **Combined queries** should handle both calculator and web search correctly
+- ✅ **Multiple calculator operations** should execute sequentially
+- ✅ **Calculator + Search** should combine results properly
+- ✅ **Response format** should follow meeTARA's structured format (🎯📊⚡💡)
+
+### Detection Testing
+- ✅ **Calculator detection** should catch: basic math, percentage, division, scientific, algorithms
+- ✅ **Web search detection** should catch: today, latest, current, trends, news, stock market
+- ✅ **Natural language** should be converted correctly (e.g., "sine of 90" → sin(90))
+- ✅ **Pattern matching** should work for variations (e.g., "5P3", "5C3", "npr(5,3)")
+
+### Error Handling
+- ✅ **Invalid expressions** should return error messages gracefully
+- ✅ **Division by zero** should be handled safely
+- ✅ **Out of range** (e.g., factorial(1000)) should be handled
+- ✅ **Search failures** should fallback to DuckDuckGo automatically
+- ✅ **No search results** should still provide model response
+
+---
+
+## 🎯 Testing Checklist
+
+### Basic Calculator ✅
+- [ ] Basic arithmetic (+, -, *, /)
+- [ ] Percentage calculations
+- [ ] Division text conversion
+- [ ] Order of operations
+
+### Scientific Calculator ✅
+- [ ] Trigonometry (sin, cos, tan, arcsin, arccos, arctan)
+- [ ] Hyperbolic functions (sinh, cosh, tanh)
+- [ ] Logarithms (log, log10, log2, ln, exp)
+- [ ] Powers and roots (sqrt, cbrt, pow)
+- [ ] Advanced (factorial, gcd, lcm, floor, ceil)
+- [ ] Degree/radian conversion
+
+### Algorithms & Data Structures ✅
+- [ ] Fibonacci sequence
+- [ ] Permutations (nPr)
+- [ ] Combinations (nCr)
+- [ ] Base conversions (binary, hex, octal)
+- [ ] Complexity keywords (detection)
+- [ ] Data structure keywords (detection)
+
+### Geometry ✅
+- [ ] Surface area
+- [ ] Area of circle
+- [ ] Volume calculations
+- [ ] Perimeter calculations
+
+### Web Search ✅
+- [ ] Today's news
+- [ ] Current trends
+- [ ] Stock market data
+- [ ] Latest developments
+- [ ] Time-sensitive queries
+
+### Combined Queries ✅
+- [ ] Calculator + Search
+- [ ] Multiple calculations + Search
+- [ ] Scientific + Search
+- [ ] Algorithms + Search
+
+---
+
+**Happy Testing! 🚀**
+
+The meeTARA Agent now supports comprehensive mathematical calculations, scientific functions, algorithms, data structures, and intelligent web search!
+

config/agent_config.json

@@ -11,6 +11,15 @@
       "trend",
       "trends",
       "news",
+      "headlines",
+      "headline",
+      "breaking news",
+      "latest news",
+      "today's news",
+      "top news",
+      "current news",
+      "what happened",
+      "happening",
       "2024",
       "2025",
       "2026",
@@ -49,6 +58,50 @@
       "breaking news",
       "latest developments"
     ],
+    "news_query_keywords": [
+      "news",
+      "headlines",
+      "headline",
+      "breaking news",
+      "latest news",
+      "today's news",
+      "top news",
+      "current news",
+      "what happened",
+      "happening",
+      "breaking",
+      "developing"
+    ],
+    "meta_page_filter_phrases": [
+      "provides",
+      "offers",
+      "visit",
+      "check",
+      "read",
+      "explore",
+      "go to",
+      "subscribe",
+      "newsletter",
+      "website",
+      "at cnn",
+      "at fox",
+      "at bbc",
+      "you can find",
+      "available across",
+      "including cnn",
+      "including fox",
+      "visit cnn",
+      "check fox",
+      "view",
+      "on cnn.com",
+      "on foxnews.com",
+      "on bbc.com"
+    ],
+    "news_enhancement_keywords": [
+      "headlines",
+      "breaking",
+      "latest"
+    ],
     "search_patterns": [
       {
         "pattern": "(?:search|find)\\s+(?:for\\s+)?(.+?)(?:\\s+and|\\s+also|$)",
@@ -96,7 +149,86 @@
     "provider": "duckduckgo",
     "google_custom_search": {
       "enabled": false,
-      "note": "Set GOOGLE_CUSTOM_SEARCH_API_KEY and GOOGLE_CUSTOM_SEARCH_ENGINE_ID environment variables to enable. Free tier: 100 queries/day. See README for setup instructions."
+      "auto_fallback_on_quota": true,
+      "note": "Set GOOGLE_CUSTOM_SEARCH_API_KEY and GOOGLE_CUSTOM_SEARCH_ENGINE_ID environment variables to enable. Free tier: 100 queries/day. When quota exceeded, automatically falls back to DuckDuckGo (free, unlimited). Paid tier: $5 per 1,000 queries after free tier. See README for setup instructions.",
+      "quota_info": {
+        "free_tier_quota": 100,
+        "free_tier_period": "per day",
+        "paid_tier_cost": "$5 per 1,000 queries",
+        "auto_fallback": "DuckDuckGo (free, unlimited)"
+      }
+    },
+    "news_query_instructions": {
+      "enabled": true,
+      "instruction_template": "CRITICAL INSTRUCTIONS FOR NEWS/HEADLINES QUERY:\n1. Extract and list the ACTUAL NEWS HEADLINES and STORIES from the search results above.\n2. Do NOT just describe news sources (e.g., 'CNN provides...' or 'Fox News offers...').\n3. Extract the REAL HEADLINES and NEWS CONTENT (e.g., 'President announces...', 'Stock market rises...', 'New study finds...').\n4. Focus on actual events, developments, and stories mentioned in the search results.\n5. You may mention source names briefly for attribution (e.g., 'According to CNN...'), but the primary content should be the actual news headlines and stories.\n6. List specific headlines and news items, not generic descriptions of news websites.\n\nExample of what to extract: 'Breaking: Stock market surges 2% today' (actual news)\nNOT: 'CNN provides breaking news updates' (source description)\n\nNow extract the actual news headlines and content from the search results above.",
+      "regular_instruction": "Use the tool results above to provide your response."
+    },
+    "safety_filter": {
+      "enabled": true,
+      "blocked_keywords": [
+        "how to hack",
+        "how to crack",
+        "how to break into",
+        "how to bypass",
+        "how to exploit",
+        "how to harm",
+        "how to hurt",
+        "how to kill",
+        "how to attack",
+        "how to destroy",
+        "how to steal",
+        "how to scam",
+        "how to cheat",
+        "how to manipulate",
+        "illegal activities",
+        "illegal content",
+        "piracy",
+        "warez",
+        "crack software",
+        "hack account",
+        "ddos attack",
+        "phishing",
+        "malware",
+        "virus download",
+        "trojan",
+        "keylogger",
+        "spyware",
+        "ransomware",
+        "drugs buy",
+        "drugs online",
+        "weapons buy",
+        "weapons online",
+        "violence instructions",
+        "terrorism",
+        "extremist content",
+        "hate speech",
+        "discriminatory content",
+        "explicit adult content",
+        "adult websites",
+        "nsfw content",
+        "inappropriate content"
+      ],
+      "blocked_patterns": [
+        {
+          "pattern": "how\\s+to\\s+(?:hack|crack|break|bypass|exploit|harm|hurt|attack|destroy|steal|scam|cheat|manipulate)",
+          "description": "How-to queries for harmful activities"
+        },
+        {
+          "pattern": "(?:download|get|buy)\\s+(?:malware|virus|trojan|keylogger|spyware|ransomware|warez|cracked)",
+          "description": "Downloads of malicious software or pirated content"
+        },
+        {
+          "pattern": "(?:buy|purchase|get)\\s+(?:drugs|weapons|illegal)",
+          "description": "Illegal goods purchase queries"
+        },
+        {
+          "pattern": "(?:instructions|guide|tutorial)\\s+(?:for|on)\\s+(?:violence|attack|harm|illegal)",
+          "description": "Instructions for harmful activities"
+        }
+      ],
+      "safe_search_enabled": true,
+      "safe_search_param": "safe=active",
+      "blocked_response_message": "I cannot search for content that may involve harmful, illegal, or inappropriate material. Please try a different query related to news, current events, technology, education, or general information."
     }
   },
   
@@ -123,20 +255,241 @@
       "sum",
       "difference",
       "product",
-      "quotient"
+      "quotient",
+      "percentage",
+      "percent",
+      "%",
+      "of",
+      "surface area",
+      "area",
+      "volume",
+      "perimeter",
+      "circumference",
+      "radius",
+      "diameter",
+      "find the",
+      "find",
+      "rectangular prism",
+      "circle",
+      "rectangle",
+      "triangle",
+      "cylinder",
+      "sphere",
+      "sine",
+      "cosine",
+      "tangent",
+      "sin",
+      "cos",
+      "tan",
+      "arcsin",
+      "arccos",
+      "arctan",
+      "logarithm",
+      "log",
+      "ln",
+      "natural log",
+      "exponential",
+      "exp",
+      "factorial",
+      "gcd",
+      "lcm",
+      "degrees",
+      "radians",
+      "square root",
+      "cube root",
+      "sqrt",
+      "power",
+      "exponent",
+      "pow",
+      "algorithm",
+      "algorithms",
+      "data structure",
+      "data structures",
+      "big o",
+      "complexity",
+      "time complexity",
+      "space complexity",
+      "fibonacci",
+      "fibonacci sequence",
+      "permutation",
+      "permutations",
+      "combination",
+      "combinations",
+      "ncr",
+      "npr",
+      "factorial",
+      "fact",
+      "binary search",
+      "linear search",
+      "sorting",
+      "quick sort",
+      "merge sort",
+      "bubble sort",
+      "graph",
+      "tree",
+      "binary tree",
+      "array",
+      "linked list",
+      "stack",
+      "queue",
+      "hash",
+      "hash table",
+      "heap",
+      "binary heap",
+      "trie",
+      "recursion",
+      "recursive",
+      "dynamic programming",
+      "greedy",
+      "backtracking",
+      "divide and conquer",
+      "binary",
+      "hexadecimal",
+      "hex",
+      "decimal",
+      "octal",
+      "base conversion"
     ],
     "math_patterns": [
       {
-        "pattern": "\\b(calculate|compute|what is|what's|solve|evaluate|multiply|divide|add|subtract)\\s+([0-9+\\-*/().\\s]+?)(?:\\s+and|\\s+also|$)",
-        "description": "calculate 25 * 48, what is 25 * 48, compute X"
+        "pattern": "\\b(calculate|compute|what is|what's|solve|evaluate|multiply|divide|add|subtract|find|find the)\\s+([0-9+\\-*/().\\s]+?)(?:\\s+and|\\s+also|$)",
+        "description": "calculate 25 * 48, what is 25 * 48, compute X, find the area"
       },
       {
-        "pattern": "\\b([0-9]+\\s*[+\\-*/×÷]\\s*[0-9]+)",
-        "description": "25 * 48 or 25 × 48"
+        "pattern": "\\b([0-9]+\\s*[+\\-*/×÷]\\s*[0-9]+(?:\\s*[+\\-*/×÷]\\s*[0-9]+)*)",
+        "description": "25 * 48 or 25 × 48 or 1000 - 456 + 234 * 3"
       },
       {
         "pattern": "\\b(sqrt|square root|power|exponent)\\s*\\(?\\s*([0-9]+)\\s*\\)?",
         "description": "sqrt(16) or square root 16"
+      },
+      {
+        "pattern": "\\b([0-9]+(?:\\.[0-9]+)?)\\s*%\\s*(?:of|times|×)\\s*([0-9]+)",
+        "description": "15% of 340, 25% times 100"
+      },
+      {
+        "pattern": "(?:what is|what's|calculate|compute|find|find the)\\s+([0-9]+(?:\\.[0-9]+)?)\\s*%\\s*(?:of|times|×)?\\s*([0-9]+)",
+        "description": "what's 15% of 340"
+      },
+      {
+        "pattern": "\\b([0-9]+)\\s+(?:divided by|divided|÷|/)\\s+([0-9]+)",
+        "description": "999 divided by 3, 100 / 4, 50 ÷ 2"
+      },
+      {
+        "pattern": "(?:find|calculate|compute|what is|what's|the)\\s+(?:surface area|area|volume|perimeter|circumference)\\s+(?:of|for)?",
+        "description": "find the surface area of, calculate the area of a circle, volume of a cylinder"
+      },
+      {
+        "pattern": "(?:surface area|area|volume|perimeter|circumference)\\s+(?:of|for|with)\\s+.*?(?:radius|diameter|length|width|height|dimensions)\\s*=",
+        "description": "area of a circle with radius 7 cm, surface area with dimensions length = 6"
+      },
+      {
+        "pattern": "\\b(sin|cos|tan|asin|acos|atan|arcsin|arccos|arctan|sine|cosine|tangent)\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?|pi|e|pi/[0-9]+)\\s*\\)",
+        "description": "sin(90), cos(pi/2), tan(45), sine(90), arcsin(1)"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|find the)\\s+(?:the\\s+)?(sin|cos|tan|sine|cosine|tangent|arcsin|arccos|arctan)\\s+(?:of|at)?\\s*([0-9]+(?:\\.[0-9]+)?|pi|e|pi/[0-9]+)",
+        "description": "calculate sine of 90, what is cos of pi/2, find tangent of 45"
+      },
+      {
+        "pattern": "\\b(sinh|cosh|tanh|asinh|acosh|atanh)\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?)\\s*\\)",
+        "description": "sinh(2), cosh(3), tanh(1)"
+      },
+      {
+        "pattern": "\\b(log|ln|log10|log2|natural log|logarithm)\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?|e|10|2)\\s*\\)",
+        "description": "log(10), ln(e), log10(100), log2(8), natural log of e"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find)\\s+(?:the\\s+)?(log|ln|natural log|logarithm|log base 10|log base 2)\\s+(?:of|of the number)?\\s*([0-9]+(?:\\.[0-9]+)?|e|10|2)",
+        "description": "calculate log of 10, what is natural log of e, find log base 10 of 100"
+      },
+      {
+        "pattern": "\\bexp\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?)\\s*\\)|exponential\\s+of\\s+([0-9]+(?:\\.[0-9]+)?)|e\\^([0-9]+(?:\\.[0-9]+)?)",
+        "description": "exp(2), exponential of 3, e^2"
+      },
+      {
+        "pattern": "\\bfactorial\\s*\\(\\s*([0-9]+)\\s*\\)|([0-9]+)!",
+        "description": "factorial(5), 5!"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find)\\s+(?:the\\s+)?factorial\\s+of\\s+([0-9]+)|([0-9]+)\\s*factorial",
+        "description": "calculate factorial of 5, what is 5 factorial"
+      },
+      {
+        "pattern": "\\bgcd\\s*\\(\\s*([0-9]+)\\s*,\\s*([0-9]+)\\s*\\)|greatest common divisor\\s+of\\s+([0-9]+)\\s+and\\s+([0-9]+)",
+        "description": "gcd(48, 18), greatest common divisor of 48 and 18"
+      },
+      {
+        "pattern": "\\blcm\\s*\\(\\s*([0-9]+)\\s*,\\s*([0-9]+)\\s*\\)|least common multiple\\s+of\\s+([0-9]+)\\s+and\\s+([0-9]+)",
+        "description": "lcm(12, 18), least common multiple of 12 and 18"
+      },
+      {
+        "pattern": "\\b(pow|power|\\^)\\s*\\(\\s*([0-9]+)\\s*,\\s*([0-9]+)\\s*\\)|([0-9]+)\\s*\\^\\s*([0-9]+)|([0-9]+)\\s+to\\s+the\\s+power\\s+of\\s+([0-9]+)",
+        "description": "pow(2, 8), 2^8, 2 to the power of 8"
+      },
+      {
+        "pattern": "\\b(sqrt|square root|√)\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?)\\s*\\)|square root of\\s+([0-9]+(?:\\.[0-9]+)?)|√([0-9]+(?:\\.[0-9]+)?)",
+        "description": "sqrt(144), square root(16), square root of 144, √16"
+      },
+      {
+        "pattern": "\\b(cbrt|cube root)\\s*\\(\\s*([0-9]+)\\s*\\)|cube root of\\s+([0-9]+)",
+        "description": "cbrt(27), cube root(8), cube root of 27"
+      },
+      {
+        "pattern": "(?:convert|what is|calculate|compute)\\s+([0-9]+(?:\\.[0-9]+)?)\\s*(?:degrees?|°)\\s+(?:to|in)\\s+radians?",
+        "description": "convert 180 degrees to radians, what is 90° in radians"
+      },
+      {
+        "pattern": "(?:convert|what is|calculate|compute)\\s+([0-9]+(?:\\.[0-9]+)?|pi|pi/[0-9]+)\\s+radians?\\s+(?:to|in)\\s+degrees?",
+        "description": "convert pi radians to degrees, what is pi/2 in degrees"
+      },
+      {
+        "pattern": "\\b(degrees|radians)\\s*\\(\\s*([0-9]+(?:\\.[0-9]+)?|pi|pi/[0-9]+)\\s*\\)",
+        "description": "degrees(pi), radians(180)"
+      },
+      {
+        "pattern": "\\b(floor|ceil|trunc|round)\\s*\\(\\s*([0-9]+\\.[0-9]+)\\s*\\)",
+        "description": "floor(3.7), ceil(3.2), trunc(3.9), round(3.5)"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|find the|nth term of)\\s+(?:the\\s+)?fibonacci\\s+(?:number|sequence|of|at)?\\s*([0-9]+)|fibonacci\\s*\\(\\s*([0-9]+)\\s*\\)",
+        "description": "calculate fibonacci of 10, what is the 10th fibonacci number, fibonacci(10)"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find)\\s+(?:the\\s+)?(?:number of\\s+)?permutations?\\s+(?:of|for|with)?\\s*([0-9]+)\\s+(?:taken|choose|selected|at a time|per group)?\\s*([0-9]+)?|npr\\s*\\(\\s*([0-9]+)\\s*,\\s*([0-9]+)\\s*\\)|([0-9]+)p([0-9]+)",
+        "description": "permutations of 5 taken 3, npr(5,3), 5P3, number of permutations for 5 items"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find)\\s+(?:the\\s+)?(?:number of\\s+)?combinations?\\s+(?:of|for|with)?\\s*([0-9]+)\\s+(?:taken|choose|selected|at a time|per group)?\\s*([0-9]+)?|ncr\\s*\\(\\s*([0-9]+)\\s*,\\s*([0-9]+)\\s*\\)|([0-9]+)c([0-9]+)",
+        "description": "combinations of 5 choose 3, ncr(5,3), 5C3, number of combinations for 5 items"
+      },
+      {
+        "pattern": "(?:what is|what's|calculate|compute|find|analyze|explain)\\s+(?:the\\s+)?(?:time|space)?\\s*complexity\\s+(?:of|for)?|big\\s*o\\s+(?:of|for|notation)?|o\\s*\\(|complexity\\s+analysis",
+        "description": "what is the time complexity of, big o of, o(n), complexity analysis"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|explain)\\s+(?:binary|linear|quick|merge|bubble|heap|selection|insertion)\\s+search\\s+(?:complexity|time|space|algorithm)?",
+        "description": "binary search complexity, time complexity of merge sort, quick sort big o"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|explain)\\s+(?:binary|linear|quick|merge|bubble|heap|selection|insertion)\\s+sort\\s+(?:complexity|time|space|algorithm)?",
+        "description": "merge sort time complexity, big o of quick sort, bubble sort space complexity"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|explain|analyze)\\s+(?:binary\\s+)?tree\\s+(?:height|depth|nodes|leaves|complexity|traversal|algorithm)?|tree\\s+(?:height|depth|nodes|leaves)\\s+(?:of|for)?",
+        "description": "binary tree height, tree depth calculation, tree nodes count, tree complexity"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find|explain|analyze)\\s+(?:graph|hash|heap|trie|array|linked list|stack|queue)\\s+(?:complexity|operations|algorithm|time|space)?",
+        "description": "graph complexity, hash table operations, heap insert complexity, trie search time"
+      },
+      {
+        "pattern": "(?:convert|what is|calculate|compute)\\s+([0-9]+|binary|hex|hexadecimal|decimal|octal)\\s+(?:to|in|as)\\s+(binary|hex|hexadecimal|decimal|octal|base\\s+[0-9]+)",
+        "description": "convert 255 to binary, what is 10 in hex, 1010 to decimal, base conversion"
+      },
+      {
+        "pattern": "(?:calculate|compute|what is|what's|find)\\s+(?:recursive|recursion)\\s+(?:complexity|time|space|depth|calls)?|recursion\\s+(?:depth|complexity|for)?",
+        "description": "recursive complexity, recursion depth, recursive fibonacci complexity"
       }
     ],
     "enabled": true

core/meetara_agent.py

@@ -54,27 +54,242 @@ def calculator(expression: str) -> str:
     Evaluates a mathematical expression and returns the result.
     Use this for any calculations to ensure accuracy.
     
+    Supports:
+    - Basic math: "25 * 48", "1000 - 456 + 234 * 3"
+    - Percentage: "15% of 340" (converts to "0.15 * 340")
+    - Division text: "999 divided by 3" (converts to "999 / 3")
+    - Scientific functions:
+      * Powers/roots: "sqrt(144)", "pow(2, 8)", "cbrt(27)"
+      * Trigonometry: "sin(pi/2)", "cos(0)", "tan(pi/4)", "asin(1)", "acos(0)", "atan(1)"
+      * Hyperbolic: "sinh(2)", "cosh(2)", "tanh(1)"
+      * Logarithms: "log(10)", "log10(100)", "log2(8)", "ln(e)", "exp(2)"
+      * Advanced: "factorial(5)", "gcd(48, 18)", "lcm(12, 18)", "degrees(pi)", "radians(180)"
+    - Natural language: "sine of pi/2", "natural log of e", "square root of 144"
+    - Algorithms & Data Structures:
+      * Fibonacci: "fibonacci(10)", "fibonacci of 10", "10th fibonacci"
+      * Permutations: "npr(5, 3)", "permutations of 5 taken 3", "5P3"
+      * Combinations: "ncr(5, 3)", "combinations of 5 choose 3", "5C3"
+      * Base conversion: "bin(255)", "hex(255)", "oct(255)", "convert 255 to binary"
+    
     Args:
-        expression: A mathematical expression like "25 * 48" or "sqrt(144)"
+        expression: A mathematical expression or natural language math query
     
     Returns:
         The calculated result as a string
     """
     import math
+    import re
+    
     try:
-        # Safe evaluation with math functions available
+        expr_lower = expression.lower()
+        original_expr = expression
+        
+        # Handle percentage: "15% of 340" or "15% times 340" or "what's 15% of 340"
+        percentage_match = re.search(r'([0-9]+(?:\.[0-9]+)?)\s*%\s*(?:of|times|×)\s*([0-9]+)', expr_lower)
+        if percentage_match:
+            percent = float(percentage_match.group(1)) / 100
+            value = float(percentage_match.group(2))
+            expression = f"{percent} * {value}"
+            logger.info(f"[AGENT] 🧮 Converted percentage: '{original_expr}' → '{expression}'")
+        
+        # Handle division text: "999 divided by 3" or "999 ÷ 3"
+        if not percentage_match:
+            division_match = re.search(r'([0-9]+(?:\.[0-9]+)?)\s+(?:divided by|divided|÷)\s+([0-9]+(?:\.[0-9]+)?)', expr_lower)
+            if division_match:
+                dividend = division_match.group(1)
+                divisor = division_match.group(2)
+                expression = f"{dividend} / {divisor}"
+                logger.info(f"[AGENT] 🧮 Converted division text: '{original_expr}' → '{expression}'")
+        
+        # Handle geometry queries (model will calculate, calculator just provides context)
+        geometry_keywords = ["surface area", "area of", "volume of", "perimeter", "circumference", "radius", "diameter"]
+        if any(geo in expr_lower for geo in geometry_keywords):
+            # Extract numbers for context (model will do the actual geometry calculation)
+            numbers = re.findall(r'[0-9]+(?:\.[0-9]+)?', expression)
+            if len(numbers) >= 2:
+                # Try to extract a simple expression if possible
+                logger.info(f"[AGENT] 🧮 Geometry query detected: '{expression}' - model will calculate")
+                # Return context - model will handle geometry formulas
+                return f"Geometry calculation requested: {expression}. Numbers found: {', '.join(numbers)}. Please calculate using appropriate formulas."
+        
+        # Clean expression: remove extra spaces, normalize operators
+        expression = re.sub(r'\s+', ' ', expression.strip())
+        expression = expression.replace('×', '*').replace('÷', '/')
+        
+        # Safe evaluation with comprehensive scientific math functions
         allowed_names = {
-            "abs": abs, "round": round, "min": min, "max": max,
-            "sum": sum, "pow": pow, "sqrt": math.sqrt,
+            # Basic functions
+            "abs": abs, "round": round, "min": min, "max": max, "sum": sum,
+            
+            # Powers and roots
+            "pow": pow, "sqrt": math.sqrt, "cbrt": lambda x: x ** (1/3),  # Cube root
+            
+            # Trigonometric functions (radians)
             "sin": math.sin, "cos": math.cos, "tan": math.tan,
-            "log": math.log, "log10": math.log10, "exp": math.exp,
-            "pi": math.pi, "e": math.e
+            "asin": math.asin, "acos": math.acos, "atan": math.atan, "atan2": math.atan2,
+            
+            # Hyperbolic functions
+            "sinh": math.sinh, "cosh": math.cosh, "tanh": math.tanh,
+            "asinh": math.asinh, "acosh": math.acosh, "atanh": math.atanh,
+            
+            # Logarithmic functions
+            "log": math.log, "log10": math.log10, "log2": math.log2, "exp": math.exp,
+            "ln": math.log,  # Natural logarithm (alias)
+            
+            # Additional functions
+            "factorial": math.factorial, "gcd": math.gcd, "lcm": lambda a, b: abs(a * b) // math.gcd(a, b) if a and b else 0,
+            "degrees": math.degrees, "radians": math.radians,
+            "floor": math.floor, "ceil": math.ceil, "trunc": math.trunc,
+            
+            # Algorithm & Data Structure functions
+            "perm": lambda n, r: math.factorial(n) // math.factorial(n - r) if n >= r >= 0 else 0,  # Permutations nPr
+            "permutations": lambda n, r: math.factorial(n) // math.factorial(n - r) if n >= r >= 0 else 0,
+            "npr": lambda n, r: math.factorial(n) // math.factorial(n - r) if n >= r >= 0 else 0,
+            "comb": lambda n, r: math.factorial(n) // (math.factorial(r) * math.factorial(n - r)) if n >= r >= 0 else 0,  # Combinations nCr
+            "combinations": lambda n, r: math.factorial(n) // (math.factorial(r) * math.factorial(n - r)) if n >= r >= 0 else 0,
+            "ncr": lambda n, r: math.factorial(n) // (math.factorial(r) * math.factorial(n - r)) if n >= r >= 0 else 0,
+            "choose": lambda n, r: math.factorial(n) // (math.factorial(r) * math.factorial(n - r)) if n >= r >= 0 else 0,
+            
+            # Fibonacci function (iterative for efficiency)
+            "fibonacci": lambda n: int((((1 + math.sqrt(5)) / 2) ** n - ((1 - math.sqrt(5)) / 2) ** n) / math.sqrt(5)) if n >= 0 else 0,
+            "fib": lambda n: int((((1 + math.sqrt(5)) / 2) ** n - ((1 - math.sqrt(5)) / 2) ** n) / math.sqrt(5)) if n >= 0 else 0,
+            
+            # Base conversion helpers (to be used in expressions like "int('1010', 2)")
+            "bin_to_dec": lambda b: int(str(b), 2),
+            "hex_to_dec": lambda h: int(str(h), 16),
+            "oct_to_dec": lambda o: int(str(o), 8),
+            "dec_to_bin": lambda n: bin(int(n)),
+            "dec_to_hex": lambda n: hex(int(n)),
+            "dec_to_oct": lambda n: oct(int(n)),
+            
+            # Constants
+            "pi": math.pi, "e": math.e, "tau": math.tau,
+            "inf": float('inf'), "nan": float('nan')
         }
+        
+        # Handle base conversion expressions separately (they return strings)
+        # Check for direct function calls like bin(255), hex(255), oct(255)
+        base_conv_pattern = re.search(r'\b(bin|hex|oct|dec_to_bin|dec_to_hex|dec_to_oct)\s*\(\s*([0-9]+)\s*\)', expression, re.IGNORECASE)
+        base_conv_result = None
+        if base_conv_pattern:
+            func_name = base_conv_pattern.group(1).lower()
+            num = int(base_conv_pattern.group(2))
+            if 'bin' in func_name:
+                base_conv_result = bin(num)
+            elif 'hex' in func_name:
+                base_conv_result = hex(num)
+            elif 'oct' in func_name:
+                base_conv_result = oct(num)
+            
+            if base_conv_result:
+                result_str = f"{original_expr} = {base_conv_result}"
+                logger.info(f"[AGENT] 📥 Calculator result (base conversion): {result_str}")
+                return result_str
+        
+        # Handle natural language scientific function names (before cleaning)
+        scientific_aliases = {
+            "sine of": "sin", "cosine of": "cos", "tangent of": "tan",
+            "sine": "sin", "cosine": "cos", "tangent": "tan",
+            "arcsin of": "asin", "arccos of": "acos", "arctan of": "atan",
+            "square root of": "sqrt", "cube root of": "cbrt",
+            "natural log of": "ln", "log base 10 of": "log10", "log base 2 of": "log2"
+        }
+        
+        # Replace natural language patterns like "sine of 90" -> "sin(90)" or "sine(90)"
+        for alias, func_name in scientific_aliases.items():
+            if alias in expr_lower:
+                # Pattern: "sine of 90" -> "sin(90)"
+                pattern1 = re.compile(r'\b' + re.escape(alias) + r'\s+([0-9]+(?:\.[0-9]+)?|pi|e)' , re.IGNORECASE)
+                expression = pattern1.sub(func_name + r'(\1)', expression)
+                # Pattern: "sine(90)" -> "sin(90)" (already in correct format)
+                pattern2 = re.compile(r'\b' + re.escape(alias.split()[0]) + r'\s*\(' , re.IGNORECASE)
+                expression = pattern2.sub(func_name + '(', expression)
+        
+        # Handle algorithm & data structure natural language queries
+        # Fibonacci: "fibonacci of 10" or "fibonacci(10)" or "10th fibonacci"
+        fib_match = re.search(r'(?:fibonacci|fib)\s+(?:of|at|number)?\s*([0-9]+)|([0-9]+)(?:th|st|nd|rd)?\s+fibonacci', expr_lower)
+        if fib_match:
+            n = int(fib_match.group(1) or fib_match.group(2))
+            expression = f"fibonacci({n})"
+            logger.info(f"[AGENT] 🧮 Converted fibonacci query: '{original_expr}' → '{expression}'")
+        
+        # Permutations: "permutations of 5 taken 3" or "5P3" or "npr(5, 3)"
+        perm_match = re.search(r'(?:permutations?|perm|npr)\s+(?:of|for)?\s*([0-9]+)\s+(?:taken|choose|selected|at a time)?\s*([0-9]+)|([0-9]+)p([0-9]+)', expr_lower)
+        if perm_match:
+            n = int(perm_match.group(1) or perm_match.group(3))
+            r = int(perm_match.group(2) or perm_match.group(4))
+            expression = f"npr({n}, {r})"
+            logger.info(f"[AGENT] 🧮 Converted permutations query: '{original_expr}' → '{expression}'")
+        
+        # Combinations: "combinations of 5 choose 3" or "5C3" or "ncr(5, 3)"
+        comb_match = re.search(r'(?:combinations?|comb|ncr|choose)\s+(?:of|for)?\s*([0-9]+)\s+(?:choose|taken|selected|at a time)?\s*([0-9]+)|([0-9]+)c([0-9]+)', expr_lower)
+        if comb_match:
+            n = int(comb_match.group(1) or comb_match.group(3))
+            r = int(comb_match.group(2) or comb_match.group(4))
+            expression = f"ncr({n}, {r})"
+            logger.info(f"[AGENT] 🧮 Converted combinations query: '{original_expr}' → '{expression}'")
+        
+        # Base conversion: "convert 255 to binary" or "binary of 255"
+        base_conv_match = re.search(r'(?:convert|what is|calculate|compute)\s+([0-9]+)\s+(?:to|in|as)\s+(binary|hex|hexadecimal|decimal|octal|base\s+([0-9]+))|(?:binary|hex|hexadecimal|decimal|octal)\s+(?:of|for)?\s*([0-9]+)', expr_lower)
+        if base_conv_match and not percentage_match and not division_match:
+            if base_conv_match.group(1):  # "convert 255 to binary" pattern
+                num = int(base_conv_match.group(1))
+                target_base = base_conv_match.group(2).lower() if base_conv_match.group(2) else ""
+                if 'binary' in target_base or 'base 2' in target_base or (not target_base and 'binary' in expr_lower):
+                    expression = f"bin({num})"
+                elif 'hex' in target_base or 'base 16' in target_base or (not target_base and ('hex' in expr_lower or 'hexadecimal' in expr_lower)):
+                    expression = f"hex({num})"
+                elif 'octal' in target_base or 'base 8' in target_base or (not target_base and 'octal' in expr_lower):
+                    expression = f"oct({num})"
+                logger.info(f"[AGENT] 🧮 Converted base conversion query: '{original_expr}' → '{expression}'")
+            elif base_conv_match.group(4):  # "binary of 255" pattern
+                num = int(base_conv_match.group(4))
+                if 'binary' in expr_lower:
+                    expression = f"bin({num})"
+                elif 'hex' in expr_lower or 'hexadecimal' in expr_lower:
+                    expression = f"hex({num})"
+                elif 'octal' in expr_lower:
+                    expression = f"oct({num})"
+                logger.info(f"[AGENT] 🧮 Converted base conversion query: '{original_expr}' → '{expression}'")
+        
         logger.info(f"[AGENT] 🧮 Calculator API call: expression='{expression}'")
-        result = eval(expression, {"__builtins__": {}}, allowed_names)
-        result_str = f"{expression} = {result}"
+        
+        # Check again for base conversion after natural language processing
+        base_conv_after = re.search(r'\b(bin|hex|oct)\s*\(\s*([0-9]+)\s*\)', expression, re.IGNORECASE)
+        if base_conv_after and not base_conv_result:
+            func_name = base_conv_after.group(1).lower()
+            num = int(base_conv_after.group(2))
+            if func_name == 'bin':
+                base_conv_result = bin(num)
+            elif func_name == 'hex':
+                base_conv_result = hex(num)
+            elif func_name == 'oct':
+                base_conv_result = oct(num)
+        
+        # Evaluate expression
+        if base_conv_result:
+            result = base_conv_result
+        else:
+            # Add bin, hex, oct to allowed built-ins for eval
+            safe_builtins = {"__builtins__": {}, "bin": bin, "hex": hex, "oct": oct}
+            result = eval(expression, safe_builtins, allowed_names)
+        
+        # Format result nicely
+        if isinstance(result, str) and (result.startswith('0b') or result.startswith('0x') or result.startswith('0o')):
+            # Base conversion result (already formatted)
+            result_str = f"{original_expr if original_expr != expression else expression} = {result}"
+        elif isinstance(result, float):
+            if result.is_integer():
+                result = int(result)
+            else:
+                result = round(result, 10)  # Round to 10 decimal places
+            result_str = f"{original_expr if original_expr != expression else expression} = {result}"
+        else:
+            result_str = f"{original_expr if original_expr != expression else expression} = {result}"
+        
         logger.info(f"[AGENT] 📥 Calculator result: {result_str}")
         return result_str
+        
     except Exception as e:
         error_msg = f"Error calculating '{expression}': {str(e)}"
         logger.error(f"[AGENT] ❌ Calculator error: {error_msg}")
@@ -98,18 +313,113 @@ if USE_GOOGLE_SEARCH:
 else:
     logger.debug("[AGENT] ℹ️ Google Custom Search API not configured - using DuckDuckGo (free)")
 
+def is_safe_search_query(query: str, agent_config: dict = None) -> tuple[bool, str]:
+    """
+    Check if a search query is safe to execute.
+    
+    Args:
+        query: Search query string to validate
+        agent_config: Optional agent configuration dict (if None, uses defaults)
+    
+    Returns:
+        Tuple of (is_safe: bool, reason: str)
+    """
+    # Load safety filter config
+    if agent_config is None:
+        try:
+            if CONFIG_AVAILABLE:
+                agent_config = get_agent_config()
+            else:
+                agent_config = {}
+        except:
+            agent_config = {}
+    
+    web_search_config = agent_config.get("web_search", {})
+    safety_config = web_search_config.get("safety_filter", {})
+    
+    # Check if safety filter is enabled (default: True)
+    if not safety_config.get("enabled", True):
+        return True, "Safety filter disabled"
+    
+    # Load blocked keywords and patterns
+    blocked_keywords = safety_config.get("blocked_keywords", [])
+    blocked_patterns = safety_config.get("blocked_patterns", [])
+    
+    # Normalize query for checking
+    query_lower = query.lower().strip()
+    
+    # Check blocked keywords
+    for keyword in blocked_keywords:
+        if keyword.lower() in query_lower:
+            logger.warning(f"[AGENT] 🚫 Safety filter blocked query: contains blocked keyword '{keyword}'")
+            return False, f"Query contains blocked keyword: {keyword}"
+    
+    # Check blocked patterns (regex)
+    import re
+    for pattern_obj in blocked_patterns:
+        pattern = pattern_obj.get("pattern", "") if isinstance(pattern_obj, dict) else pattern_obj
+        if not pattern:
+            continue
+        
+        try:
+            if re.search(pattern, query_lower, re.IGNORECASE):
+                desc = pattern_obj.get("description", "harmful pattern") if isinstance(pattern_obj, dict) else "harmful pattern"
+                logger.warning(f"[AGENT] 🚫 Safety filter blocked query: matches blocked pattern '{desc}'")
+                return False, f"Query matches blocked pattern: {desc}"
+        except re.error as e:
+            logger.warning(f"[AGENT] ⚠️ Invalid regex pattern in safety config: {pattern}, error: {e}")
+            continue
+    
+    # Query passed all safety checks
+    return True, "Query is safe"
+
+
 # Define Google Search function first (doesn't require DDGS imports)
-def web_search_google(query: str, max_results: int = 5) -> str:
+def web_search_google(query: str, max_results: int = 5, agent_config: dict = None) -> str:
     """
     Search using Google Custom Search API (requires API key - free tier: 100 queries/day)
     Returns better, more relevant results than DuckDuckGo
+    
+    Args:
+        query: Search query string
+        max_results: Maximum number of results (default: 5)
+        agent_config: Optional agent configuration dict (if None, uses defaults)
     """
     if not USE_GOOGLE_SEARCH:
         return None
     
+    # Load config for safety check and news detection
+    if agent_config is None:
+        try:
+            if CONFIG_AVAILABLE:
+                agent_config = get_agent_config()
+            else:
+                agent_config = {}
+        except:
+            agent_config = {}
+    
+    # Safety check - block harmful queries before searching
+    is_safe, safety_reason = is_safe_search_query(query, agent_config)
+    if not is_safe:
+        web_search_config = agent_config.get("web_search", {})
+        safety_config = web_search_config.get("safety_filter", {})
+        blocked_message = safety_config.get("blocked_response_message", 
+            "I cannot search for content that may involve harmful, illegal, or inappropriate material. Please try a different query.")
+        logger.warning(f"[AGENT] 🚫 Safety filter blocked Google search: {safety_reason}")
+        return f"⚠️ {blocked_message}"
+    
     try:
         import requests
         
+        web_search_config = agent_config.get("web_search", {})
+        news_keywords = web_search_config.get("news_query_keywords", ["news", "headlines", "headline", "breaking"])
+        meta_filter_phrases = web_search_config.get("meta_page_filter_phrases", [
+            "provides", "offers", "visit", "check", "read", "explore", "go to", 
+            "subscribe", "newsletter", "website", "at cnn", "at fox", "at bbc"
+        ])
+        safety_config = web_search_config.get("safety_filter", {})
+        safe_search_enabled = safety_config.get("safe_search_enabled", True)
+        
         # Google Custom Search API endpoint
         url = "https://www.googleapis.com/customsearch/v1"
         params = {
@@ -119,34 +429,136 @@ def web_search_google(query: str, max_results: int = 5) -> str:
             "num": min(max_results, 10)  # Google allows max 10 per request
         }
         
+        # Enable safe search (filters explicit content)
+        if safe_search_enabled:
+            safe_search_param = safety_config.get("safe_search_param", "safe=active")
+            # Google API uses "safe" parameter with values: "active", "off", "high"
+            params["safe"] = "active"
+        
         logger.info(f"[AGENT] 🔍 Google Custom Search API call: query='{query}', max_results={max_results}")
         response = requests.get(url, params=params, timeout=10)
+        
+        # Handle HTTP errors with detailed diagnostics
+        if response.status_code == 429:
+            # Quota exceeded (100 queries/day free tier limit reached)
+            error_data = response.json() if response.content else {}
+            error_message = error_data.get("error", {}).get("message", "Quota exceeded")
+            logger.warning(f"[AGENT] ⚠️ Google Search API 429 - Daily quota exceeded (free tier: 100 queries/day)")
+            logger.warning(f"[AGENT]   Error: {error_message}")
+            logger.info(f"[AGENT]   → Auto-fallback to DuckDuckGo (free, unlimited)")
+            # Return special marker to trigger fallback
+            return "QUOTA_EXCEEDED"
+        
+        elif response.status_code == 403:
+            # Forbidden - could be quota, API not enabled, or billing issue
+            error_data = response.json() if response.content else {}
+            error_message = error_data.get("error", {}).get("message", "Forbidden")
+            error_code = error_data.get("error", {}).get("code", 0)
+            
+            # Check if it's a quota issue (sometimes 403 is used for quota)
+            if "quota" in error_message.lower() or "quotaExceeded" in str(error_data):
+                logger.warning(f"[AGENT] ⚠️ Google Search API 403 - Quota exceeded (free tier: 100 queries/day)")
+                logger.info(f"[AGENT]   → Auto-fallback to DuckDuckGo (free, unlimited)")
+                return "QUOTA_EXCEEDED"
+            else:
+                logger.error(f"[AGENT] ❌ Google Search API 403 Forbidden - Possible causes:")
+                logger.error(f"[AGENT]   1. API not enabled in Google Cloud Console")
+                logger.error(f"[AGENT]   2. Billing account required (even for free tier)")
+                logger.error(f"[AGENT]   3. API key restricted to wrong HTTP referrers (should be unrestricted for server-side)")
+                logger.error(f"[AGENT]   4. Daily quota exceeded (free tier: 100 queries/day)")
+                logger.error(f"[AGENT]   Error: {error_message}")
+                logger.info(f"[AGENT]   → Falling back to DuckDuckGo (free, unlimited)")
+                # Fallback to DuckDuckGo even for other 403 errors
+                return None
+        
+        elif response.status_code == 401:
+            # Unauthorized - invalid API key
+            error_data = response.json() if response.content else {}
+            error_message = error_data.get("error", {}).get("message", "Unauthorized")
+            logger.error(f"[AGENT] ❌ Google Search API 401 Unauthorized - Invalid API key")
+            logger.error(f"[AGENT]   Error: {error_message}")
+            logger.error(f"[AGENT]   → Check GOOGLE_CUSTOM_SEARCH_API_KEY in environment variables")
+            logger.info(f"[AGENT]   → Falling back to DuckDuckGo")
+            return None
+        
+        elif response.status_code == 400:
+            # Bad request - invalid parameters
+            error_data = response.json() if response.content else {}
+            error_message = error_data.get("error", {}).get("message", "Bad request")
+            logger.error(f"[AGENT] ❌ Google Search API 400 Bad Request")
+            logger.error(f"[AGENT]   Error: {error_message}")
+            logger.error(f"[AGENT]   → Check query parameters and Search Engine ID")
+            logger.info(f"[AGENT]   → Falling back to DuckDuckGo")
+            return None
+        
+        # Raise for other HTTP errors
         response.raise_for_status()
         
+        # Parse successful response
         data = response.json()
         items = data.get("items", [])
         
         logger.info(f"[AGENT] 📥 Google Search API returned {len(items)} results")
         
         if not items:
+            logger.info(f"[AGENT] ℹ️ Google Search returned no results - falling back to DuckDuckGo")
             return None
         
-        # Format results for model
-        formatted = f"Web search results for '{query}':\n\n"
+        # Format results for model - prioritize headlines for news queries
+        query_lower = query.lower()
+        is_news_query = any(kw in query_lower for kw in news_keywords)
+        
+        if is_news_query:
+            formatted = f"Today's News Headlines:\n\n"
+        else:
+            formatted = f"Web search results for '{query}':\n\n"
+        
         for i, item in enumerate(items[:max_results], 1):
             title = item.get("title", "No title")
             snippet = item.get("snippet", "No description")
             link = item.get("link", "")
-            formatted += f"{i}. {title}\n   {snippet[:200]}...\n   Source: {link}\n\n"
+            
+            # For news queries, prioritize title (often contains the headline) and filter out meta descriptions
+            if is_news_query:
+                # Filter out results that are just about news sources (meta pages)
+                title_lower = title.lower()
+                snippet_lower = snippet.lower()
+                is_meta_page = any(phrase in title_lower or phrase in snippet_lower for phrase in meta_filter_phrases)
+                
+                # If it's not a meta page, include it as a headline
+                if not is_meta_page and title and title != "No title":
+                    # Use title as headline, snippet as content if it contains actual news
+                    if snippet and len(snippet) > 50 and not snippet_lower.startswith("view") and not snippet_lower.startswith("visit"):
+                        formatted += f"{i}. {title}\n   {snippet[:300]}\n   Source: {link}\n\n"
+                    else:
+                        formatted += f"{i}. {title}\n   Source: {link}\n\n"
+                elif snippet and len(snippet) > 100 and any(word in snippet_lower for word in ["announced", "reported", "said", "according", "breaking", "developing"]):
+                    # Snippet contains actual news content - use it
+                    formatted += f"{i}. {snippet[:300]}\n   Source: {link}\n\n"
+            else:
+                # Regular search results formatting
+                formatted += f"{i}. {title}\n   {snippet[:200]}...\n   Source: {link}\n\n"
         
         formatted_response = formatted.strip()
         logger.info(f"[AGENT] ✅ Google search formatted response: {len(formatted_response)} chars")
+        if is_news_query:
+            logger.debug(f"[AGENT] 📰 News query - formatted for headline extraction")
         return formatted_response
         
+    except requests.exceptions.RequestException as e:
+        # Network/connection errors
+        logger.error(f"[AGENT] ❌ Google Search API network error: {e}")
+        logger.info(f"[AGENT]   → Falling back to DuckDuckGo")
+        import traceback
+        logger.debug(f"[AGENT] Google search traceback: {traceback.format_exc()}")
+        return None
     except Exception as e:
-        logger.error(f"[AGENT] ❌ Google Search API error: {e}")
+        # Other unexpected errors
+        error_msg = str(e)
+        logger.error(f"[AGENT] ❌ Google Search API unexpected error: {e}")
+        logger.info(f"[AGENT]   → Falling back to DuckDuckGo")
         import traceback
-        logger.error(f"[AGENT] Google search traceback: {traceback.format_exc()}")
+        logger.debug(f"[AGENT] Google search traceback: {traceback.format_exc()}")
         return None
 
 # Initialize DDGS availability flag
@@ -168,7 +580,7 @@ try:
             DDGS_AVAILABLE = False
             logger.warning("[AGENT] ⚠️ Neither ddgs nor duckduckgo_search available")
     
-    def web_search(query: str, max_results: int = 5) -> str:
+    def web_search(query: str, max_results: int = 5, agent_config: dict = None) -> str:
         """
         Search the web for current information.
         Uses Google Custom Search API if available (better results), otherwise DuckDuckGo (free).
@@ -177,17 +589,54 @@ try:
         Args:
             query: Search query string
             max_results: Maximum number of results to return (default: 5)
+            agent_config: Optional agent configuration dict (for news detection and filtering)
         
         Returns:
             Formatted search results as a string (or None if no results)
         """
+        # Load config for safety check and news detection
+        if agent_config is None:
+            try:
+                if CONFIG_AVAILABLE:
+                    agent_config = get_agent_config()
+                else:
+                    agent_config = {}
+            except:
+                agent_config = {}
+        
+        # Safety check - block harmful queries before searching
+        is_safe, safety_reason = is_safe_search_query(query, agent_config)
+        if not is_safe:
+            web_search_config = agent_config.get("web_search", {})
+            safety_config = web_search_config.get("safety_filter", {})
+            blocked_message = safety_config.get("blocked_response_message", 
+                "I cannot search for content that may involve harmful, illegal, or inappropriate material. Please try a different query.")
+            logger.warning(f"[AGENT] 🚫 Safety filter blocked web search: {safety_reason}")
+            return f"⚠️ {blocked_message}"
+        
+        web_search_config = agent_config.get("web_search", {})
+        news_keywords = web_search_config.get("news_query_keywords", ["news", "headlines", "headline", "breaking"])
+        meta_filter_phrases = web_search_config.get("meta_page_filter_phrases", [
+            "provides", "offers", "visit", "check", "read", "explore", "go to", 
+            "subscribe", "newsletter", "website", "at cnn", "at fox", "at bbc"
+        ])
+        
         # Try Google Custom Search first (if API key configured - better results)
         if USE_GOOGLE_SEARCH:
             logger.info("[AGENT] 🔍 Using Google Custom Search API (AI-enhanced results)")
-            google_results = web_search_google(query, max_results)
-            if google_results:
+            google_results = web_search_google(query, max_results, agent_config)
+            
+            # Check if quota exceeded (special marker)
+            if google_results == "QUOTA_EXCEEDED":
+                logger.warning("[AGENT] ⚠️ Google Search quota exceeded (100 queries/day free tier limit)")
+                logger.info("[AGENT]   → Automatically falling back to DuckDuckGo (free, unlimited)")
+                # Continue to DuckDuckGo fallback below
+            elif google_results:
+                # Success - return Google results
                 return google_results
-            logger.warning("[AGENT] ⚠️ Google Search returned no results, falling back to DuckDuckGo")
+            else:
+                # No results or error - fallback to DuckDuckGo
+                logger.info("[AGENT] ℹ️ Google Search returned no results or error, falling back to DuckDuckGo")
         
         # Fallback to DuckDuckGo (free, no API key needed)
         if not DDGS_AVAILABLE:
@@ -236,6 +685,13 @@ try:
                         if ' and ' in query.lower():
                             logger.info(f"[AGENT] 🔄 Trying simpler query (splitting on 'and')...")
                             simpler_query = query.split(' and ', 1)[0].strip()
+                            
+                            # Safety check for retry query as well
+                            is_safe_retry, safety_reason_retry = is_safe_search_query(simpler_query, agent_config)
+                            if not is_safe_retry:
+                                logger.warning(f"[AGENT] 🚫 Safety filter blocked retry query: {safety_reason_retry}")
+                                return f"⚠️ {blocked_message}"
+                            
                             logger.info(f"[AGENT] 🔄 Retry with query: '{simpler_query}'")
                             time.sleep(0.5)  # Add delay for retry
                             results = list(ddgs.text(simpler_query, max_results=max_results))
@@ -245,19 +701,67 @@ try:
                         logger.warning(f"[AGENT] ⚠️ No search results found after all attempts for: {query}")
                         return f"No results found for: {query}"
                     
-                    # Format results for model
-                    formatted = f"Web search results for '{query}':\n\n"
+                    # Format results for model - prioritize headlines for news queries (using config values)
+                    query_lower = query.lower()
+                    is_news_query = any(kw in query_lower for kw in news_keywords)
+                    
+                    if is_news_query:
+                        formatted = f"Today's News Headlines:\n\n"
+                    else:
+                        formatted = f"Web search results for '{query}':\n\n"
+                    
                     for i, result in enumerate(results, 1):
                         title = result.get('title', 'No title')
                         snippet = result.get('body', 'No description')
                         url = result.get('href', result.get('url', ''))
-                        if url:
-                            formatted += f"{i}. {title}\n   {snippet[:200]}...\n   Source: {url}\n\n"
+                        
+                        # For news queries, prioritize actual headlines over source descriptions (using config filter phrases)
+                        if is_news_query:
+                            title_lower = title.lower()
+                            snippet_lower = snippet.lower() if snippet else ""
+                            
+                            # Filter out meta pages about news sources (using config values)
+                            is_meta_page = any(phrase in title_lower or phrase in snippet_lower for phrase in meta_filter_phrases)
+                            
+                            # Skip meta pages, focus on actual news content
+                            if is_meta_page:
+                                continue  # Skip this result
+                            
+                            # Use title as headline if it contains actual news
+                            if title and title != "No title" and len(title) > 10:
+                                if snippet and len(snippet) > 50:
+                                    # Check if snippet contains actual news content (not just "visit website")
+                                    if not snippet_lower.startswith(("visit", "check", "read", "go to", "explore", "view", "subscribe")):
+                                        formatted += f"{i}. {title}\n   {snippet[:300]}\n"
+                                        if url:
+                                            formatted += f"   Source: {url}\n\n"
+                                        else:
+                                            formatted += "\n"
+                                    else:
+                                        # Title is good, snippet is meta - use just title
+                                        formatted += f"{i}. {title}\n"
+                                        if url:
+                                            formatted += f"   Source: {url}\n\n"
+                                        else:
+                                            formatted += "\n"
+                                else:
+                                    # Only title available
+                                    formatted += f"{i}. {title}\n"
+                                    if url:
+                                        formatted += f"   Source: {url}\n\n"
+                                    else:
+                                        formatted += "\n"
                         else:
-                            formatted += f"{i}. {title}\n   {snippet[:200]}...\n\n"
+                            # Regular search results formatting
+                            if url:
+                                formatted += f"{i}. {title}\n   {snippet[:200] if snippet else 'No description'}...\n   Source: {url}\n\n"
+                            else:
+                                formatted += f"{i}. {title}\n   {snippet[:200] if snippet else 'No description'}...\n\n"
                     
                     formatted_response = formatted.strip()
                     logger.info(f"[AGENT] ✅ Web search formatted response: {len(formatted_response)} chars")
+                    if is_news_query:
+                        logger.debug(f"[AGENT] 📰 News query - formatted for headline extraction (filtered meta pages)")
                     logger.debug(f"[AGENT] 📝 Formatted response preview (first 500 chars):\n{formatted_response[:500]}...")
                     
                     return formatted_response
@@ -406,9 +910,15 @@ class MeeTARAAgent:
         needs = {"calculator": False, "web_search": False, "calc_expression": None, "search_query": None}
         
         # Check for math/calculation needs
-        # Load patterns from config or use defaults
+        # First check keywords (faster), then patterns (more specific)
         query_lower = query.lower()
         calculator_config = self.agent_config.get("calculator", {})
+        calculator_keywords_config = calculator_config.get("keywords", [])
+        
+        # Check for calculator keywords first
+        matched_calc_keywords = [kw for kw in calculator_keywords_config if kw in query_lower]
+        
+        # Load patterns from config
         math_patterns_config = calculator_config.get("math_patterns", [])
         
         # Extract patterns from config (list of dicts with "pattern" key) or use defaults
@@ -422,6 +932,7 @@ class MeeTARAAgent:
                 r'\b(sqrt|square root|power|exponent)\s*\(?\s*([0-9]+)\s*\)?',
             ]
         
+        # Try pattern matching first (more specific)
         for pattern in math_patterns:
             match = re.search(pattern, query, re.IGNORECASE)
             if match:
@@ -429,7 +940,7 @@ class MeeTARAAgent:
                 # Extract the expression - try all groups
                 expr = None
                 for i in range(1, len(match.groups()) + 1):
-                    if match.group(i) and re.search(r'[0-9+\-*/().×÷]', match.group(i)):
+                    if match.group(i) and re.search(r'[0-9+\-*/().×÷%]', match.group(i)):
                         expr = match.group(i).strip()
                         break
                 
@@ -438,12 +949,42 @@ class MeeTARAAgent:
                     expr = expr.replace('×', '*').replace('÷', '/')
                     needs["calc_expression"] = expr
                 else:
-                    # Fallback: extract numbers with operators from the match
-                    numbers_ops = re.search(r'([0-9+\-*/().\s]+)', match.group(0))
-                    if numbers_ops:
-                        needs["calc_expression"] = numbers_ops.group(1).strip().replace('×', '*').replace('÷', '/')
+                    # For geometry/percentage queries without explicit expression, extract full query as context
+                    if any(geo in query_lower for geo in ["surface area", "area of", "volume of", "perimeter", "circumference", "% of"]):
+                        # Geometry or percentage query - extract numbers from query for context
+                        numbers = re.findall(r'[0-9]+(?:\.[0-9]+)?', query)
+                        if numbers:
+                            needs["calc_expression"] = " ".join(numbers)  # Pass numbers as context
+                        else:
+                            needs["calc_expression"] = query  # Pass full query as context
+                    else:
+                        # Fallback: extract numbers with operators from the match
+                        numbers_ops = re.search(r'([0-9+\-*/().\s]+)', match.group(0))
+                        if numbers_ops:
+                            needs["calc_expression"] = numbers_ops.group(1).strip().replace('×', '*').replace('÷', '/')
                 break
         
+        # If no pattern match but keywords found and numbers present, still flag as calculator
+        if not needs["calculator"] and matched_calc_keywords:
+            # Check if query contains numbers (likely a math query)
+            has_numbers = bool(re.search(r'[0-9]+', query))
+            # Check for geometry keywords
+            has_geometry = any(geo in query_lower for geo in ["surface area", "area of", "volume of", "perimeter", "circumference"])
+            # Check for percentage keywords
+            has_percentage = "%" in query or "percent" in query_lower or "percentage" in query_lower
+            # Check for division keywords
+            has_division = any(div in query_lower for div in ["divided by", "divided", "divide"])
+            
+            if has_numbers and (has_geometry or has_percentage or has_division or any(kw in ["calculate", "compute", "what is", "what's", "find", "find the"] for kw in matched_calc_keywords)):
+                needs["calculator"] = True
+                logger.info(f"[AGENT] 🔍 Calculator detected via keywords: {matched_calc_keywords}")
+                # Extract numbers for context
+                numbers = re.findall(r'[0-9]+(?:\.[0-9]+)?', query)
+                if numbers:
+                    needs["calc_expression"] = " ".join(numbers) if len(numbers) <= 3 else query[:100]
+                else:
+                    needs["calc_expression"] = query[:100]  # Pass query as context
+        
         # Check for web search needs
         # Load keywords and patterns from config
         web_search_config = self.agent_config.get("web_search", {})
@@ -609,6 +1150,36 @@ class MeeTARAAgent:
                 search_q = tool_needs["search_query"] or query
                 logger.info(f"[AGENT] 🔍 Extracted search query: '{search_q}' (original: '{query[:100]}')")
                 
+                # Load news detection keywords from config
+                web_search_config = self.agent_config.get("web_search", {})
+                news_keywords = web_search_config.get("news_query_keywords", ["news", "headlines", "headline", "breaking"])
+                news_enhancement_keywords = web_search_config.get("news_enhancement_keywords", ["headlines", "breaking", "latest"])
+                
+                # Detect news/headlines queries using config keywords
+                query_lower = query.lower()
+                search_q_lower = search_q.lower()
+                is_news_query = any(keyword in query_lower for keyword in news_keywords)
+                
+                # Enhance news queries to get actual headlines, not just source pages
+                if is_news_query:
+                    # Remove question marks and question words that might reduce relevance
+                    enhanced_search = re.sub(r'[?]', '', search_q)
+                    enhanced_search = re.sub(r'^(what are|what is|what\'s|tell me|show me|find me)\s+', '', enhanced_search, flags=re.IGNORECASE)
+                    enhanced_search = enhanced_search.strip()
+                    
+                    # For generic news queries, add specific keywords to get actual headlines (using config)
+                    if any(gen in search_q_lower for gen in ["today's", "today", "top news", "breaking news", "latest news", "news headlines", "headlines"]):
+                        # Already contains news keywords - keep as is but enhance using config
+                        if "headlines" not in search_q_lower and "headline" not in search_q_lower:
+                            if any(kw in news_enhancement_keywords for kw in ["headlines", "headline"]):
+                                enhanced_search = f"{enhanced_search} headlines"
+                        if "breaking" not in search_q_lower and "latest" not in search_q_lower:
+                            if "latest" in news_enhancement_keywords:
+                                enhanced_search = f"latest {enhanced_search}"
+                    
+                    search_q = enhanced_search
+                    logger.info(f"[AGENT] 📰 Enhanced news query: '{search_q}' (for better headline results)")
+                
                 # Validate search query before calling API
                 search_q_lower = search_q.lower().strip()
                 if (search_q_lower.startswith('and ') or 
@@ -623,7 +1194,8 @@ class MeeTARAAgent:
                     if search_q and 'custom_web_search' in globals() and custom_web_search is not None:
                         max_results = self.agent_config.get("web_search", {}).get("max_results", 5)
                         logger.info(f"[AGENT] 🌐 Web search API call: query='{search_q}', max_results={max_results}")
-                        search_result = custom_web_search(search_q, max_results=max_results)
+                        # Pass agent_config to web_search for news detection and filtering
+                        search_result = custom_web_search(search_q, max_results=max_results, agent_config=self.agent_config)
                         
                         # Check if search actually returned valid results (not "No results found" or error)
                         has_results = (search_result and 
@@ -656,13 +1228,34 @@ class MeeTARAAgent:
             # The model already has structured format (🎯, 📊, ⚡, 💡) built-in via meetara_lab_core.py
             # Just feed tool results - model will automatically structure the response
             if tool_results:
+                # Load news query keywords and instruction templates from config
+                web_search_config = self.agent_config.get("web_search", {})
+                news_query_config = web_search_config.get("news_query_instructions", {})
+                news_keywords = web_search_config.get("news_query_keywords", ["news", "headlines", "headline", "breaking"])
+                
+                # Detect if this is a news/headlines query using config keywords
+                query_lower = query.lower()
+                is_news_query = any(keyword in query_lower for keyword in news_keywords)
+                
+                # Build context-aware instructions from config
+                if is_news_query and news_query_config.get("enabled", True):
+                    instruction_text = news_query_config.get("instruction_template", 
+                        "CRITICAL: Extract and list the ACTUAL NEWS HEADLINES and STORIES from the search results above. "
+                        "Do NOT just describe what news sources offer - provide the REAL NEWS HEADLINES and CONTENT."
+                    )
+                    logger.info(f"[AGENT] 📰 News query detected - using config-based instructions for headline extraction")
+                else:
+                    instruction_text = news_query_config.get("regular_instruction", "Use the tool results above to provide your response.")
+                
                 enhanced_prompt = (
                     f"{query}\n\n"
                     f"=== Tool Results ===\n"
                     + "\n\n".join(tool_results) + 
-                    f"\n\nUse the tool results above to provide your response."
+                    f"\n\n{instruction_text}"
                 )
                 logger.info(f"[AGENT] 📝 Feeding {len(tool_results)} tool results to model (model will auto-format)")
+                if is_news_query:
+                    logger.info(f"[AGENT] 📰 News query detected - instructing model to extract actual headlines")
                 logger.debug(f"[AGENT] 📤 Enhanced prompt to model (first 1000 chars):\n{enhanced_prompt[:1000]}...")
                 
                 # Log full tool results being fed to model