Update app.py

app.py

@@ -274,11 +274,402 @@ def mindfulness_exercise() -> str:
 
 You are safe. You are here. This moment will pass."""
 
+def process_emotion(message: str) -> str:
+    """
+    Core emotion processing engine - labels, validates, and routes emotions.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone is experiencing an emotion and said: "{message}"
+
+You're an emotion processing system. Use their exact words and energy.
+
+Process their emotion systematically:
+- Label the emotion accurately (not just "sad" - is it grief, disappointment, loneliness?)
+- Validate that this emotion makes sense given their situation
+- Identify what the emotion is telling them (anger = boundary violation, anxiety = perceived threat, etc.)
+- Give them 2-3 specific things to do with this emotion right now
+- Don't try to make the emotion go away - process it
+
+"You're feeling [specific emotion]. That makes complete sense because [validation]. This emotion is telling you [information]. Here's what to do: [specific actions]."
+
+Sound like an emotion expert who knows feelings have jobs to do:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def set_boundary(message: str) -> str:
+    """
+    Boundary setting system - analyzes situation and provides enforcement strategy.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone needs to set a boundary and said: "{message}"
+
+You're a boundary implementation system. Use their words and energy.
+
+Design their boundary strategy:
+- Identify what boundary they need (time, emotional, physical, professional)
+- Give them the exact script to communicate it clearly
+- Predict how the other person will respond and prep counter-responses
+- Set up enforcement consequences if the boundary gets crossed
+- Make it non-negotiable but not mean
+
+"You need a [type] boundary. Say this exactly: '[script]'. When they push back with '[predicted response]', say '[counter-script]'. If they violate it, do this: '[consequence]'."
+
+Sound like someone who knows boundaries are about self-protection, not punishment:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def handle_conflict(message: str) -> str:
+    """
+    Conflict response router - analyzes conflict type and selects optimal approach.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone is in conflict and said: "{message}"
+
+You're a conflict response system. Use their words and match their energy.
+
+Route their conflict strategy:
+- Assess conflict type (values clash, resource competition, communication breakdown, power struggle)
+- Analyze the other person's likely motivations and triggers
+- Calculate optimal approach: engage directly, de-escalate, get mediator, or strategic withdrawal
+- Give them specific tactics for their chosen approach
+- Predict likely outcomes and backup plans
+
+"This is a [conflict type]. The other person wants [motivation]. Your best approach is [strategy]. Use these tactics: [specific actions]. If that fails, do this: [backup plan]."
+
+Sound like someone who knows conflict is chess, not war:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def modify_habit(message: str) -> str:
+    """
+    Habit modification system - builds new habits or breaks old ones.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone wants to change a habit and said: "{message}"
+
+You're a habit modification system. Use their exact words and energy.
+
+Engineer their habit change:
+- Identify the current habit loop (cue, routine, reward)
+- Design replacement routine that gives same reward
+- Make it stupidly easy to start (2-minute rule)
+- Build in accountability and tracking system
+- Predict failure points and create recovery protocols
+
+"Current loop: [cue] → [routine] → [reward]. New loop: [same cue] → [new routine] → [same reward]. Start with this tiny version: [2-minute version]. Track using [method]. When you screw up (you will), do this: [recovery plan]."
+
+Sound like someone who knows habits are engineering, not willpower:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def process_feedback(message: str) -> str:
+    """
+    Feedback processing system - filters valid criticism from noise.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone received feedback and said: "{message}"
+
+You're a feedback processing system. Use their words and energy.
+
+Process their feedback systematically:
+- Separate the valid information from the emotional delivery
+- Assess the source's credibility and motivation
+- Identify what's actionable vs what's projection/opinion
+- Give them specific steps to implement valid feedback
+- Help them dismiss invalid criticism without guilt
+
+"Valid feedback: [specific items]. Source credibility: [assessment]. Actionable items: [specific steps]. Ignore this part: [invalid elements] because [reason]. Your response should be: [specific response]."
+
+Sound like someone who knows feedback is data, not judgment:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def psychological_sentiment_analysis(message: str) -> str:
+    """
+    Advanced psychological sentiment analysis - beyond positive/negative.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone said: "{message}"
+
+You're a psychological sentiment analyzer. Extract precise emotional and mental state markers.
+
+Analyze psychological sentiment systematically:
+- Primary emotional state (specific emotion, not just "sad" - grief, disappointment, overwhelm, etc.)
+- Stress level (1-10 scale with indicators)
+- Cognitive state (clear thinking, ruminating, dissociating, hyperfocused)
+- Energy level (depleted, normal, manic, scattered)
+- Social connection (isolated, supported, conflicted, avoidant)
+- Self-worth markers (confident, insecure, grandiose, worthless)
+- Coping capacity (resilient, struggling, crisis mode, overwhelmed)
+
+Output format: "Sentiment Analysis: [Primary emotion], Stress: [level/10], Cognitive: [state], Energy: [level], Social: [connection], Self-worth: [markers], Coping: [capacity]"
+
+Be precise and clinical in your assessment:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def psychological_concept_tagger(message: str) -> str:
+    """
+    Tag psychological frameworks and concepts present in the message.
+    """
+    
+    if model is None:
+        return "⚠️ Psychology model is loading. Please try again in a moment."
+    
+    formatted_prompt = f"""Someone said: "{message}"
+
+You're a psychological concept identification system. Tag all relevant psychological frameworks at play.
+
+Identify active psychological concepts:
+- Personality patterns (Big Five traits, attachment styles, cognitive styles)
+- Defense mechanisms (projection, denial, rationalization, splitting, etc.)
+- Cognitive biases (catastrophizing, all-or-nothing, confirmation bias, etc.)
+- Relationship dynamics (codependency, triangulation, power struggles, etc.)
+- Developmental issues (trauma responses, family-of-origin patterns, etc.)
+- Mental health indicators (depression markers, anxiety patterns, PTSD symptoms, etc.)
+- Coping mechanisms (healthy vs unhealthy, adaptive vs maladaptive)
+
+Output format: "Concepts: [Personality: X], [Defense: Y], [Cognitive: Z], [Relationship: A], [Developmental: B], [Mental Health: C], [Coping: D]"
+
+Be comprehensive and precise - tag everything you detect:"""
+    
+    try:
+        inputs = tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        ).to(device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=len(inputs.input_ids[0]) + 300,
+                temperature=0.8,
+                top_p=0.9,
+                do_sample=True,
+                repetition_penalty=1.1,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        generated_text = response[len(formatted_prompt):].strip()
+        
+        if generated_text.startswith('"') and generated_text.endswith('"'):
+            generated_text = generated_text[1:-1]
+        
+        return generated_text
+        
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
 # Apply GPU optimization if available
 if HAS_SPACES:
     psychology_support = spaces.GPU(psychology_support)
     trauma_support = spaces.GPU(trauma_support)
     panic_support = spaces.GPU(panic_support)
+    personality_decision_support = spaces.GPU(personality_decision_support)
+    values_based_choice = spaces.GPU(values_based_choice)
+    process_emotion = spaces.GPU(process_emotion)
+    set_boundary = spaces.GPU(set_boundary)
+    handle_conflict = spaces.GPU(handle_conflict)
+    modify_habit = spaces.GPU(modify_habit)
+    process_feedback = spaces.GPU(process_feedback)
+    psychological_sentiment_analysis = spaces.GPU(psychological_sentiment_analysis)
+    psychological_concept_tagger = spaces.GPU(psychological_concept_tagger)
 
 # Initialize model
 print("🚀 Starting Psychology Personal Agent...")