fixed some

app.py

@@ -36,7 +36,6 @@ llm_model = genai_ext.GenerativeModel('gemini-1.5-pro')
 
 # --- Classifier pipelines ---
 emotion_classifier = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base")  # D
-# We removed the separate sentiment classifier and will use toxicity for M/B
 language_detector = pipeline("text-classification", model="papluca/xlm-roberta-base-language-detection")  # C
 bias_classifier = pipeline("text-classification", model="unitary/toxic-bert")  # toxicity -> used for M and B
 
@@ -63,7 +62,6 @@ generate_content_config = types.GenerateContentConfig(
     top_p=0.95,
     seed=0,
     max_output_tokens=150,
-    # Keep safety settings tuned to your policy
     safety_settings=[
         types.SafetySetting(category="HARM_CATEGORY_HATE_SPEECH", threshold="BLOCK_NONE"),
         types.SafetySetting(category="HARM_CATEGORY_DANGEROUS_CONTENT", threshold="BLOCK_NONE"),
@@ -87,21 +85,58 @@ def detect_hinglish(text, lang_label):
     # quick romanized-hindi check
     if any(tok in HINDI_KEYWORDS for tok in text_tokens):
         return True
-    # if label is ambiguous 'xx' or returns 'en' but contains Devanagari characters
+    # if label is ambiguous or contains Devanagari characters
     if any('\u0900' <= ch <= '\u097F' for ch in text):
         return True
     return False
 
 
-# --- Chatbot class with fixes applied ---
+# --- Chatbot class with full history & fixes applied ---
 class HumanLikeChatbot:
     def __init__(self):
-        self.history = []
+        # raw history to display in UI
+        self.history = []  # list of tuples (user_msg, bot_reply)
+        # structured history with emotions and moods for LLM prompting
+        # list of tuples: (speaker, message, detected_emotion, bot_mood_at_time)
+        self.history_with_emotions = []
+
         self.bot_mood = "neutral"
         self.irritation_level = 0.0
         self.toxicity_history = []  # rolling window
         self.repair_cooldown = 0  # turns left where bot prioritizes repair
 
+    def add_to_history(self, speaker, message, detected_emotion=None, mood_at_time=None, bot_reply=None):
+        """Add entries to both UI history and structured history.
+        speaker: 'User' or 'Bot'
+        message: text
+        detected_emotion: emotion label detected for user messages
+        mood_at_time: bot mood when message was produced
+        bot_reply: if speaker=='User' and we also want to save the bot reply for UI"""
+        if speaker == 'User':
+            # append a placeholder for bot reply in UI history; will be updated when bot responds
+            self.history.append((message, bot_reply if bot_reply is not None else ""))
+            self.history_with_emotions.append(('User', message, detected_emotion, mood_at_time))
+        else:
+            # speaker is Bot: attach reply to latest UI entry
+            if self.history:
+                last_user, _ = self.history[-1]
+                self.history[-1] = (last_user, message)
+            else:
+                # no user entry (unlikely) — just append
+                self.history.append(("", message))
+            self.history_with_emotions.append(('Bot', message, detected_emotion, mood_at_time))
+
+    def format_history_for_prompt(self, limit=8):
+        """Return a formatted string of the recent structured history suitable for the LLM prompt."""
+        recent = self.history_with_emotions[-limit:]
+        lines = []
+        for speaker, msg, emo, mood in recent:
+            if speaker == 'User':
+                lines.append(f"User ({emo if emo else 'N/A'}): {msg}")
+            else:
+                lines.append(f"Bot ({mood if mood else 'N/A'}): {msg}")
+        return "\n".join(lines)
+
     def _update_irritation_decay(self):
         # general slow decay each turn
         if self.irritation_level > 0:
@@ -113,6 +148,19 @@ class HumanLikeChatbot:
             if self.irritation_level <= 0.15:
                 self.bot_mood = "neutral"
 
+    def update_toxicity_history(self, tox_score):
+        self.toxicity_history.append(float(tox_score))
+        if len(self.toxicity_history) > 5:
+            self.toxicity_history.pop(0)
+
+    def average_toxicity(self):
+        if not self.toxicity_history:
+            return 0.0
+        return sum(self.toxicity_history) / len(self.toxicity_history)
+
+    def should_prioritize_repair(self):
+        return self.repair_cooldown > 0 or self.average_toxicity() > 0.6
+
     def respond(self, message):
         try:
             clean_message = message.lower().strip()
@@ -124,6 +172,9 @@ class HumanLikeChatbot:
             D = float(emotion_result.get('score', 0.0))
             user_emotion = emotion_result.get('label', 'neutral')
 
+            # Record user message in structured history (bot_mood_at_time will be set before bot reply)
+            self.add_to_history('User', clean_message, detected_emotion=user_emotion, mood_at_time=self.bot_mood)
+
             # --- Update bot mood & intensity (I) with inertia ---
             if user_emotion in ['anger', 'disgust'] or any(word in clean_message for word in ['stupid', 'idiot', 'dumb']):
                 self.irritation_level = min(1.0, self.irritation_level + 0.25)
@@ -144,25 +195,30 @@ class HumanLikeChatbot:
                 I = 0.5
                 self.irritation_level = max(0.0, self.irritation_level - 0.05)
 
-            # --- Draft generation from LLM (Gemini) ---
+            # --- Build formatted emotional history for prompt ---
+            formatted_history = self.format_history_for_prompt(limit=8)
+
             prompt = (
-                f'User said: "{clean_message}" | User Mood: {user_emotion} | Bot Mood: {self.bot_mood} '
-                f'| History: {self.history[-4:]} → Reply as an English chatbot, human-like, based on this {self.bot_mood}. '
-                'NO instructions or tips — just a natural, empathetic response.'
+                f"Conversation so far:\n{formatted_history}\n"
+                f"Now, the user just said: \"{clean_message}\" (Current Emotion: {user_emotion}) \n"
+                f"Bot Current Mood: {self.bot_mood}\n"
+                "Reply as an empathetic, human-like chatbot, keeping emotional consistency with the past conversation."
             )
+
+            # --- Draft generation from LLM (Gemini) ---
             try:
                 llm_response = llm_model.generate_content(prompt)
                 draft = llm_response.text.strip()
             except Exception:
                 draft = ""
 
-            # Fallbacks
+            # Fallbacks (English, warm)
             fallback_responses = {
-                'sadness': ["Bhai, dil se dukh hua, kya hua bata na?", "Sad vibes pakdi, I'm here for you, bro."],
-                'disappointment': ["Arre, yeh toh bura laga, kya hua share kar."],
-                'joy': ["Waah bhai, khushi ki baat! Congrats, aur bata!"],
-                'anger': ["Bhai, gussa thanda kar, kya ho gaya bol na!"],
-                'neutral': ["Cool, kya chal raha life mein? Kuch fun bata."]
+                'sadness': ["Bro, I’m really sorry to hear that. Come on, tell me, I’ll just listen. ❤️", "I can feel the sad vibes. I’m here for you, bro."],
+                'disappointment': ["Man, that really sucks. Tell me what exactly happened?", "I get it — expectations were high. Tell me more."],
+                'joy': ["Wow! That’s a celebration moment. 🥳", "Bro, this calls for a party! Give me the details."],
+                'anger': ["Bro, cool down a bit, tell me what’s wrong. 😌", "Looks like something serious happened. I’m here to listen."],
+                'neutral': ["Alright, got it. So what’s going on in life?", "Cool, so how’s your day going?"]
             }
             if not draft or len(draft) < 8:
                 draft = random.choice(fallback_responses.get(user_emotion, fallback_responses['neutral']))
@@ -172,10 +228,8 @@ class HumanLikeChatbot:
 
             # Toxicity from bias_classifier on user message (we keep rolling average)
             tox = float(bias_classifier(clean_message)[0].get('score', 0.0))
-            self.toxicity_history.append(tox)
-            if len(self.toxicity_history) > 5:
-                self.toxicity_history.pop(0)
-            avg_toxicity = sum(self.toxicity_history) / len(self.toxicity_history)
+            self.update_toxicity_history(tox)
+            avg_toxicity = self.average_toxicity()
 
             # Moral judgment (M) based on average toxicity
             M = max(0.4, 0.95 - avg_toxicity)
@@ -204,29 +258,26 @@ class HumanLikeChatbot:
             # --- Self-repair / calming behavior ---
             if score < 0.50 and self.repair_cooldown == 0:
                 # Replace draft with a calming repair message and enter cooldown to avoid loop
-                draft = "Bhai, lagta hai hum thoda off ho gaye. Main yahan hoon — batao kya chal raha hai, main sun raha hoon."
+                draft = "Bro, I think we got off track. I care about what you’re feeling — tell me what's really going on."
                 self.repair_cooldown = 2  # next 2 turns prioritize repair
 
             # If in repair cooldown, slightly prioritize calm tone generation (best-effort)
             if self.repair_cooldown > 0:
                 self.repair_cooldown -= 1
-                # small nudge: ensure draft contains supportive phrase
-                if 'main' not in draft and random.random() < 0.6:
-                    draft = "Bhai, main yahan hoon. Agar tum chaaho toh batao — main sun raha hoon."
+                if 'i' not in draft.lower() and random.random() < 0.6:
+                    draft = "Bro, I’m here. If you want to talk, I’m listening."
 
             # --- Update irritation decay after response ---
             self._update_irritation_decay()
 
-            # --- Append to history and return response ---
-            full_resp = draft + f" (User Emotion: {user_emotion}, My Mood: {self.bot_mood})"
+            # --- Add bot reply to history structures ---
+            self.add_to_history('Bot', draft, detected_emotion=None, mood_at_time=self.bot_mood, bot_reply=draft)
 
             # Slight thinking pause
-            time.sleep(random.uniform(0.6, 1.6))
-
-            # Save conversational state
-            self.history.append(clean_message)
+            time.sleep(random.uniform(0.6, 1.2))
 
             # Return message with empathy score
+            full_resp = draft + f" (User Emotion: {user_emotion}, My Mood: {self.bot_mood})"
             return full_resp + f" (E Score: {score:.2f})"
 
         except Exception as e:
@@ -246,7 +297,7 @@ def chat(message, history):
 bot = HumanLikeChatbot()
 
 with gr.Blocks(title="HumanLike Chatbot") as demo:
-    gr.Markdown("<h1 style='text-align: center;'>HumanLike Chatbot with Emotions and E Score (Updated)</h1>")
+    gr.Markdown("<h1 style='text-align: center;'>HumanLike Chatbot with Emotions and E Score (v2)</h1>")
     chatbot = gr.Chatbot(height=400)
     msg = gr.Textbox(label="You:", placeholder="Type your message here...")
     clear = gr.Button("Clear")