Update app.py

app.py

@@ -9,17 +9,15 @@ from tools.final_answer import FinalAnswerTool
 import tempfile
 import shutil
 
-# File to save the history of recognized songs
+# Constantes
 HISTORY_FILE = "song_history.json"
 
-# Supported languages
 LANGUAGES = {
     "English": "en",
     "Español": "es",
     "Français": "fr"
 }
 
-# Language-specific messages
 MESSAGES = {
     "en": {
         "title": "# 🎵 Music Recognition & Fun Facts",
@@ -95,43 +93,25 @@ MESSAGES = {
     }
 }
 
-# Tool to recognize songs using AudD
+# Herramientas
 @tool
 def recognize_song(audio_path: str) -> dict:
-    """Recognizes a song from an audio file
-    Args:
-        audio_path: path to the audio file to recognize
-    """
     AUDD_API_TOKEN = os.getenv("AUDD_API_TOKEN")
-    
     if not os.path.exists(audio_path):
         return {"error": "The audio file does not exist"}
-    
     try:
         with open(audio_path, 'rb') as file:
-            data = {
-                'api_token': AUDD_API_TOKEN,
-                'return': 'spotify,apple_music'
-            }
-            files = {
-                'file': file
-            }
+            data = {'api_token': AUDD_API_TOKEN, 'return': 'spotify,apple_music'}
+            files = {'file': file}
             response = requests.post('https://api.audd.io/', data=data, files=files)
-            
         if response.status_code != 200:
             return {"error": f"API Error: {response.status_code}"}
-            
         result = response.json()
-        
         if result['status'] == 'error':
             return {"error": result['error']['error_message']}
-            
         if not result.get('result'):
             return {"error": "Could not recognize the song"}
-            
         song_info = result['result']
-        
-        # Create object with song information
         song_data = {
             "Song": song_info.get('title', 'Unknown'),
             "Artist": song_info.get('artist', 'Unknown'),
@@ -140,115 +120,60 @@ def recognize_song(audio_path: str) -> dict:
             "Apple Music": song_info.get('apple_music', {}).get('url', 'Not available'),
             "Recognition Date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
-        
-        # Save to history
         save_to_history(song_data)
-        
         return song_data
-        
     except Exception as e:
         return {"error": f"Error processing audio: {str(e)}"}
 
-# Function to save song to history
 def save_to_history(song_data):
-    """Saves a song to the history"""
     try:
-        # Load existing history or create new
         if os.path.exists(HISTORY_FILE):
             with open(HISTORY_FILE, 'r') as f:
-                try:
-                    history = json.load(f)
-                except json.JSONDecodeError:
-                    history = []
+                history = json.load(f) if f.read().strip() else []
         else:
             history = []
-        
-        # Add song to the beginning of history (most recent first)
         history.insert(0, song_data)
-        
-        # Limit history to the 50 most recent songs
         if len(history) > 50:
             history = history[:50]
-        
-        # Save updated history
         with open(HISTORY_FILE, 'w') as f:
             json.dump(history, f, indent=2)
-            
     except Exception as e:
         print(f"Error saving to history: {str(e)}")
 
-# Tool to view song history
 @tool
 def view_song_history(limit: int = 10, language: str = "en") -> str:
-    """Shows the history of recognized songs
-    Args:
-        limit: maximum number of songs to display (default 10)
-        language: language code (en, es, fr)
-    """
     lang = LANGUAGES.get(language, "en")
     try:
         if not os.path.exists(HISTORY_FILE):
             return f"📋 {MESSAGES[lang]['no_history']}"
-        
         with open(HISTORY_FILE, 'r') as f:
-            try:
-                history = json.load(f)
-            except json.JSONDecodeError:
-                return "📋 Error loading song history."
-        
+            history = json.load(f)
         if not history:
             return f"📋 {MESSAGES[lang]['empty_history']}"
-        
-        # Limit the number of songs to display
         history = history[:min(limit, len(history))]
-        
-        # Format output
         result = f"📋 **{MESSAGES[lang]['history_title']}:**\n\n"
-        
         for i, song in enumerate(history, 1):
             result += f"{i}. **{song.get('Song', 'Unknown')}** - *{song.get('Artist', 'Unknown')}*\n"
             result += f"   📀 Album: {song.get('Album', 'Unknown')}\n"
-            
             if song.get('Spotify', 'Not available') != 'Not available':
                 result += f"   🎧 [Spotify]({song.get('Spotify')})\n"
-                
             if song.get('Apple Music', 'Not available') != 'Not available':
                 result += f"   🍏 [Apple Music]({song.get('Apple Music')})\n"
-                
             result += f"   🕒 Recognized on: {song.get('Recognition Date', 'Unknown date')}\n\n"
-        
         return result
-        
     except Exception as e:
         return f"❌ {MESSAGES[lang]['history_error'].format(error=str(e))}"
 
-# Tool to get artist information in selected language
 @tool
 def get_artist_info(artist_name: str, song_title: str, language: str = "en") -> dict:
-    """Gets background information and fun facts about a music artist in the specified language
-    Args:
-        artist_name: name of the artist to get information about
-        song_title: title of the song
-        language: language code (en, es, fr)
-    """
-    # Language-specific prompts
     prompts = {
         "en": f"Provide interesting and fun facts about the music artist '{artist_name}' that fans would love to know. Include stories about their career, personal anecdotes, how their song '{song_title}' was created if known, or surprising facts about their life. Include an image URL if possible. Focus on highlighting their contributions to music and anything that makes them unique as an artist. Keep it engaging and positive.",
         "es": f"Proporciona datos interesantes y curiosos sobre el artista musical '{artist_name}' que a los fans les encantaría conocer. Incluye historias sobre su carrera, anécdotas personales, cómo se creó su canción '{song_title}' si se sabe, o datos sorprendentes sobre su vida. Incluye una URL de imagen si es posible. Céntrate en destacar sus contribuciones a la música y cualquier cosa que les haga únicos como artistas. Mantenlo atractivo y positivo.",
         "fr": f"Fournissez des faits intéressants et amusants sur l'artiste musical '{artist_name}' que les fans aimeraient connaître. Incluez des histoires sur leur carrière, des anecdotes personnelles, comment leur chanson '{song_title}' a été créée si connu, ou des faits surprenants sur leur vie. Incluez une URL d'image si possible. Concentrez-vous sur la mise en valeur de leurs contributions à la musique et tout ce qui les rend uniques en tant qu'artiste. Gardez-le engageant et positif.",
     }
-    
-    # Default to English if language not supported
-    if language not in prompts:
-        language = "en"
-    
-    # Create messages for the model
-    messages = [
-        {"role": "user", "content": prompts[language]}
-    ]
-    
+    language = language if language in prompts else "en"
+    messages = [{"role": "user", "content": prompts[language]}]
     try:
-        # Using the same model that powers our agent
         response = model(messages)
         content = response.content
         image_url = None
@@ -261,45 +186,26 @@ def get_artist_info(artist_name: str, song_title: str, language: str = "en") ->
     except Exception as e:
         return {"text": f"Could not retrieve information about {artist_name}: {str(e)}", "image": None}
 
-# Chat with LLM tool
 @tool
 def chat_with_assistant(query: str, artist_info: str = "", language: str = "en") -> str:
-    """Chat with the AI assistant about any music related topic in the specified language
-    Args:
-        query: user's question or request
-        artist_info: previous artist info to provide context
-        language: language code (en, es, fr)
-    """
-    # Language-specific system messages
     system_messages = {
         "en": "You are a music expert assistant who specializes in providing engaging information about artists, songs, and music history. Focus on sharing interesting, fun facts that highlight the artist's unique contributions and stories.",
         "es": "Eres un asistente experto en música que se especializa en proporcionar información interesante sobre artistas, canciones e historia musical. Céntrate en compartir datos curiosos e interesantes que destaquen las contribuciones únicas y las historias del artista.",
         "fr": "Vous êtes un assistant expert en musique qui se spécialise dans la fourniture d'informations intéressantes sur les artistes, les chansons et l'histoire de la musique. Concentrez-vous sur le partage de faits intéressants et amusants qui mettent en évidence les contributions uniques et les histoires de l'artiste.",
     }
-    
-    # Default to English if language not supported
-    if language not in system_messages:
-        language = "en"
-    
-    # Create context
-    context = ""
-    if artist_info:
-        context = f"Previous context about the artist: {artist_info}\n\n"
-    
-    # Create messages for the model
+    language = language if language in system_messages else "en"
+    context = f"Previous context about the artist: {artist_info}\n\n" if artist_info else ""
     messages = [
         {"role": "system", "content": system_messages[language]},
         {"role": "user", "content": context + query}
     ]
-    
     try:
-        # Using the model to generate a response
         response = model(messages)
         return response.content
     except Exception as e:
         return f"Sorry, I couldn't process your request: {str(e)}"
 
-# Agent configuration
+# Configuración del agente
 final_answer = FinalAnswerTool()
 model = HfApiModel(
     max_tokens=2096,
@@ -311,16 +217,9 @@ model = HfApiModel(
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
-# Agent definition
 agent = CodeAgent(
     model=model,
-    tools=[
-        final_answer,
-        recognize_song,
-        view_song_history,
-        get_artist_info,
-        chat_with_assistant
-    ],
+    tools=[final_answer, recognize_song, view_song_history, get_artist_info, chat_with_assistant],
     max_steps=8,
     verbosity_level=1,
     grammar=None,
@@ -330,240 +229,177 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
-# Gradio user interface
+# Descargar imagen (función auxiliar)
+def download_image(image_url):
+    if not image_url:
+        return ""
+    try:
+        response = requests.get(image_url, stream=True)
+        if response.status_code == 200:
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.jpg')
+            shutil.copyfileobj(response.raw, temp_file)
+            temp_file.close()
+            return temp_file.name
+        return ""
+    except Exception:
+        return ""
+
+# Interfaz de usuario con Gradio
 with gr.Blocks(title="Music Recognition & Fun Facts", css=".large-text {font-size: 1.5em !important;} .big-button {font-size: 1.2em; padding: 15px 30px;}") as demo:
-    # State variables
     selected_language = gr.State("en")
     song_info_state = gr.State(None)
     artist_info_state = gr.State("")
-    audio_status = gr.State("no_audio")  # States: no_audio, loading, ready
-    
-    # Title and intro
-    gr.Markdown(value=lambda: MESSAGES[selected_language.value]["title"])
-    gr.Markdown(value=lambda: MESSAGES[selected_language.value]["subtitle"])
-    
-    # Language selection
+    audio_status = gr.State("no_audio")
+
+    title = gr.Markdown(value=MESSAGES["en"]["title"], elem_id="title")
+    subtitle = gr.Markdown(value=MESSAGES["en"]["subtitle"], elem_id="subtitle")
+
     with gr.Row():
         language_dropdown = gr.Dropdown(
             choices=[("English", "en"), ("Español", "es"), ("Français", "fr")],
             value="en",
-            label=lambda: MESSAGES[selected_language.value]["language_label"]
+            label=MESSAGES["en"]["language_label"]
         )
-    
-    # Combined recognition and chat interface
+
     with gr.Tab("Song Recognition & Chat"):
-        # Audio status message
-        audio_status_msg = gr.Markdown(value=lambda: MESSAGES[selected_language.value]["no_audio"])
-        
-        # Song recognition section
+        audio_status_msg = gr.Markdown(value=MESSAGES["en"]["no_audio"], elem_id="audio_status_msg")
         with gr.Row():
             with gr.Column(scale=1):
-                # Replacing the standard audio widget with a custom button approach
-                # First, keep the actual audio input but make it less visible
-                audio_input = gr.Audio(type="filepath", visible=False)  # Removed source="microphone"
-                
-                # Add a big, prominent record button
-                record_btn = gr.Button(value=lambda: MESSAGES[selected_language.value]["rec_button"], elem_classes="big-button", variant="primary")
+                audio_input = gr.Audio(type="filepath", visible=False)
+                record_btn = gr.Button(value=MESSAGES["en"]["rec_button"], elem_classes="big-button", variant="primary", elem_id="record_btn")
                 audio_loaded_msg = gr.Markdown("", elem_classes="large-text")
-                # Add the recognize button
-                recognize_btn = gr.Button(value=lambda: MESSAGES[selected_language.value]["recognize_button"], variant="secondary")
-        
-        # Recognition results section (separate from chat)
+                recognize_btn = gr.Button(value=MESSAGES["en"]["recognize_button"], variant="secondary", elem_id="recognize_btn")
+
         with gr.Row():
             recognition_results = gr.Markdown("")
-        
-        # Artist info section
+
         with gr.Row():
             artist_info_text = gr.Markdown("")
-            artist_info_image = gr.Image(type="filepath")  # Changed from type="url" to type="filepath"
+            artist_info_image = gr.Image(type="filepath")
+
+        chat_title = gr.Markdown(value=MESSAGES["en"]["chat_title"], elem_id="chat_title")
+        chat_history = gr.Chatbot(label="Music Chat", type="messages")
 
-        gr.Markdown(value=lambda: MESSAGES[selected_language.value]["chat_title"])
-        chat_history = gr.Chatbot(label="Music Chat")
-        
         with gr.Row():
             chat_input = gr.Textbox(
-                placeholder=lambda: MESSAGES[selected_language.value]["chat_placeholder"],
-                label="Your question"
-            )
-            chat_btn = gr.Button(value=lambda: MESSAGES[selected_language.value]["chat_button"], variant="primary")
-        
-        # Function to handle audio recording/uploading
-        def toggle_audio_widget(language_name):
-            lang = LANGUAGES.get(language_name, "en")
-            # This function triggers the audio widget's recording functionality
-            return gr.update(visible=True), "loading", MESSAGES[lang]["loading"]
-        
-        # Function to update status when audio is uploaded
-        def update_audio_status(audio_path, language_name):
-            lang = LANGUAGES.get(language_name, "en")
-            if audio_path:
-                return "ready", MESSAGES[lang]["audio_loaded"]
-            else:
-                return "no_audio", MESSAGES[lang]["no_audio"]
-        
-        # Function to download image from URL and return a local filepath
-        def download_image(url):
-            if not url:
-                return None
-            try:
-                response = requests.get(url, stream=True)
-                response.raise_for_status()
-                # Create a temporary file
-                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.jpg')
-                shutil.copyfileobj(response.raw, temp_file)
-                temp_file.close()
-                return temp_file.name
-            except Exception as e:
-                print(f"Error downloading image: {str(e)}")
-                return None
-        
-        # Recognition function
-        def process_audio(audio_path, language_name, status):
-            lang = LANGUAGES.get(language_name, "en")
-            if not audio_path or status != "ready":
-                return None, "", "", MESSAGES[lang]["no_audio"], ""
-            
-            yield None, "", "", MESSAGES[lang]["uploading"], ""
-            yield None, "", "", MESSAGES[lang]["searching"], ""
-            try:
-                result = recognize_song(audio_path)
-                
-                if "error" in result:
-                    return None, "", "", MESSAGES[lang]["error"].format(error=result['error']), ""
-                
-                # Get artist information in selected language
-                artist_info = get_artist_info(result['Artist'], result['Song'], lang)
-                
-                # Format recognition result based on language
-                if lang == "en":
-                    recognition_msg = f"### 🎵 Recognized Song: {result['Song']}\n\n"
-                    recognition_msg += f"**🎤 Artist:** {result['Artist']}\n"
-                    recognition_msg += f"**📀 Album:** {result['Album']}\n\n"
-                    
-                    if result['Spotify'] != "Not available":
-                        recognition_msg += f"**🎧 [Listen on Spotify]({result['Spotify']})**\n"
-                    if result['Apple Music'] != "Not available":
-                        recognition_msg += f"**🍏 [Listen on Apple Music]({result['Apple Music']})**\n"
-                
-                elif lang == "es":
-                    recognition_msg = f"### 🎵 Canción Reconocida: {result['Song']}\n\n"
-                    recognition_msg += f"**🎤 Artista:** {result['Artist']}\n"
-                    recognition_msg += f"**📀 Álbum:** {result['Album']}\n\n"
-                    
-                    if result['Spotify'] != "Not available":
-                        recognition_msg += f"**🎧 [Escuchar en Spotify]({result['Spotify']})**\n"
-                    if result['Apple Music'] != "Not available":
-                        recognition_msg += f"**🍏 [Escuchar en Apple Music]({result['Apple Music']})**\n"
-                
-                elif lang == "fr":
-                    recognition_msg = f"### 🎵 Chanson Reconnue: {result['Song']}\n\n"
-                    recognition_msg += f"**🎤 Artiste:** {result['Artist']}\n"
-                    recognition_msg += f"**📀 Album:** {result['Album']}\n\n"
-                    
-                    if result['Spotify'] != "Not available":
-                        recognition_msg += f"**🎧 [Écouter sur Spotify]({result['Spotify']})**\n"
-                    if result['Apple Music'] != "Not available":
-                        recognition_msg += f"**🍏 [Écouter sur Apple Music]({result['Apple Music']})**\n"
-                
-                # Artist info section title based on language
-                artist_facts_content = f"{MESSAGES[lang]['artist_info_title']}\n\n{artist_info['text']}"
-                
-                # Download the image if URL exists
-                image_filepath = download_image(artist_info['image']) if artist_info['image'] else ""
-                
-                # Update status message
-                status_msg = MESSAGES[lang]["recognized"]
-                
-                return result, recognition_msg, artist_facts_content, status_msg, image_filepath
-            
-            except Exception as e:
-                return None, "", "", MESSAGES[lang]["error"].format(error=str(e)), ""
-        
-        # Chat function
-        def process_chat(query, language_name, song_info, artist_info):
-            lang = LANGUAGES.get(language_name, "en")
-            if not query:
-                return []
-            
-            try:
-                # Get response
-                response = chat_with_assistant(query, artist_info, lang)
-                
-                return [(query, response)]
-            except Exception as e:
-                return [(query, f"Sorry, I couldn't process your request: {str(e)}")]
-        
-        def view_history_process(limit, language_name):
-            lang = LANGUAGES.get(language_name, "en")
-            return view_song_history(int(limit), lang)
-
-        def update_ui(language_name):
-            lang = LANGUAGES.get(language_name, "en")
-            return (
-                MESSAGES[lang]["title"],
-                MESSAGES[lang]["subtitle"],
-                gr.Markdown(value=MESSAGES[lang]["no_audio"]),
-                gr.Button(value=MESSAGES[lang]["rec_button"], elem_classes="big-button", variant="primary"),
-                gr.Button(value=MESSAGES[lang]["recognize_button"], variant="secondary"),
-                gr.Markdown(value=MESSAGES[lang]["chat_title"]),
-                gr.Textbox(placeholder=MESSAGES[lang]["chat_placeholder"], label="Your question"),
-                gr.Button(value=MESSAGES[lang]["chat_button"], variant="primary"),
-                gr.Slider(minimum=5, maximum=50, value=10, step=5, label=MESSAGES[lang]["history_limit_label"]),
-                gr.Button(value=MESSAGES[lang]["history_button"])
+                placeholder=MESSAGES["en"]["chat_placeholder"],
+                label="Your question",
+                elem_id="chat_input"
             )
+            chat_btn = gr.Button(value=MESSAGES["en"]["chat_button"], variant="primary", elem_id="chat_btn")
 
-        # Event handlers
-        language_dropdown.change(
-            fn=update_ui,
-            inputs=[language_dropdown],
-            outputs=[demo.get_component(0), demo.get_component(1), audio_status_msg, record_btn, recognize_btn, demo.get_component(8), chat_input, chat_btn, history_limit, view_history_btn]
-        )
-
-        record_btn.click(
-            fn=toggle_audio_widget,
-            inputs=[language_dropdown],
-            outputs=[audio_input, audio_status, audio_status_msg]
-        )
-        
-        audio_input.change(
-            fn=update_audio_status,
-            inputs=[audio_input, language_dropdown],
-            outputs=[audio_status, audio_loaded_msg]
-        )
-        
-        recognize_btn.click(
-            fn=process_audio,
-            inputs=[audio_input, language_dropdown, audio_status],
-            outputs=[song_info_state, recognition_results, artist_info_text, audio_status_msg, artist_info_image]
-        ).then(
-            fn=lambda a: a,
-            inputs=[artist_info_text],
-            outputs=[artist_info_state]
-        )
-        
-        chat_btn.click(
-            fn=process_chat,
-            inputs=[chat_input, language_dropdown, song_info_state, artist_info_state],
-            outputs=[chat_history]
-        ).then(
-            fn=lambda: "",  # Clear input after sending
-            inputs=[],
-            outputs=[chat_input]
-        )
-    
     with gr.Tab("Song History"):
-        gr.Markdown(value=lambda: MESSAGES[selected_language.value]["history_title"])
-        
+        gr.Markdown(value=MESSAGES["en"]["history_title"])
         with gr.Row():
-            history_limit = gr.Slider(minimum=5, maximum=50, value=10, step=5, label=lambda: MESSAGES[selected_language.value]["history_limit_label"])
-            view_history_btn = gr.Button(value=lambda: MESSAGES[selected_language.value]["history_button"])
-        
+            history_limit = gr.Slider(minimum=5, maximum=50, value=10, step=5, label=MESSAGES["en"]["history_limit_label"], elem_id="history_limit")
+            view_history_btn = gr.Button(value=MESSAGES["en"]["history_button"], elem_id="view_history_btn")
         history_output = gr.Markdown()
-        
-        view_history_btn.click(
-            fn=view_history_process,
-            inputs=[history_limit, language_dropdown],
-            outputs=[history_output]
+
+    def update_ui(language_name):
+        lang = LANGUAGES.get(language_name, "en")
+        return (
+            MESSAGES[lang]["title"],
+            MESSAGES[lang]["subtitle"],
+            MESSAGES[lang]["no_audio"],
+            MESSAGES[lang]["rec_button"],
+            MESSAGES[lang]["recognize_button"],
+            MESSAGES[lang]["chat_title"],
+            MESSAGES[lang]["chat_placeholder"],
+            MESSAGES[lang]["chat_button"],
+            MESSAGES[lang]["history_limit_label"],
+            MESSAGES[lang]["history_button"]
         )
 
+    language_dropdown.change(
+        fn=update_ui,
+        inputs=[language_dropdown],
+        outputs=[title, subtitle, audio_status_msg, record_btn, recognize_btn, chat_title, chat_input, chat_btn, history_limit, view_history_btn]
+    )
+
+    def toggle_audio_widget(language_name):
+        lang = LANGUAGES.get(language_name, "en")
+        return gr.update(visible=True), "loading", MESSAGES[lang]["loading"]
+
+    record_btn.click(
+        fn=toggle_audio_widget,
+        inputs=[language_dropdown],
+        outputs=[audio_input, audio_status, audio_status_msg]
+    )
+
+    def update_audio_status(audio_path, language_name):
+        lang = LANGUAGES.get(language_name, "en")
+        if audio_path:
+            return "ready", MESSAGES[lang]["audio_loaded"]
+        else:
+            return "no_audio", MESSAGES[lang]["no_audio"]
+
+    audio_input.change(
+        fn=update_audio_status,
+        inputs=[audio_input, language_dropdown],
+        outputs=[audio_status, audio_loaded_msg]
+    )
+
+    def process_audio(audio_path, language_name, status):
+        lang = LANGUAGES.get(language_name, "en")
+        if not audio_path or status != "ready":
+            return None, "", "", MESSAGES[lang]["no_audio"], ""
+        yield None, "", "", MESSAGES[lang]["uploading"], ""
+        yield None, "", "", MESSAGES[lang]["searching"], ""
+        try:
+            result = recognize_song(audio_path)
+            if "error" in result:
+                return None, "", "", MESSAGES[lang]["error"].format(error=result['error']), ""
+            artist_info = get_artist_info(result['Artist'], result['Song'], lang)
+            recognition_msg = f"### 🎵 Recognized Song: {result['Song']}\n\n**🎤 Artist:** {result['Artist']}\n**📀 Album:** {result['Album']}\n\n"
+            if result['Spotify'] != "Not available":
+                recognition_msg += f"**🎧 [Listen on Spotify]({result['Spotify']})**\n"
+            if result['Apple Music'] != "Not available":
+                recognition_msg += f"**🍏 [Listen on Apple Music]({result['Apple Music']})**\n"
+            artist_facts_content = f"{MESSAGES[lang]['artist_info_title']}\n\n{artist_info['text']}"
+            image_filepath = download_image(artist_info['image']) if artist_info['image'] else ""
+            status_msg = MESSAGES[lang]["recognized"]
+            return result, recognition_msg, artist_facts_content, status_msg, image_filepath
+        except Exception as e:
+            return None, "", "", MESSAGES[lang]["error"].format(error=str(e)), ""
+
+    recognize_btn.click(
+        fn=process_audio,
+        inputs=[audio_input, language_dropdown, audio_status],
+        outputs=[song_info_state, recognition_results, artist_info_text, audio_status_msg, artist_info_image]
+    ).then(
+        fn=lambda a: a,
+        inputs=[artist_info_text],
+        outputs=[artist_info_state]
+    )
+
+    def process_chat(query, language_name, song_info, artist_info):
+        lang = LANGUAGES.get(language_name, "en")
+        if not query:
+            return []
+        try:
+            response = chat_with_assistant(query, artist_info, lang)
+            return [(query, response)]
+        except Exception as e:
+            return [(query, f"Sorry, I couldn't process your request: {str(e)}")]
+
+    chat_btn.click(
+        fn=process_chat,
+        inputs=[chat_input, language_dropdown, song_info_state, artist_info_state],
+        outputs=[chat_history]
+    ).then(
+        fn=lambda: "",
+        inputs=[],
+        outputs=[chat_input]
+    )
+
+    def view_history_process(limit, language_name):
+        lang = LANGUAGES.get(language_name, "en")
+        return view_song_history(int(limit), lang)
+
+    view_history_btn.click(
+        fn=view_history_process,
+        inputs=[history_limit, language_dropdown],
+        outputs=[history_output]
+    )
+
 demo.launch()