Update rich tool: bugifx,

- update prompts
- update providers

agents/single_agent.py

@@ -8,7 +8,7 @@ from smolagents import CodeAgent, VisitWebpageTool, FinalAnswerTool, DuckDuckGoS
 from config import load_prompt_templates
 from tools.analysis_tools import AnalyzeLyricsTool
 from tools.formatting_tools import FormatAnalysisResultsTool
-from tools.search_tools import ThrottledDuckDuckGoSearchTool
+from tools.search_tools import ThrottledDuckDuckGoSearchTool, BraveSearchTool
 
 
 def create_single_agent(model):
@@ -27,12 +27,12 @@ def create_single_agent(model):
     # Example usage within the agent
     agent = CodeAgent(
         tools=[
-            FinalAnswerTool(),
-            DuckDuckGoSearchTool(),
+            BraveSearchTool(),
             # ThrottledDuckDuckGoSearchTool(min_delay=7.0, max_delay=15.0),
             VisitWebpageTool(),
             AnalyzeLyricsTool(),
-            FormatAnalysisResultsTool()
+            FormatAnalysisResultsTool(),
+            FinalAnswerTool(),
         ],
         model=model,
         additional_authorized_imports=['numpy', 'bs4', 'rich'],

api_utils.py

@@ -40,6 +40,32 @@ def make_api_call_with_retry(model: str, prompt: str) -> str:
                 model=model,
                 messages=[{"role": "user", "content": prompt}],
                 num_retries=2,  # Built-in retry mechanism of LiteLLM
+                response_format={
+                    "type": "json_object",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "summary": {"type": "string", "description": "Overall analysis of the song vibes, meaning and mood"},
+                            "main_themes": {"type": "array", "items": {"type": "string"}, "description": "Main themes identified in the song"},
+                            "mood": {"type": "string", "description": "The overall mood/emotion of the song"},
+                            "sections_analysis": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "section_type": {"type": "string", "description": "verse/chorus/bridge/etc."},
+                                        "section_number": {"type": "integer", "description": "Sequential number of this section type"},
+                                        "lines": {"type": "array", "items": {"type": "string"}, "description": "Lyrics of this section"},
+                                        "analysis": {"type": "string", "description": "Analysis of this section with respect to the overall theme"}
+                                    },
+                                    "required": ["section_type", "section_number", "lines", "analysis"]
+                                }
+                            },
+                            "conclusion": {"type": "string", "description": "The song vibes and concepts of the underlying meaning, including ideas author may have intended to express"}
+                        },
+                        "required": ["summary", "main_themes", "mood", "sections_analysis", "conclusion"]
+                    }
+                }
             )
 
             # Try to extract the content from the response

config.py

@@ -26,7 +26,7 @@ def load_api_keys():
     os.environ["GEMINI_API_KEY"] = os.getenv("GEMINI_API_KEY")
     
 
-def get_model_id(use_local=True, provider="gemini"):
+def get_model_id(provider="gemini"):
     """Get the appropriate model ID based on configuration.
     
     Args:
@@ -38,14 +38,15 @@ def get_model_id(use_local=True, provider="gemini"):
         String with model ID for the specified provider.
     """
     if provider == "ollama":
-        return "ollama/gemma3:4b"  # Using local Ollama with Gemma 3:4B
+        # return "ollama/gemma3:4b"  # Using local Ollama with Gemma 3:4B
+        return "ollama/qwen2.5-coder:7b"
     elif provider == "gemini":
         return "gemini/gemini-2.0-flash"
     elif provider == "openrouter":
         return "openrouter/google/gemini-2.0-flash-lite-preview-02-05:free"  # OpenRouter Claude 3 Opus
-    else:
-        # Default fallback
-        return "ollama/gemma3:4b" if use_local else "gemini/gemini-2.0-flash"
+        # return "openrouter/mistralai/mistral-small-3.1-24b-instruct:free"
+        #return "openrouter/rekaai/reka-flash-3:free"
+        # return "openrouter/deepseek/deepseek-chat:free"
 
 def get_ollama_api_base():
     """Get the API base URL for Ollama."""

run_single_agent.py

@@ -14,16 +14,12 @@ os.environ["GEMINI_API_KEY"] = str(os.getenv("GEMINI_API_KEY"))
 
 use_local = False
 
-# If using Ollama, we need to specify the API base URL
-# Initialize the LLM model based on configuration
-if use_local:
-    model_id = "openrouter/google/gemini-2.0-flash-lite-preview-02-05:free"
-else:
-    model_id = get_model_id(use_local=use_local)
-
+model_id = get_model_id(provider='openrouter')
 logger.info(f"Initializing with model: {model_id}")
 
 if use_local:
+    # If using Ollama, we need to specify the API base URL
+    # Initialize the LLM model based onx configuration
     api_base = get_ollama_api_base()
     logger.info(f"Using Ollama API base: {api_base}")
     model = LiteLLMModel(model_id=model_id, api_base=api_base)
@@ -34,12 +30,12 @@ else:
 # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
 
 # Prompt the user for the song name
-song_data = "John Frusciante - Crowded"
+song_data = "Felix Da Housecat - Everyone is someone in LA"
 
 agent = create_single_agent(model)
-
+prompt = f"""1. Find and extract the lyrics of the song: {song_data}.
+2. Perform deep lyrics analysis and return full lyrics and analysis results 
+  in a pretty human-readable format.
+"""
 # Agent execution
-agent.run(f"""
-1. Find and extract the lyrics of the song, {song_data}. Don't try to scrape from azlyrics.com or genius.com, others are ok.
-2. Perform deep lyrics analysis and return full lyrics and analysis results in a pretty human-readable format.
-""")
+agent.run(prompt)

tools/analysis_tools.py

@@ -4,6 +4,8 @@ Analysis tools for understanding and interpreting song lyrics.
 
 from loguru import logger
 from smolagents import Tool
+import json
+from typing import Dict
 
 from api_utils import make_api_call_with_retry
 
@@ -67,11 +69,23 @@ class AnalyzeLyricsTool(Tool):
         {lyrics}
         """
 
-        model_to_use = "gemini/gemini-2.0-flash"
-        logger.info("Using Gemini model: {} for lyrics analysis", model_to_use)
+        # model_to_use = "gemini/gemini-2.0-flash"
+        model_to_use = "openrouter/google/gemini-2.0-flash-lite-preview-02-05:free"
+        logger.info("Using {} for lyrics analysis", model_to_use)
 
         # Use the function with retry mechanism
         logger.info("Analyzing lyrics for song: '{}' by '{}'", song_title, artist)
-        response = make_api_call_with_retry(model_to_use, prompt)
-        return response
+        response_text = make_api_call_with_retry(model_to_use, prompt)
+        
+        try:
+            # Parse the string response into a JSON object (dictionary)
+            logger.debug(f"Parsing JSON response for {song_title}")
+            response_json = json.loads(response_text)
+            return response_json
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse lyrics analysis response as JSON: {str(e)}")
+            # Return the raw text response if parsing fails
+            # This will likely cause an error in the formatting step,
+            # but at least we'll have the raw output for debugging
+            return response_text
 

tools/formatting_tools.py

@@ -3,6 +3,8 @@ Formatting tools for displaying analysis results with rich formatting.
 """
 
 import json
+import traceback
+from typing import Dict, Any, List, Union
 from loguru import logger
 from smolagents import Tool
 from rich.console import Console
@@ -25,205 +27,220 @@ class FormatAnalysisResultsTool(Tool):
     }
     output_type = "string"
     
-    def forward(self, analysis_json, pretty: bool = True) -> str:
+    def forward(self, analysis_json: Dict, pretty: bool = True) -> str:
         """
         Formats the analysis results for better readability.
         
         Args:
-            analysis_json: JSON string or dictionary containing the analysis results
+            analysis_json: Dics JSON containing the analysis results
+            # Format:
+            # {
+            #     "summary": "Overall analysis of the song vibes, meaning and mood",
+            #     "main_themes": ["theme1", "theme2", ...],
+            #     "mood": "The overall mood/emotion of the song",
+            #     "sections_analysis": [
+            #         {
+            #             "section_type": "verse/chorus/bridge/etc.",
+            #             "section_number": 1,
+            #             "lines": ["line1", "line2", ...],
+            #             "analysis": "Analysis of this section whith respect to the overall theme"
+            #         },
+            #         ...
+            #     ],
+            #     "conclusion": "The song vibes and concepts of the underlying meaning"
+            # }
             pretty: Whether to use rich formatting (True) or simple text formatting (False)
             
         Returns:
             A formatted string representation of the analysis
         """
-        # Expected JSON structure from analysis_tools.py:
-        # {
-        #     "summary": "Overall analysis of the song vibes, meaning and mood",
-        #     "main_themes": ["theme1", "theme2", ...],
-        #     "mood": "The overall mood/emotion of the song",
-        #     "sections_analysis": [
-        #         {
-        #             "section_type": "verse/chorus/bridge/etc.",
-        #             "section_number": 1,
-        #             "lines": ["line1", "line2", ...],
-        #             "analysis": "Analysis of this section whith respect to the overall theme"
-        #         },
-        #         ...
-        #     ],
-        #     "conclusion": "The song vibes and concepts of the underlying meaning"
-        # }
-        try:
-            # Parse the JSON string into a Python dictionary if it's a string
-            if isinstance(analysis_json, str):
-                analysis = json.loads(analysis_json)
-            else:
-                analysis = analysis_json
-                
-            if pretty:
-                # Rich formatting with the rich library
-                try:
-                    # Create a string buffer to capture the rich output
-                    console = Console(record=True, width=100)
-                    
-                    # Create a custom theme for consistent styling
-                    # Using direct style definitions instead of named styles
-                    custom_theme = Theme({
-                        "heading": "bold cyan underline",
-                        "highlight": "bold yellow",
-                        "positive": "green",
-                        "negative": "red",
-                        "neutral": "magenta",
-                        "quote": "italic yellow",
-                        "metadata": "dim white",
-                        "conclusion": "bold magenta"  # Add style for conclusion
-                    })
-                    
-                    # Apply the theme to our console
-                    console.theme = custom_theme
-                    
-                    # Format the summary section
-                    summary = analysis.get("summary", "No summary available")
-                    console.print(Panel(Text(summary, justify="center"), title="[heading]Song Analysis[/]", subtitle="[metadata]Summary[/]"))
-                    
-                    # Create a table for the main themes and mood
-                    info_table = Table(show_header=False, box=ROUNDED, expand=True)
-                    info_table.add_column("Key", style="bold blue")
-                    info_table.add_column("Value")
-                    
-                    # Add the mood
-                    mood = analysis.get("mood", "Not specified")
-                    info_table.add_row("Mood", mood)
-                    
-                    # Add the themes as a comma-separated list
-                    themes = analysis.get("main_themes", [])
-                    if themes:
-                        themes_text = ", ".join([f"[highlight]{theme}[/]" for theme in themes])
-                        info_table.add_row("Main Themes", themes_text)
-                    
-                    console.print(info_table)
-                    
-                    # Section-by-section analysis
-                    sections = analysis.get("sections_analysis", [])
-                    if sections:
-                        console.print("\n[heading]Section-by-Section Analysis[/]")
-                        
-                        for section in sections:
-                            section_type = section.get("section_type", "Unknown")
-                            section_number = section.get("section_number", "")
-                            section_title = f"{section_type.title()} {section_number}" if section_number else section_type.title()
-                            
-                            section_analysis = section.get("analysis", "No analysis available")
-                            lines = section.get("lines", [])
-                            
-                            # Create a group with the lyrics and analysis
-                            section_content = []
-                            
-                            if lines:
-                                # Format lyrics in a more readable way
-                                section_content.append(Text("Lyrics:", style="bold blue"))
-                                # Форматируем каждую строку лирики с стилем quote
-                                lyrics_lines = []
-                                for line in lines:
-                                    lyrics_lines.append(f"[quote]{line}[/]")
-                                
-                                lyrics_panel = Panel(
-                                    "\n".join(lyrics_lines),
-                                    border_style="blue",
-                                    padding=(1, 2)
-                                )
-                                section_content.append(lyrics_panel)
-                            
-                            section_content.append(Text("Analysis:", style="bold blue"))
-                            section_content.append(Text(section_analysis))
-                            
-                            # Add the section panel
-                            console.print(Panel(
-                                Group(*section_content),
-                                title=f"[bold cyan]{section_title}[/]",
-                                border_style="cyan"
-                            ))
-                    
-                    # We no longer have significant_lines in the new format
-                    
-                    # Conclusion
-                    conclusion = analysis.get("conclusion", "No conclusion available")
-                    console.print("\n[heading]Conclusion[/]")
-                    console.print(Panel(conclusion, border_style="magenta"))
-                    
-                    # Export the rich text as a string
-                    return console.export_text()
-                    
-                except Exception as e:
-                    logger.error("Error in rich formatting: {}", str(e))
-                    # Fall back to simple formatting if rich formatting fails
-                    logger.info("Falling back to simple text formatting")
-                    pretty = False
+
+        analysis = analysis_json
+        # Log the structure of the parsed analysis
+        logger.debug(f"Analysis structure keys: {list(analysis.keys()) if isinstance(analysis, dict) else 'Not a dictionary'}")
             
-            if not pretty:
-                # Simple text formatting
-                formatted_text = []
+        if pretty:
+            # Rich formatting with the rich library
+            try:
+                logger.debug("Starting rich formatting")
+                # Create a console that outputs to a temporary file
+                import tempfile
+                temp_file = tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8', delete=False)
+                console = Console(file=temp_file, width=100)
                 
-                # Summary
-                formatted_text.append("SONG ANALYSIS SUMMARY")
-                formatted_text.append("====================")
-                formatted_text.append(analysis.get("summary", "No summary available"))
-                formatted_text.append("")
+                # Create a custom theme for consistent styling
+                # Using direct style definitions instead of named styles
+                custom_theme = Theme({
+                    "heading": "bold cyan underline",
+                    "highlight": "bold yellow",
+                    "positive": "green",
+                    "negative": "red",
+                    "neutral": "magenta",
+                    "quote": "italic yellow",
+                    "metadata": "dim white",
+                    "conclusion": "bold magenta"  # Add style for conclusion
+                })
+                
+                # Apply the theme to our console
+                console.theme = custom_theme
+                
+                # Format the summary section
+                summary = analysis.get("summary", "No summary available")
+                logger.debug(f"Summary content: {summary if summary else 'Not available'}")
+                console.print(Panel(Text(summary, justify="center"), title="[heading]Song Analysis[/]", subtitle="[metadata]Summary[/]"))
+                
+                # Create a table for the main themes and mood
+                info_table = Table(show_header=False, box=ROUNDED, expand=True)
+                info_table.add_column("Key", style="bold blue")
+                info_table.add_column("Value")
+                
+                # Add the mood
+                mood = analysis.get("mood", "Not specified")
+                logger.debug(f"Mood content: {mood if mood else 'Not specified'}")
+                info_table.add_row("Mood", mood)
                 
-                # Main themes
+                # Add the themes as a comma-separated list
                 themes = analysis.get("main_themes", [])
+                logger.debug(f"Themes: {themes if themes else 'Not available'}")
                 if themes:
-                    formatted_text.append("MAIN THEMES")
-                    formatted_text.append("===========")
-                    for theme in themes:
-                        formatted_text.append(f"• {theme}")
-                    formatted_text.append("")
+                    themes_text = ", ".join([f"[highlight]{theme}[/]" for theme in themes])
+                    info_table.add_row("Main Themes", themes_text)
                 
-                # Mood
-                mood = analysis.get("mood", "Not specified")
-                formatted_text.append("MOOD")
-                formatted_text.append("====")
-                formatted_text.append(mood)
-                formatted_text.append("")
+                console.print(info_table)
                 
-                # Sections analysis
+                # Section-by-section analysis
                 sections = analysis.get("sections_analysis", [])
+                logger.debug(f"Sections count: {len(sections) if sections else 0}")
                 if sections:
-                    formatted_text.append("SECTION-BY-SECTION ANALYSIS")
-                    formatted_text.append("==========================")
+                    console.print("\n[heading]Section-by-Section Analysis[/]")
                     
-                    for i, section in enumerate(sections):
+                    for section in sections:
                         section_type = section.get("section_type", "Unknown")
-                        section_number = section.get("section_number", i+1)
+                        section_number = section.get("section_number", "")
+                        logger.debug(f"Processing section: {section_type} {section_number}")
+                        section_title = f"{section_type.title()} {section_number}" if section_number else section_type.title()
+                        
                         section_analysis = section.get("analysis", "No analysis available")
+                        lines = section.get("lines", [])
+                        logger.debug(f"Section lines count: {len(lines) if lines else 0}")
                         
-                        formatted_text.append(f"{section_type.upper()} {section_number}")
-                        formatted_text.append("-" * (len(section_type) + len(str(section_number)) + 1))
+                        # Create a group with the lyrics and analysis
+                        section_content = []
                         
-                        # Format the section lines
-                        lines = section.get("lines", [])
                         if lines:
-                            formatted_text.append("Lyrics:")
+                            # Format lyrics in a more readable way
+                            section_content.append(Text("Lyrics:", style="bold blue"))
+                            # Форматируем каждую строку лирики с стилем quote
+                            lyrics_lines = []
                             for line in lines:
-                                formatted_text.append(f"> {line}")
-                            formatted_text.append("")
+                                lyrics_lines.append(f"[quote]{line}[/]")
+                            
+                            lyrics_panel = Panel(
+                                "\n".join(lyrics_lines),
+                                border_style="blue",
+                                padding=(1, 2)
+                            )
+                            section_content.append(lyrics_panel)
                         
-                        formatted_text.append("Analysis:")
-                        formatted_text.append(section_analysis)
-                        formatted_text.append("")
+                        section_content.append(Text("Analysis:", style="bold blue"))
+                        section_content.append(Text(section_analysis))
+                        
+                        # Add the section panel
+                        console.print(Panel(
+                            Group(*section_content),
+                            title=f"[bold cyan]{section_title}[/]",
+                            border_style="cyan"
+                        ))
                 
                 # We no longer have significant_lines in the new format
                 
                 # Conclusion
                 conclusion = analysis.get("conclusion", "No conclusion available")
-                formatted_text.append("CONCLUSION")
-                formatted_text.append("==========")
-                formatted_text.append(conclusion)
+                logger.debug(f"Conclusion content: {conclusion if conclusion else 'Not available'}")
+                console.print("\n[heading]Conclusion[/]")
+                console.print(Panel(conclusion, border_style="magenta"))
                 
-                return "\n".join(formatted_text)
+                # Save output to file and read back as string
+                temp_file.close()
+                with open(temp_file.name, 'r', encoding='utf-8') as f:
+                    result = f.read()
+                # Clean up the temp file
+                import os
+                try:
+                    os.unlink(temp_file.name)
+                except Exception as e:
+                    logger.warning(f"Could not delete temporary file {temp_file.name}: {str(e)}")
+                return result
                 
-        except json.JSONDecodeError:
-            logger.error("Failed to parse analysis JSON: {}", analysis_json[:100] + "..." if len(analysis_json) > 100 else analysis_json)
-            return f"Error: Could not parse the analysis result as JSON. Raw output:\n{analysis_json}"
-        except Exception as e:
-            logger.error("Error formatting analysis: {}", str(e))
-            return f"Error formatting analysis: {str(e)}\nRaw output:\n{analysis_json}"
+            except Exception as e:
+                error_traceback = traceback.format_exc()
+                logger.error(f"Error in rich formatting: {str(e)}\nTraceback:\n{error_traceback}")
+                # Log the current state of the analysis object for debugging
+                if isinstance(analysis, dict):
+                    for key, value in analysis.items():
+                        logger.debug(f"Key: {key}, Value type: {type(value)}, Value: {str(value)[:100]}{'...' if len(str(value)) > 100 else ''}")
+                # Fall back to simple formatting if rich formatting fails
+                logger.info("Falling back to simple text formatting")
+                pretty = False
+        
+        if not pretty:
+            # Simple text formatting
+            formatted_text = []
+            
+            # Summary
+            formatted_text.append("SONG ANALYSIS SUMMARY")
+            formatted_text.append("====================")
+            formatted_text.append(analysis.get("summary", "No summary available"))
+            formatted_text.append("")
+            
+            # Main themes
+            themes = analysis.get("main_themes", [])
+            if themes:
+                formatted_text.append("MAIN THEMES")
+                formatted_text.append("===========")
+                for theme in themes:
+                    formatted_text.append(f"• {theme}")
+                formatted_text.append("")
+            
+            # Mood
+            mood = analysis.get("mood", "Not specified")
+            formatted_text.append("MOOD")
+            formatted_text.append("====")
+            formatted_text.append(mood)
+            formatted_text.append("")
+            
+            # Sections analysis
+            sections = analysis.get("sections_analysis", [])
+            if sections:
+                formatted_text.append("SECTION-BY-SECTION ANALYSIS")
+                formatted_text.append("==========================")
+                
+                for i, section in enumerate(sections):
+                    section_type = section.get("section_type", "Unknown")
+                    section_number = section.get("section_number", i+1)
+                    section_analysis = section.get("analysis", "No analysis available")
+                    
+                    formatted_text.append(f"{section_type.upper()} {section_number}")
+                    formatted_text.append("-" * (len(section_type) + len(str(section_number)) + 1))
+                    
+                    # Format the section lines
+                    lines = section.get("lines", [])
+                    if lines:
+                        formatted_text.append("Lyrics:")
+                        for line in lines:
+                            formatted_text.append(f"> {line}")
+                        formatted_text.append("")
+                    
+                    formatted_text.append("Analysis:")
+                    formatted_text.append(section_analysis)
+                    formatted_text.append("")
+            
+            # We no longer have significant_lines in the new format
+            
+            # Conclusion
+            conclusion = analysis.get("conclusion", "No conclusion available")
+            formatted_text.append("CONCLUSION")
+            formatted_text.append("==========")
+            formatted_text.append(conclusion)
+            
+            return "\n".join(formatted_text)

tools/search_tools.py

@@ -2,11 +2,83 @@
 Search tools for finding song lyrics and related information.
 """
 
-import time
+import os
 import random
-from typing import Dict, List, Any
+import time
+from typing import Any, Dict, List
+
+import requests
 from loguru import logger
-from smolagents import DuckDuckGoSearchTool
+from smolagents import DuckDuckGoSearchTool, Tool
+
+
+class BraveSearchTool(Tool):
+    """
+    A tool for performing web searches using the Brave Search API.
+    
+    This tool requires a Brave Search API key to be set in the environment
+    variable BRAVE_API_KEY or passed directly to the constructor.
+    
+    Documentation: https://api.search.brave.com/app/documentation
+    """
+    
+    def __init__(self, max_results: int = 10, **kwargs):
+        """
+        Initialize the Brave Search tool.
+        
+        Args:
+            max_results: Maximum number of results to return (default: 10)
+        """
+        super().__init__(**kwargs)
+        self.api_key = os.environ.get("BRAVE_API_KEY")
+        if not self.api_key:
+            logger.warning("No Brave API key found. Set BRAVE_API_KEY environment variable or pass api_key parameter.")
+        self.max_results = max_results
+        self.name = "brave_search"
+        self.description = "Search the web using Brave Search API"
+        self.inputs = {"query": {"type": "string", "description": "The search query string"}}
+        self.output_type = "string"
+        logger.info(f"Initialized BraveSearchTool with max_results={max_results}")
+    
+    def forward(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Execute a search using the Brave Search API.
+        
+        Args:
+            query: The search query string
+            
+        Returns:
+            List of search results in the format:
+            [{"title": str, "href": str, "body": str}, ...]
+        """
+        if not self.api_key:
+            logger.error("Brave Search API key is not set")
+            return [{"title": "API Key Error", "href": "", "body": "Brave Search API key is not set"}]
+        
+        url = "https://api.search.brave.com/res/v1/web/search"
+        headers = {"Accept": "application/json", "X-Subscription-Token": self.api_key}
+        params = {"q": query, "count": self.max_results}
+        
+        try:
+            logger.info(f"Performing Brave search for query: '{query}'")
+            response = requests.get(url, headers=headers, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            results = []
+            if "web" in data and "results" in data["web"]:
+                for result in data["web"]["results"]:
+                    results.append({
+                        "title": result.get("title", ""),
+                        "href": result.get("url", ""),
+                        "body": result.get("description", "")
+                    })
+            
+            logger.info(f"Found {len(results)} results for query: '{query}'")
+            return results
+        except Exception as e:
+            logger.error(f"Error in Brave search: {str(e)}")
+            return [{"title": "Search error", "href": "", "body": f"Error performing search: {str(e)}"}]
 
 
 class ThrottledDuckDuckGoSearchTool(DuckDuckGoSearchTool):