Upd MCP search max global

agent.py

@@ -36,6 +36,8 @@ except ImportError:
     print("Error: google-genai not installed. Install with: pip install google-genai", file=sys.stderr)
     sys.exit(1)
 
+from supervisor import MAX_SEARCH_STRATEGIES
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -203,6 +205,25 @@ async def list_tools() -> list[Tool]:
                     },
                     "required": ["text"]
                 }
+            ),
+            Tool(
+                name="search_web",
+                description="Search the web for information. Returns search results with titles, URLs, and content snippets.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "Search query string (required)"
+                        },
+                        "max_results": {
+                            "type": "integer",
+                            "description": "Maximum number of results to return (optional, defaults to 5)",
+                            "default": MAX_SEARCH_STRATEGIES
+                        }
+                    },
+                    "required": ["query"]
+                }
             )
         ]
         return tools
@@ -426,6 +447,82 @@ async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageC
         except Exception as e:
             logger.error(f"Error in text_to_speech: {e}")
             return [TextContent(type="text", text=f"Error: {str(e)}")]
+    elif name == "search_web":
+        try:
+            query = arguments.get("query")
+            if not query:
+                logger.error("❌ query is required but missing")
+                return [TextContent(type="text", text="Error: query is required")]
+            
+            max_results = int(arguments.get("max_results", MAX_SEARCH_STRATEGIES))
+            
+            # Use DuckDuckGo for web search
+            try:
+                from ddgs import DDGS
+                import requests
+                from bs4 import BeautifulSoup
+            except ImportError:
+                logger.error("DuckDuckGo dependencies not available (ddgs, requests, beautifulsoup4)")
+                return [TextContent(type="text", text="Error: Web search dependencies not available")]
+            
+            logger.info(f"🔵 Performing web search for: {query[:100]}...")
+            
+            try:
+                with DDGS() as ddgs:
+                    results = list(ddgs.text(query, max_results=max_results))
+                    web_content = []
+                    for result in results:
+                        try:
+                            url = result.get('href', '')
+                            title = result.get('title', '')
+                            snippet = result.get('body', '')
+                            
+                            try:
+                                response = requests.get(url, timeout=5, headers={'User-Agent': 'Mozilla/5.0'})
+                                if response.status_code == 200:
+                                    soup = BeautifulSoup(response.content, 'html.parser')
+                                    for script in soup(["script", "style"]):
+                                        script.decompose()
+                                    text = soup.get_text()
+                                    lines = (line.strip() for line in text.splitlines())
+                                    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+                                    text = ' '.join(chunk for chunk in chunks if chunk)
+                                    if len(text) > 1000:
+                                        text = text[:1000] + "..."
+                                    web_content.append({
+                                        'title': title,
+                                        'url': url,
+                                        'content': snippet + "\n" + text[:500] if text else snippet
+                                    })
+                                else:
+                                    web_content.append({
+                                        'title': title,
+                                        'url': url,
+                                        'content': snippet
+                                    })
+                            except:
+                                web_content.append({
+                                    'title': title,
+                                    'url': url,
+                                    'content': snippet
+                                })
+                        except Exception as e:
+                            logger.error(f"Error processing search result: {e}")
+                            continue
+                    
+                    # Return results as JSON string
+                    results_json = json.dumps(web_content, indent=2)
+                    logger.info(f"✅ Web search completed: {len(web_content)} results")
+                    return [TextContent(type="text", text=results_json)]
+            except Exception as e:
+                logger.error(f"❌ Web search error: {type(e).__name__}: {e}")
+                import traceback
+                logger.debug(f"Full traceback: {traceback.format_exc()}")
+                return [TextContent(type="text", text=f"Error: {str(e)}")]
+                
+        except Exception as e:
+            logger.error(f"Error in search_web: {e}")
+            return [TextContent(type="text", text=f"Error: {str(e)}")]
     else:
         return [TextContent(type="text", text=f"Unknown tool: {name}")]
 

search.py

@@ -11,8 +11,9 @@ try:
 except ImportError:
     nest_asyncio = None
 
+from supervisor import MAX_SEARCH_STRATEGIES
 
-async def search_web_mcp_tool(query: str, max_results: int = 5) -> list:
+async def search_web_mcp_tool(query: str, max_results: int = MAX_SEARCH_STRATEGIES) -> list:
     """Search web using MCP web search tool (e.g., DuckDuckGo MCP server)"""
     if not MCP_AVAILABLE:
         return []
@@ -97,7 +98,7 @@ async def search_web_mcp_tool(query: str, max_results: int = 5) -> list:
         return []
 
 
-async def search_web_mcp(query: str, max_results: int = 5) -> list:
+async def search_web_mcp(query: str, max_results: int = MAX_SEARCH_STRATEGIES) -> list:
     """Search web using MCP tools - tries web search MCP tool first, then falls back to direct search"""
     results = await search_web_mcp_tool(query, max_results)
     if results:
@@ -108,7 +109,7 @@ async def search_web_mcp(query: str, max_results: int = 5) -> list:
     return search_web_fallback(query, max_results)
 
 
-def search_web_fallback(query: str, max_results: int = 5) -> list:
+def search_web_fallback(query: str, max_results: int = MAX_SEARCH_STRATEGIES) -> list:
     """Fallback web search using DuckDuckGo directly (when MCP is not available)"""
     logger.info(f"🔍 [Direct API] Performing web search using DuckDuckGo API for: {query[:100]}...")
     try: