Update a lot...

Gradio_UI.py

@@ -197,9 +197,15 @@ class GradioUI:
 
     def interact_with_agent(self, prompt, messages):
         import gradio as gr
-
+        
         messages.append(gr.ChatMessage(role="user", content=prompt))
         yield messages
+
+        prompt = f"""1. Find and extract the lyrics of the song: {prompt}.
+        2. Perform deep lyrics analysis and return full lyrics and analysis
+        3. Generate an image based on the song analysis using generate_image tool
+        4. Return rich-formatted string.
+        """
         for msg in stream_to_gradio(self.agent, task=prompt, reset_agent_memory=False):
             messages.append(msg)
             yield messages
@@ -275,7 +281,7 @@ class GradioUI:
         2. Agent will **search for the lyrics**.
         3. Agent will **summarize the song's meaning** based on the lyrics using pre-defined prompt (see files).  
         """
-
+        
         with gr.Blocks(fill_height=True) as demo:
             gr.Markdown(ui_tip_text)
             stored_messages = gr.State([])

agents/single_agent.py

@@ -9,6 +9,7 @@ from config import load_prompt_templates
 from tools.analysis_tools import AnalyzeLyricsTool
 from tools.formatting_tools import FormatAnalysisResultsTool
 from tools.search_tools import ThrottledDuckDuckGoSearchTool, BraveSearchTool
+from tools.image_generation_tools import GenerateImageTool
 
 
 def create_single_agent(model):
@@ -32,13 +33,14 @@ def create_single_agent(model):
             VisitWebpageTool(),
             AnalyzeLyricsTool(),
             FormatAnalysisResultsTool(),
+            GenerateImageTool(),
             FinalAnswerTool(),
         ],
         model=model,
-        additional_authorized_imports=['numpy', 'bs4', 'rich'],
+        additional_authorized_imports=['numpy', 'bs4', 'rich', 'json'],
         max_steps=25,
         verbosity_level=2,
-        description="Specialized agent for finding and extracting song lyrics specified by the user using search and analysis tools. Performs lyrics search and after getting the lyrics full text from the web, it performs the analysis using given tools. Provides detailed commentary with beautiful and human-readable format using rich library formatting. Format analysis results in rich colorful output.",
+        description="Specialized agent for finding and extracting song lyrics specified by the user using search and analysis tools. Performs lyrics search and after getting the lyrics full text from the web, it performs the analysis using given tools. Generates visual representation of the song based on the analysis results. Provides detailed commentary with beautiful and human-readable format using rich library formatting. Format analysis results in rich colorful output.",
         prompt_templates=prompt_templates
     )
     

app.py

@@ -5,8 +5,6 @@ Lyrics Analyzer Agent - Main Entry Point
 This module serves as the entry point for the Lyrics Analyzer application, which
 uses a system of specialized agents to search for and analyze song lyrics.  
 """
-import os
-
 from loguru import logger
 from smolagents import LiteLLMModel
 
@@ -32,14 +30,16 @@ def main():
     setup_logger()
     load_api_keys()
     
-    is_test = os.environ.get('SPACE_ID') is None
+    # use_local = os.environ.get('SPACE_ID') is None
+    use_local_llm = False
+    use_localhost = True
 
     # If using Ollama, we need to specify the API base URL
     # Initialize the LLM model based on configuration
-    model_id = get_model_id(use_local=is_test)
+    model_id = get_model_id(provider='openrouter')
 
     logger.info(f"Initializing with model: {model_id}")
-    if is_test:
+    if use_local_llm:
         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)
@@ -55,21 +55,19 @@ def main():
     # Determine if we're in test mode (local) or production (HuggingFace)
     # HuggingFace environment has SPACE_ID environment variable
     
-    gradio_config = get_gradio_config(is_test)
+    gradio_config = get_gradio_config(use_localhost=use_localhost)
+    
+    # Инструкции агенту настраиваются непосредственно в GradioUI.py
     
     # Launch with appropriate configuration
     launch_kwargs = {
         "debug": gradio_config["debug"],
-        "share": gradio_config["share"]
+        "share": gradio_config["share"],
+        "server_name": gradio_config["server_name"],
+        "server_port": gradio_config["server_port"]
     }
     
-    # Add server parameters only for local testing
-    if is_test:
-        launch_kwargs.update({
-            "server_name": gradio_config["server_name"],
-            "server_port": gradio_config["server_port"]
-        })
-    
+    # Передаем инструкцию в конструктор GradioUI
     GradioUI(single_agent).launch(**launch_kwargs)
     logger.success("Server started successfully")
 

config.py

@@ -70,7 +70,7 @@ SEARCH_TOOL_CONFIG = {
 
 
 # Gradio UI configuration
-def get_gradio_config(is_test=True):
+def get_gradio_config(use_localhost=True):
     """Get the appropriate Gradio UI configuration based on environment.
     
     Args:
@@ -80,7 +80,7 @@ def get_gradio_config(is_test=True):
     Returns:
         Dictionary with Gradio configuration parameters.
     """
-    if is_test:
+    if use_localhost:
         # Configuration for local development/testing
         return {
             "debug": True,

run_single_agent.py

@@ -30,7 +30,7 @@ else:
 # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
 
 # Prompt the user for the song name
-song_data = "Felix Da Housecat - Everyone is someone in LA"
+song_data = "Mechanical Me - Beachy Head"
 
 agent = create_single_agent(model)
 prompt = f"""1. Find and extract the lyrics of the song: {song_data}.

tools/__init__.py

@@ -1,3 +1,5 @@
 """
-Tools for interacting with search engines and analyzing song lyrics.
+Tools for interacting with search engines, analyzing song lyrics, and generating images.
 """
+
+from .image_generation_tools import GenerateImageTool

tools/analysis_tools.py

@@ -75,17 +75,11 @@ class AnalyzeLyricsTool(Tool):
 
         # Use the function with retry mechanism
         logger.info("Analyzing lyrics for song: '{}' by '{}'", song_title, artist)
+
         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
+        # 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
+
 

tools/formatting_tools.py

@@ -2,9 +2,10 @@
 Formatting tools for displaying analysis results with rich formatting.
 """
 
-import json
+import os
+import tempfile
 import traceback
-from typing import Dict, Any, List, Union
+from typing import Dict, Any, Tuple
 from loguru import logger
 from smolagents import Tool
 from rich.console import Console
@@ -32,215 +33,172 @@ class FormatAnalysisResultsTool(Tool):
         Formats the analysis results for better readability.
         
         Args:
-            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)
+            analysis_json: Dictionary containing the analysis results
+            pretty: Parameter kept for API compatibility but not used anymore
             
         Returns:
             A formatted string representation of the analysis
         """
-
-        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 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)
-                
-                # 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)
-                
-                # 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:
-                    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", [])
-                logger.debug(f"Sections count: {len(sections) if sections else 0}")
-                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", "")
-                        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}")
-                        
-                        # 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")
-                logger.debug(f"Conclusion content: {conclusion if conclusion else 'Not available'}")
-                console.print("\n[heading]Conclusion[/]")
-                console.print(Panel(conclusion, border_style="magenta"))
-                
-                # 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 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
+        analysis = analysis_json
             
-            # Conclusion
-            conclusion = analysis.get("conclusion", "No conclusion available")
-            formatted_text.append("CONCLUSION")
-            formatted_text.append("==========")
-            formatted_text.append(conclusion)
+        logger.debug(f"Analysis structure keys: {list(analysis.keys()) if isinstance(analysis, dict) else 'Not a dictionary'}")
+        
+        try:
+            return self._format_rich(analysis)
+        except Exception as e:
+            error_traceback = traceback.format_exc()
+            logger.error(f"Error in rich formatting: {str(e)}\nTraceback:\n{error_traceback}")
+            self._log_analysis_debug_info(analysis)
+            # Return error message instead of falling back to simple formatting
+            return f"Error formatting analysis results: {str(e)}"
+
+    
+    def _log_analysis_debug_info(self, analysis: Dict) -> None:
+        """Log debug information about the analysis dictionary"""
+        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 ''}")
+    
+    def _create_rich_console(self) -> Tuple[Console, Any]:
+        """Create and configure a Rich console with a temporary file"""
+        logger.debug("Starting rich formatting")
+        temp_file = tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8', delete=False)
+        # Reduce console width for better display in Gradio UI
+        console = Console(file=temp_file, width=70)
+        
+        # Create a custom theme for consistent styling
+        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"
+        })
+        
+        # Apply the theme to our console
+        console.theme = custom_theme
+        return console, temp_file
+    
+    def _format_summary(self, console: Console, analysis: Dict) -> None:
+        """Format and print 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[/]",
+            expand=True  # Расширять панель на всю доступную ширину
+        ))
+    
+    def _format_info_table(self, console: Console, analysis: Dict) -> None:
+        """Format and print the info table with 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)
+        
+        # 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:
+            themes_text = ", ".join([f"[highlight]{theme}[/]" for theme in themes])
+            info_table.add_row("Main Themes", themes_text)
+        
+        console.print(info_table)
+    
+    def _format_section(self, console: Console, section: Dict) -> None:
+        """Format and print a single section"""
+        section_type = section.get("section_type", "Unknown")
+        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}")
+        
+        # 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"))
+            # Format each lyrics line with the quote style
+            lyrics_lines = []
+            for line in lines:
+                lyrics_lines.append(f"[quote]{line}[/]")
             
-            return "\n".join(formatted_text)
+            lyrics_panel = Panel(
+                "\n".join(lyrics_lines),
+                border_style="blue",
+                padding=(1, 2),
+                expand=True  # Расширять панель на всю доступную ширину
+            )
+            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",
+            expand=True  # Расширять панель на всю доступную ширину
+        ))
+    
+    def _format_sections(self, console: Console, analysis: Dict) -> None:
+        """Format and print all sections"""
+        sections = analysis.get("sections_analysis", [])
+        logger.debug(f"Sections count: {len(sections) if sections else 0}")
+        if sections:
+            console.print("\n[heading]Section-by-Section Analysis[/]")
+            for section in sections:
+                self._format_section(console, section)
+    
+    def _format_conclusion(self, console: Console, analysis: Dict) -> None:
+        """Format and print the conclusion"""
+        conclusion = analysis.get("conclusion", "No conclusion available")
+        logger.debug(f"Conclusion content: {conclusion if conclusion else 'Not available'}")
+        console.print("\n[heading]Conclusion[/]")
+        console.print(Panel(
+            Text(conclusion, justify="left"), 
+            border_style="magenta",
+            expand=True  # Расширять панель на всю доступную ширину
+        ))
+    
+    def _format_rich(self, analysis: Dict) -> str:
+        """Format the analysis using rich formatting"""
+        console, temp_file = self._create_rich_console()
+        
+        # Format each section
+        self._format_summary(console, analysis)
+        self._format_info_table(console, analysis)
+        self._format_sections(console, analysis)
+        self._format_conclusion(console, analysis)
+        
+        # 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()
+        
+        # Градио не поддерживает HTML-теги pre, поэтому просто возвращаем текст как есть
+        # Текстовое форматирование Rich уже содержит необходимые отступы и пробелы
+        
+        # Clean up the temp file
+        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
+    
+