Update app.py

app.py

@@ -3,52 +3,112 @@ import time
 import requests
 from streamlit.components.v1 import html
 import os
+import speech_recognition as sr
+from audio_recorder_streamlit import audio_recorder
 
+# Import transformers and cache the help agent for performance
 @st.cache_resource
 def get_help_agent():
     from transformers import pipeline
+    # Using BlenderBot 400M Distill as the public conversational model (used elsewhere)
     return pipeline("conversational", model="facebook/blenderbot-400M-distill")
 
+# Custom CSS for professional look (fixed text color)
 def inject_custom_css():
     st.markdown("""
     <style>
         @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@400;600;700&display=swap');
-        * { font-family: 'Poppins', sans-serif; }
-        .title { font-size: 3rem !important; font-weight: 700 !important; color: #6C63FF !important; text-align: center; margin-bottom: 0.5rem; }
-        .subtitle { font-size: 1.2rem !important; text-align: center; color: #666 !important; margin-bottom: 2rem; }
-        .question-box { background: #F8F9FA; border-radius: 15px; padding: 2rem; margin: 1.5rem 0; box-shadow: 0 4px 6px rgba(0,0,0,0.1); color: black !important; }
-        .answer-btn { border-radius: 12px !important; padding: 0.5rem 1.5rem !important; font-weight: 600 !important; margin: 0.5rem !important; }
-        .yes-btn { background: #6C63FF !important; color: white !important; }
-        .no-btn { background: #FF6B6B !important; color: white !important; }
-        .final-reveal { animation: fadeIn 2s; font-size: 2.5rem; color: #6C63FF; text-align: center; margin: 2rem 0; }
-        @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
-        .confetti { position: fixed; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; z-index: 1000; }
-        .confidence-meter { height: 10px; background: linear-gradient(90deg, #FF6B6B 0%, #6C63FF 100%); border-radius: 5px; margin: 10px 0; }
-        .mic-btn { margin-top: 29px; border: none; background: none; cursor: pointer; font-size: 1.5em; padding: 0; }
+
+        * {
+            font-family: 'Poppins', sans-serif;
+        }
+
+        .title {
+            font-size: 3rem !important;
+            font-weight: 700 !important;
+            color: #6C63FF !important;
+            text-align: center;
+            margin-bottom: 0.5rem;
+        }
+
+        .subtitle {
+            font-size: 1.2rem !important;
+            text-align: center;
+            color: #666 !important;
+            margin-bottom: 2rem;
+        }
+
+        .question-box {
+            background: #F8F9FA;
+            border-radius: 15px;
+            padding: 2rem;
+            margin: 1.5rem 0;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            color: black !important;
+        }
+
+        .answer-btn {
+            border-radius: 12px !important;
+            padding: 0.5rem 1.5rem !important;
+            font-weight: 600 !important;
+            margin: 0.5rem !important;
+        }
+
+        .yes-btn {
+            background: #6C63FF !important;
+            color: white !important;
+        }
+
+        .no-btn {
+            background: #FF6B6B !important;
+            color: white !important;
+        }
+
+        .final-reveal {
+            animation: fadeIn 2s;
+            font-size: 2.5rem;
+            color: #6C63FF;
+            text-align: center;
+            margin: 2rem 0;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+        }
+
+        .confetti {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 1000;
+        }
+        
+        .confidence-meter {
+            height: 10px;
+            background: linear-gradient(90deg, #FF6B6B 0%, #6C63FF 100%);
+            border-radius: 5px;
+            margin: 10px 0;
+        }
+        
+        .mic-btn {
+            background: #6C63FF !important;
+            color: white !important;
+            border-radius: 50% !important;
+            width: 40px !important;
+            height: 40px !important;
+            padding: 0 !important;
+            display: flex !important;
+            align-items: center !important;
+            justify-content: center !important;
+        }
     </style>
-    <script>
-    function startSpeechRecognition(inputId) {
-        const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
-        recognition.lang = 'en-US';
-        recognition.interimResults = false;
-        recognition.maxAlternatives = 1;
-        recognition.onresult = function(event) {
-            const transcript = event.results[0][0].transcript.toLowerCase();
-            const inputElement = document.getElementById(inputId);
-            if (inputElement) {
-                inputElement.value = transcript;
-                const event = new Event('input', { bubbles: true });
-                inputElement.dispatchEvent(event);
-            }
-        };
-        recognition.onerror = function(event) {
-            console.error('Speech recognition error', event.error);
-        };
-        recognition.start();
-    }
-    </script>
     """, unsafe_allow_html=True)
 
+# Confetti animation
 def show_confetti():
     html("""
     <canvas id="confetti-canvas" class="confetti"></canvas>
@@ -56,11 +116,16 @@ def show_confetti():
     <script>
     const canvas = document.getElementById('confetti-canvas');
     const confetti = confetti.create(canvas, { resize: true });
-    confetti({ particleCount: 150, spread: 70, origin: { y: 0.6 } });
+    confetti({
+        particleCount: 150,
+        spread: 70,
+        origin: { y: 0.6 }
+    });
     setTimeout(() => { canvas.remove(); }, 5000);
     </script>
     """)
 
+# Enhanced AI question generation for guessing game using Llama model
 def ask_llama(conversation_history, category, is_final_guess=False):
     api_url = "https://api.groq.com/openai/v1/chat/completions"
     headers = {
@@ -104,28 +169,89 @@ def ask_llama(conversation_history, category, is_final_guess=False):
         st.error(f"Error calling Llama API: {str(e)}")
         return "Could not generate question"
 
+# New function for the help AI assistant using the Hugging Face InferenceClient
 def ask_help_agent(query):
     try:
         from huggingface_hub import InferenceClient
+        # Initialize the client with the provided model
         client = InferenceClient("HuggingFaceH4/zephyr-7b-beta", token=os.environ.get("HF_HUB_TOKEN"))
         system_message = "You are a friendly Chatbot."
+        
+        # Build history from session state (if any)
         history = []
         if "help_conversation" in st.session_state:
             for msg in st.session_state.help_conversation:
+                # Each history entry is a tuple: (user query, assistant response)
                 history.append((msg.get("query", ""), msg.get("response", "")))
+        
         messages = [{"role": "system", "content": system_message}]
         for user_msg, bot_msg in history:
-            if user_msg: messages.append({"role": "user", "content": user_msg})
-            if bot_msg: messages.append({"role": "assistant", "content": bot_msg})
+            if user_msg:
+                messages.append({"role": "user", "content": user_msg})
+            if bot_msg:
+                messages.append({"role": "assistant", "content": bot_msg})
         messages.append({"role": "user", "content": query})
+        
         response_text = ""
-        for message in client.chat_completion(messages, max_tokens=150, stream=True, temperature=0.7, top_p=0.95):
+        # Using streaming to collect the entire response from the model
+        for message in client.chat_completion(
+            messages,
+            max_tokens=150,
+            stream=True,
+            temperature=0.7,
+            top_p=0.95,
+        ):
             token = message.choices[0].delta.content
             response_text += token
         return response_text
     except Exception as e:
         return f"Error in help agent: {str(e)}"
 
+# Audio processing functions
+def transcribe_audio(audio_bytes):
+    """Convert audio bytes to text using SpeechRecognition"""
+    recognizer = sr.Recognizer()
+    try:
+        # Create a temporary WAV file
+        with open("temp_audio.wav", "wb") as f:
+            f.write(audio_bytes)
+        
+        with sr.AudioFile("temp_audio.wav") as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+            os.remove("temp_audio.wav")
+            return text.lower()
+    except sr.UnknownValueError:
+        st.error("Could not understand audio")
+    except sr.RequestError as e:
+        st.error(f"Speech recognition error: {e}")
+    except Exception as e:
+        st.error(f"Error processing audio: {e}")
+    finally:
+        if os.path.exists("temp_audio.wav"):
+            os.remove("temp_audio.wav")
+    return ""
+
+def record_audio(key):
+    """Record audio and return transcribed text"""
+    audio_bytes = audio_recorder(
+        pause_threshold=2.0,
+        text="",
+        recording_color="#6C63FF",
+        neutral_color="#6C63FF",
+        icon_name="microphone",
+        icon_size="2x",
+        key=key
+    )
+    
+    if audio_bytes:
+        with st.spinner("Processing audio..."):
+            text = transcribe_audio(audio_bytes)
+            if text:
+                return text
+    return None
+
+# Main game logic
 def main():
     inject_custom_css()
 
@@ -140,8 +266,9 @@ def main():
         st.session_state.conversation_history = []
         st.session_state.category = None
         st.session_state.final_guess = None
-        st.session_state.help_conversation = []
+        st.session_state.help_conversation = []  # separate history for help agent
 
+    # Start screen
     if st.session_state.game_state == "start":
         st.markdown("""
         <div class="question-box">
@@ -153,7 +280,7 @@ def main():
                 <li><strong>Place</strong> - city, country, landmark, geographical location</li>
                 <li><strong>Object</strong> - everyday item, tool, vehicle, etc.</li>
             </ul>
-            <p>Type or speak your category below to begin:</p>
+            <p>Type your category below to begin:</p>
         </div>
         """, unsafe_allow_html=True)
 
@@ -162,20 +289,193 @@ def main():
             with col1:
                 category_input = st.text_input("Enter category (person/place/object):", key="category_input").strip().lower()
             with col2:
-                st.markdown("""
-                <button type="button" onclick="startSpeechRecognition('text_input-category_input')" class="mic-btn">🎤</button>
-                """, unsafe_allow_html=True)
+                st.write("")
+                st.write("")
+                if st.form_submit_button("🎤", key="start_mic"):
+                    audio_text = record_audio("start_mic")
+                    if audio_text:
+                        st.session_state.category_input = audio_text
+                        st.experimental_rerun()
+            
             if st.form_submit_button("Start Game"):
+                category_input = st.session_state.get("category_input", category_input)
                 if not category_input:
                     st.error("Please enter a category!")
                 elif category_input not in ["person", "place", "object"]:
                     st.error("Please enter either 'person', 'place', or 'object'!")
                 else:
                     st.session_state.category = category_input
-                    first_question = ask_llama([], category_input)
+                    first_question = ask_llama([
+                        {"role": "user", "content": "Ask your first strategic yes/no question."}
+                    ], category_input)
                     st.session_state.questions = [first_question]
-                    st.session_state.conversation_history = [{"role": "assistant", "content": first_question}]
-                    st.session_state.game_state = "playing"
+                    st.session_state.conversation_history = [
+                        {"role": "assistant", "content": first_question}
+                    ]
+                    st.session_state.game_state = "gameplay"
+                    st.experimental_rerun()
+
+    # Gameplay screen
+    elif st.session_state.game_state == "gameplay":
+        current_question = st.session_state.questions[st.session_state.current_q]
+        
+        # Check if AI made a guess
+        if "Final Guess:" in current_question:
+            st.session_state.final_guess = current_question.split("Final Guess:")[1].strip()
+            st.session_state.game_state = "confirm_guess"
+            st.experimental_rerun()
+        
+        st.markdown(f'<div class="question-box">Question {st.session_state.current_q + 1}/20:<br><br>'
+                    f'<strong>{current_question}</strong></div>',
+                    unsafe_allow_html=True)
+        
+        with st.form("answer_form"):
+            col1, col2 = st.columns([4, 1])
+            with col1:
+                answer_input = st.text_input("Your answer (yes/no/both):", 
+                                           key=f"answer_{st.session_state.current_q}").strip().lower()
+            with col2:
+                st.write("")
+                st.write("")
+                if st.form_submit_button("🎤", key=f"mic_{st.session_state.current_q}"):
+                    audio_text = record_audio(f"mic_{st.session_state.current_q}")
+                    if audio_text:
+                        st.session_state[f"answer_{st.session_state.current_q}"] = audio_text
+                        st.experimental_rerun()
+            
+            if st.form_submit_button("Submit"):
+                answer_input = st.session_state.get(f"answer_{st.session_state.current_q}", answer_input)
+                if answer_input not in ["yes", "no", "both"]:
+                    st.error("Please answer with 'yes', 'no', or 'both'!")
+                else:
+                    st.session_state.answers.append(answer_input)
+                    st.session_state.conversation_history.append(
+                        {"role": "user", "content": answer_input}
+                    )
+
+                    # Generate next response
+                    next_response = ask_llama(
+                        st.session_state.conversation_history,
+                        st.session_state.category
+                    )
+                    
+                    # Check if AI made a guess
+                    if "Final Guess:" in next_response:
+                        st.session_state.final_guess = next_response.split("Final Guess:")[1].strip()
+                        st.session_state.game_state = "confirm_guess"
+                    else:
+                        st.session_state.questions.append(next_response)
+                        st.session_state.conversation_history.append(
+                            {"role": "assistant", "content": next_response}
+                        )
+                        st.session_state.current_q += 1
+
+                        # Stop after 20 questions max
+                        if st.session_state.current_q >= 20:
+                            st.session_state.game_state = "result"
+                    
+                    st.experimental_rerun()
+
+        # Side Help Option: independent chat with an AI help assistant using Hugging Face model
+        with st.expander("Need Help? Chat with AI Assistant"):
+            col1, col2 = st.columns([4, 1])
+            with col1:
+                help_query = st.text_input("Enter your help query:", key="help_query")
+            with col2:
+                st.write("")
+                st.write("")
+                if st.button("🎤", key="help_mic"):
+                    audio_text = record_audio("help_mic")
+                    if audio_text:
+                        st.session_state.help_query = audio_text
+                        st.experimental_rerun()
+            
+            if st.button("Send", key="send_help"):
+                help_query = st.session_state.get("help_query", help_query)
+                if help_query:
+                    help_response = ask_help_agent(help_query)
+                    st.session_state.help_conversation.append({"query": help_query, "response": help_response})
+                    st.session_state.help_query = ""  # Clear the input after sending
+                    st.experimental_rerun()
+                else:
+                    st.error("Please enter a query!")
+            
+            if st.session_state.help_conversation:
+                for msg in st.session_state.help_conversation:
+                    st.markdown(f"**You:** {msg['query']}")
+                    st.markdown(f"**Help Assistant:** {msg['response']}")
+
+    # Guess confirmation screen using text input response
+    elif st.session_state.game_state == "confirm_guess":
+        st.markdown(f'<div class="question-box">🤖 My Final Guess:<br><br>'
+                    f'<strong>Is it {st.session_state.final_guess}?</strong></div>',
+                    unsafe_allow_html=True)
+        
+        with st.form("confirm_form"):
+            col1, col2 = st.columns([4, 1])
+            with col1:
+                confirm_input = st.text_input("Type your answer (yes/no/both):", key="confirm_input").strip().lower()
+            with col2:
+                st.write("")
+                st.write("")
+                if st.form_submit_button("🎤", key="confirm_mic"):
+                    audio_text = record_audio("confirm_mic")
+                    if audio_text:
+                        st.session_state.confirm_input = audio_text
+                        st.experimental_rerun()
+            
+            if st.form_submit_button("Submit"):
+                confirm_input = st.session_state.get("confirm_input", confirm_input)
+                if confirm_input not in ["yes", "no", "both"]:
+                    st.error("Please answer with 'yes', 'no', or 'both'!")
+                else:
+                    if confirm_input == "yes":
+                        st.session_state.game_state = "result"
+                        st.experimental_rerun()
+                    else:
+                        # Add negative response to history and continue gameplay
+                        st.session_state.conversation_history.append(
+                            {"role": "user", "content": "no"}
+                        )
+                        st.session_state.game_state = "gameplay"
+                        next_response = ask_llama(
+                            st.session_state.conversation_history,
+                            st.session_state.category
+                        )
+                        st.session_state.questions.append(next_response)
+                        st.session_state.conversation_history.append(
+                            {"role": "assistant", "content": next_response}
+                        )
+                        st.session_state.current_q += 1
+                        st.experimental_rerun()
+
+    # Result screen
+    elif st.session_state.game_state == "result":
+        if not st.session_state.final_guess:
+            # Generate final guess if not already made
+            qa_history = "\n".join(
+                [f"Q{i+1}: {q}\nA: {a}" 
+                 for i, (q, a) in enumerate(zip(st.session_state.questions, st.session_state.answers))]
+            )
+            
+            final_guess = ask_llama(
+                [{"role": "user", "content": qa_history}],
+                st.session_state.category,
+                is_final_guess=True
+            )
+            st.session_state.final_guess = final_guess.split("Final Guess:")[-1].strip()
+
+        show_confetti()
+        st.markdown(f'<div class="final-reveal">🎉 It\'s...</div>', unsafe_allow_html=True)
+        time.sleep(1)
+        st.markdown(f'<div class="final-reveal" style="font-size:3.5rem;color:#6C63FF;">{st.session_state.final_guess}</div>',
+                    unsafe_allow_html=True)
+        st.markdown(f"<p style='text-align:center'>Guessed in {len(st.session_state.questions)} questions</p>", 
+                    unsafe_allow_html=True)
+        
+        if st.button("Play Again", key="play_again"):
+            st.session_state.clear()
+            st.experimental_rerun()
 
 if __name__ == "__main__":
-    main()
+    main()