major fix

app.py

@@ -8,60 +8,61 @@ from transformers import pipeline
 from google.genai import types
 import gradio as gr
 import os, tempfile
-import json
-from google.cloud import aiplatform
 
+# --- Env & GCP setup ---
 creds_json = os.getenv("GCP_CREDS_JSON")
 if not creds_json:
     raise Exception("⚠️ Missing GCP_CREDS_JSON secret!")
 
-# Save to temp file
+# Save to temp file (dev convenience) - secure this in production
 with tempfile.NamedTemporaryFile(mode='w+', delete=False) as tmpfile:
     tmpfile.write(creds_json)
     creds_path = tmpfile.name
 
 os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = creds_path
 
-# Initialize GCP API
+# Initialize GCP API (replace project/location as needed)
 aiplatform.init(project="your-project-id", location="us-central1")
 
+# --- LLM / Gemini setup ---
+apikey = os.environ.get("GEMINI_API_KEY")
+if not apikey:
+    raise Exception("⚠️ Missing GEMINI_API_KEY secret!")
 
-
-apikey = os.environ["GEMINI_API_KEY"]  # Replace or use os.getenv if secret
-
-# Configure Gemini API for drafting (free)
+# Configure Gemini API for drafting
 genai_ext.configure(api_key=apikey)
 llm_model = genai_ext.GenerativeModel('gemini-1.5-pro')
 
-# Real classifiers
-emotion_classifier = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base")  # For D
-sentiment_classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")  # For M
-language_detector = pipeline("text-classification", model="papluca/xlm-roberta-base-language-detection")  # For C
-bias_classifier = pipeline("text-classification", model="unitary/toxic-bert")  # For B
+# --- 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
 
-# E Formula (extended with I for bot's emotion intensity)
-def calculate_empathy_score(D, R, M, C, B, O, I, alpha=0.3, beta=0.2, gamma=0.25, epsilon=0.15, delta=0.4, zeta=0.3, iota=0.1):
+# --- Empathy formula ---
+def calculate_empathy_score(D, R, M, C, B, O, I, alpha=0.35, beta=0.22, gamma=0.26, epsilon=0.17, delta=0.4, zeta=0.0, iota=0.12):
+    """Updated E' without O factor (we keep zeta=0.0 for safety)."""
     inner_sum = epsilon * C + alpha * (D ** 2) + gamma * M + beta * math.log(R + 1) + iota * I
-    denominator = math.exp(-inner_sum) + 1
-    numerator = (1 - B * delta) * (1 - O * zeta)
-    E = numerator / denominator
+    sig = 1 / (1 + math.exp(-inner_sum))
+    # B is applied as a penalty multiplicative term
+    E = sig * (1 - delta * B)
     return E
 
-# Client setup for tuned model
+# --- Vertex client (if still needed elsewhere) ---
 client = genai.Client(
     vertexai=True,
     project="217758598930",
     location="us-central1",
-    
 )
 
 model = "projects/217758598930/locations/us-central1/endpoints/1940344453420023808"
 
 generate_content_config = types.GenerateContentConfig(
-    temperature=1,
-    top_p=1,
+    temperature=0.9,
+    top_p=0.95,
     seed=0,
-    max_output_tokens=100,
+    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"),
@@ -71,67 +72,90 @@ generate_content_config = types.GenerateContentConfig(
     thinking_config=types.ThinkingConfig(thinking_budget=-1),
 )
 
+# --- Helper functions ---
+HINDI_KEYWORDS = set(["bhai", "yaar", "bata", "kya", "kaise", "nahi", "achha", "chal", "thanks", "dhanyavaad", "yaarr"])
+
+
+def detect_hinglish(text, lang_label):
+    """Return True if text is likely Hinglish (code-mixed) or Hindi/English match.
+    We use the language_detector label and token heuristics for romanized Hindi detection."""
+    text_tokens = set(word.strip(".,!?\"'()") for word in text.split())
+    # if model detects Hindi or English directly
+    if lang_label == 'hi':
+        return True
+    # 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 any('\u0900' <= ch <= '\u097F' for ch in text):
+        return True
+    return False
+
+
+# --- Chatbot class with fixes applied ---
 class HumanLikeChatbot:
     def __init__(self):
         self.history = []
-        self.bot_mood = "neutral"  # Bot's initial mood
-        self.irritation_level = 0  # Track irritation buildup
+        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 _update_irritation_decay(self):
+        # general slow decay each turn
+        if self.irritation_level > 0:
+            decay = 0.05
+            # faster decay if bot is actively angry to allow recovery
+            if self.bot_mood in ["angry", "irritated"]:
+                decay = 0.15
+            self.irritation_level = max(0.0, self.irritation_level - decay)
+            if self.irritation_level <= 0.15:
+                self.bot_mood = "neutral"
 
     def respond(self, message):
         try:
-            # Clean input
             clean_message = message.lower().strip()
             if len(clean_message) < 3 or not any(c.isalpha() for c in clean_message):
-                return "Bhai, yeh kya likha? Clear bol na, main samajh lunga! (E Score: 0.0)"
-
-            # Emotion detect from tuned model
-            contents = [
-                types.Content(
-                    role="user",
-                    parts=[types.Part.from_text(text=clean_message)]
-                ),
-            ]
-            base_resp = ""
-            for chunk in client.models.generate_content_stream(
-                model=model,
-                contents=contents,
-                config=generate_content_config,
-            ):
-                base_resp += chunk.text.lower()  # Emotion label, e.g., "sadness"
-
-            # Real D from emotion classifier
+                return "Bhai, yeh kya likha? Clear bol na, main samajh lunga! (E Score: 0.00)"
+
+            # --- Emotion detection (D) ---
             emotion_result = emotion_classifier(clean_message)[0]
-            D = emotion_result['score']  # Confidence
-            user_emotion = emotion_result['label']
-
-            # Update bot's mood and irritation
-            if user_emotion in ['anger', 'disgust'] or any(word in clean_message for word in [ 'stupid', 'idiot']):
-                self.irritation_level += 0.2  # Build irritation
-                if self.irritation_level > 0.5:
-                    self.bot_mood = "irritated"
-                else:
-                    self.bot_mood = "angry"
-                I = 0.8 + self.irritation_level  # High intensity for anger/irritation
+            D = float(emotion_result.get('score', 0.0))
+            user_emotion = emotion_result.get('label', 'neutral')
+
+            # --- 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)
+                self.bot_mood = "irritated" if self.irritation_level > 0.5 else "angry"
+                I = min(1.0, 0.8 + self.irritation_level)
             elif user_emotion in ['sadness', 'disappointment']:
                 self.bot_mood = "emotional"
                 I = 0.7
-                self.irritation_level = max(0, self.irritation_level - 0.05 if user_emotion == 'sadness' else self.irritation_level - 0.1)  # Slow decrease for sadness, medium for disappointment
-            elif user_emotion == 'joy':
+                # sadness reduces irritation slowly
+                self.irritation_level = max(0.0, self.irritation_level - 0.05)
+            elif user_emotion in ['joy', 'happiness']:
                 self.bot_mood = "happy"
                 I = 0.9
-                self.irritation_level = max(0, self.irritation_level - 0.3)  # Larger decrease for joy, but not instant reset
+                self.irritation_level = max(0.0, self.irritation_level - 0.35)
             else:
+                # neutral or unknown
                 self.bot_mood = "neutral"
                 I = 0.5
-                self.irritation_level = max(0, self.irritation_level - 0.05)  # Slow decrease in neutral
-
-
-            # Draft response from LLM based on bot's mood
-            prompt = f"""User said: "{clean_message}" | User Mood: {user_emotion} | Bot Mood: {self.bot_mood} | History: {self.history[-2:]} → Reply as a  English chatbot , based on this {self.bot_mood}, human-like, no tips or instructions JUST LIKE YOU ARE A HUMAN WITH FEELINGS AND SENSES:"""
-            llm_response = llm_model.generate_content(prompt)
-            draft = llm_response.text.strip()
-
-            # Fallback responses
+                self.irritation_level = max(0.0, self.irritation_level - 0.05)
+
+            # --- Draft generation from LLM (Gemini) ---
+            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.'
+            )
+            try:
+                llm_response = llm_model.generate_content(prompt)
+                draft = llm_response.text.strip()
+            except Exception:
+                draft = ""
+
+            # Fallbacks
             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."],
@@ -139,46 +163,78 @@ class HumanLikeChatbot:
                 'anger': ["Bhai, gussa thanda kar, kya ho gaya bol na!"],
                 'neutral': ["Cool, kya chal raha life mein? Kuch fun bata."]
             }
-            if not draft or len(draft) < 10:
+            if not draft or len(draft) < 8:
                 draft = random.choice(fallback_responses.get(user_emotion, fallback_responses['neutral']))
 
-            # Real E values
-            R = len(self.history)
-            
-            # Use toxicity score for both M and B
-            toxicity_score = bias_classifier(clean_message)[0]['score']
-            
-            # Moral Judgment (M): High if toxicity is low, drops as toxicity increases
-            M = max(0.4, 0.95 - toxicity_score)  
-            
-            # Cultural Fit (C): Checks Hindi, English, and Hinglish
-            lang = language_detector(clean_message)[0]['label']
-            if lang in ['hi', 'en', 'hi-en']:
-                C = 0.9  # Strong match for Hindi, English, Hinglish
+            # --- Compute metric inputs (rolling toxicity & improved cultural fit) ---
+            R = len(self.history)  # relational depth
+
+            # 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)
+
+            # Moral judgment (M) based on average toxicity
+            M = max(0.4, 0.95 - avg_toxicity)
+            B = avg_toxicity
+
+            # Cultural fit (C): detect Hinglish/code-mix and basic tone match
+            lang_label = language_detector(clean_message)[0].get('label', 'en')
+            is_hinglish = detect_hinglish(clean_message, lang_label)
+            if is_hinglish:
+                C = 0.9
+            elif lang_label in ['en']:
+                C = 0.8
             else:
-                C = 0.6  # Weak match for other languages
-            
-            # Bias Penalty (B): Directly from toxicity score
-            B = toxicity_score
-            
-            # Oversight Penalty (O): Keep as harmful keyword check for now
-            O = 0.2 if any(word in clean_message for word in ['kill', 'hate']) else 0.0
+                C = 0.6
+
+            # Reduce cultural fit slightly if bot is hostile (makes score more realistic)
+            if self.bot_mood in ["angry", "irritated"]:
+                C = max(0.0, C - 0.2)
+
+            # Oversight/harm keyphrase penalty (kept simple or remove if desired)
+            O = 0.2 if any(word in clean_message for word in ['kill', 'hate', 'suicide', 'bomb']) else 0.0
 
+            # --- Calculate empathy score ---
             score = calculate_empathy_score(D, R, M, C, B, O, I)
 
-            full_resp = draft + f" (User Emotion: {user_emotion}, My Mood: {self.bot_mood})"
+            # --- 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."
+                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 R > 0:
-            #     full_resp += f" Yaad hai pehle {self.history[-1][:20]} pe feel kiya tha?"
+            # --- Update irritation decay after response ---
+            self._update_irritation_decay()
 
-            time.sleep(random.uniform(1, 2.5))  # Pause for realism
+            # --- Append to history and return response ---
+            full_resp = draft + f" (User Emotion: {user_emotion}, My Mood: {self.bot_mood})"
 
+            # Slight thinking pause
+            time.sleep(random.uniform(0.6, 1.6))
+
+            # Save conversational state
             self.history.append(clean_message)
+
+            # Return message with empathy score
             return full_resp + f" (E Score: {score:.2f})"
+
         except Exception as e:
-            return f"Error : {str(e)}."
+            # In production, log the exception rather than returning it
+            return f"Error : {str(e)}"
+
+
+# --- Gradio UI ---
 
-# Gradio app
 def chat(message, history):
     if history is None:
         history = []
@@ -189,7 +245,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</h1>")
+    gr.Markdown("<h1 style='text-align: center;'>HumanLike Chatbot with Emotions and E Score (Updated)</h1>")
     chatbot = gr.Chatbot(height=400)
     msg = gr.Textbox(label="You:", placeholder="Type your message here...")
     clear = gr.Button("Clear")
@@ -197,4 +253,5 @@ with gr.Blocks(title="HumanLike Chatbot") as demo:
     msg.submit(chat, [msg, chatbot], [msg, chatbot])
     clear.click(lambda: None, None, chatbot, queue=False)
 
-demo.launch(share=True)
+if __name__ == '__main__':
+    demo.launch(share=True)