Upload responder.py

responder.py

@@ -0,0 +1,692 @@
+import json
+import os
+import re
+import threading
+import torch
+from engine.drift import get_current_mode, apply_response_effects, generate_teaching_note
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+
+# -----------------------------
+# Dispatcher
+# -----------------------------
+
+def generate_response(student_prompt, persona, conversation_history, force_mode=None):
+    """
+    Generate a response from the client persona using AI or fallback logic.
+    Priority (when not forced): HF (local transformers) > Claude API > Local Templates
+    Returns: (response_text, updated_state, teaching_note)
+    """
+    try:
+        # Explicitly forced to local templates
+        if force_mode == "Templates (Local)":
+            print("FORCED: Using local templates")
+            return generate_response_local(student_prompt, persona, conversation_history)
+
+        # Explicitly forced to AI (local transformers)
+        if force_mode == "AI":
+            print("FORCED: Using Hugging Face transformers (AI)")
+            return generate_response_hf(student_prompt, persona, conversation_history)
+
+        # Default priority order if no force_mode
+        if os.getenv("HF_TOKEN"):
+            print("DEBUG: Attempting Hugging Face transformers generation...")
+            return generate_response_hf(student_prompt, persona, conversation_history)
+
+        if os.getenv("ANTHROPIC_API_KEY"):
+            print("DEBUG: Attempting Claude API generation...")
+            return generate_response_claude(student_prompt, persona, conversation_history)
+
+        print("DEBUG: Falling back to local templates")
+        return generate_response_local(student_prompt, persona, conversation_history)
+
+    except Exception as e:
+        from engine.utils import safe_log
+        safe_log("Response generation error", str(e))
+        # If user explicitly asked for AI, don’t silently fall back
+        if force_mode == "AI":
+            raise
+        return generate_response_local(student_prompt, persona, conversation_history)
+
+# -----------------------------
+# Local Transformers Generation
+# -----------------------------
+
+# Candidate models optimized for HF Spaces (smaller, faster models)
+# These models are specifically chosen for:
+# - Small size (< 1GB) for fast loading
+# - Good instruction following
+# - Fast inference on CPU
+# PRIORITIZED FOR SPEED: TinyLlama first (1.1B = 2.5x faster than Phi-2)
+MODEL_CANDIDATES = [
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0", # 1.1B params, very fast - PRIORITY FOR SPEED
+    "microsoft/phi-2",                    # 2.7B params, excellent quality but slower
+    "facebook/opt-350m",                   # 350M params, fast fallback
+    "distilgpt2",                          # 82M params, extremely fast
+]
+
+_TOKENIZER = None
+_MODEL = None
+_MODEL_NAME = None
+
+def _select_dtype():
+    """Select appropriate dtype based on available hardware."""
+    if torch.cuda.is_available():
+        return torch.float16  # Use float16 for GPU (faster than bfloat16 on most GPUs)
+    return torch.float32      # CPU uses float32
+
+def _ensure_model_loaded():
+    """Load the most suitable model for the current environment."""
+    global _TOKENIZER, _MODEL, _MODEL_NAME
+    if _TOKENIZER is not None:
+        return
+
+    last_error = None
+    for model_name in MODEL_CANDIDATES:
+        try:
+            print(f"Loading model: {model_name}")
+            _TOKENIZER = AutoTokenizer.from_pretrained(
+                model_name,
+                use_fast=True,
+                trust_remote_code=True  # Some models like Phi-2 need this
+            )
+
+            # Add padding token if not present
+            if _TOKENIZER.pad_token is None:
+                _TOKENIZER.pad_token = _TOKENIZER.eos_token
+
+            # Load model with optimizations for HF Spaces
+            _MODEL = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=_select_dtype(),
+                device_map="auto",
+                low_cpu_mem_usage=True,  # Optimize memory usage
+                trust_remote_code=True    # Some models need this
+            )
+
+            # Set to eval mode for inference
+            _MODEL.eval()
+
+            _MODEL_NAME = model_name
+            print(f"✓ Loaded {model_name} successfully")
+            return
+        except Exception as e:
+            last_error = e
+            print(f"✗ Failed to load {model_name}: {str(e)[:200]}")
+            continue
+    raise RuntimeError(f"Could not load any candidate model. Last error: {last_error}")
+
+import re
+import threading
+import torch
+from transformers import TextIteratorStreamer
+
+def _select_relevant_facts(facts, prompt, count=5):
+    """
+    Select most relevant facts based on prompt content.
+    Returns a mix of always-relevant facts and prompt-specific ones.
+    """
+    if not facts:
+        return []
+
+    prompt_lower = prompt.lower()
+    scored_facts = []
+
+    # Keywords to look for in prompt
+    keywords = {
+        'work': ['work', 'job', 'boss', 'career', 'coworker', 'supervisor', 'shift', 'office', 'construction'],
+        'family': ['family', 'dad', 'mom', 'brother', 'sister', 'parent', 'son', 'daughter', 'wife', 'husband'],
+        'pain': ['pain', 'hurt', 'ache', 'injury', 'physical', 'body', 'knee', 'back'],
+        'mental': ['feel', 'stress', 'anxiety', 'panic', 'worry', 'scared', 'overwhelm'],
+        'social': ['friend', 'people', 'social', 'lonely', 'isolated', 'relationship'],
+        'leisure': ['hobby', 'fun', 'enjoy', 'free time', 'weekend', 'relax', 'game', 'gaming'],
+        'future': ['future', 'plan', 'goal', 'retirement', 'college', 'next', 'change'],
+        'money': ['money', 'afford', 'cost', 'expensive', 'financial', 'save', 'pay']
+    }
+
+    for fact in facts:
+        fact_str = str(fact)
+        fact_lower = fact_str.lower()
+        score = 1  # Base score
+
+        # Check for keyword matches
+        for category, words in keywords.items():
+            if any(word in prompt_lower for word in words):
+                if any(word in fact_lower for word in words):
+                    score += 2
+
+        scored_facts.append((score, fact_str))
+
+    # Sort by relevance, take top facts
+    scored_facts.sort(reverse=True, key=lambda x: x[0])
+    return [fact for score, fact in scored_facts[:count]]
+
+def _check_triggers(prompt, triggers):
+    """
+    Check if prompt contains potentially triggering content.
+    Returns True if triggers detected.
+    """
+    if not triggers:
+        return False
+
+    prompt_lower = prompt.lower()
+    for trigger in triggers:
+        trigger_lower = str(trigger).lower()
+        # Check for key phrases from trigger
+        trigger_words = trigger_lower.split()[:3]  # First few words often most relevant
+        if any(word in prompt_lower for word in trigger_words if len(word) > 3):
+            return True
+    return False
+
+def generate_response_hf(prompt, persona, conversation_history, stream_callback=None):
+    """
+    Generate a deeply persona-grounded response using local transformers.
+    Leverages rich persona data for authentic, psychologically complex responses.
+    Supports optional streaming via stream_callback.
+    """
+    _ensure_model_loaded()
+
+    name = persona.get("persona_name", "Client")
+    age = persona.get("age", "")
+    role = persona.get("role", "")
+    state = persona.get("default_state", {}) or {}
+    mode = get_current_mode(state)
+
+    # Apply response effects
+    state = apply_response_effects(state, prompt)
+    mode = get_current_mode(state)
+
+    # Extract rich persona elements
+    system_prompt = persona.get("system_prompt", "").strip()
+    facts = persona.get("facts", [])
+    triggers = persona.get("triggers", [])
+    reasoning_style = persona.get("reasoning_style", "").strip()
+    resilience_hooks = persona.get("resilience_hooks", [])
+
+    # Get tone guidance for current mode
+    tone_guidance = persona.get("tone_guidance", {}).get(mode, {})
+    tone_voice = tone_guidance.get("voice", "Natural and authentic")
+    tone_example = tone_guidance.get("example", "")
+
+    # Select most relevant facts (mix of general and specific to prompt)
+    selected_facts = _select_relevant_facts(facts, prompt, count=3)  # Reduced from 5 for faster processing
+
+    # Check if prompt might trigger defensive response
+    is_potentially_triggering = _check_triggers(prompt, triggers)
+
+    # Extract current situation from emotional memory or conversation history
+    current_situation = "Normal day, no specific external stressors right now"
+    if state.get("emotional_memory"):
+        for memory in reversed(state["emotional_memory"]):
+            if memory.startswith("context:"):
+                current_situation = memory.replace("context:", "").strip()
+                break
+
+    # Build conversation context (last 2 turns for faster processing)
+    context = ""
+    if conversation_history:
+        for turn in conversation_history[-2:]:  # Reduced from 3 to 2 for speed
+            if "student" in turn and "client" in turn:
+                context += f"Student: {turn['student']}\n{name}: {turn['client']}\n\n"
+
+    # Build optimized instruction (reduced tokens for speed)
+    instruction = f"""You are {name}, {age}, {role}. In OT therapy session.
+
+RESPOND as {name} only. 5-6 sentences. Be authentic. NO analysis or questions.
+
+BACKGROUND: {system_prompt}
+
+LIFE CONTEXT:
+{chr(10).join(f'• {fact}' for fact in selected_facts)}
+
+CURRENT SITUATION: {current_situation}
+
+EMOTIONAL STATE ({mode}): Anxiety {state.get('anxiety', 0.5):.2f}, Trust {state.get('trust', 0.5):.2f}, Openness {state.get('openness', 0.5):.2f}
+
+TONE: {tone_voice} Example: "{tone_example}"
+
+"""
+
+    if context:
+        instruction += f"""CONVERSATION SO FAR:
+{context}"""
+
+    instruction += f"""Student: {prompt}
+{name}:"""
+
+
+    # Tokenize
+    inputs = _TOKENIZER(instruction, return_tensors="pt", padding=True, truncation=True).to(_MODEL.device)
+
+    # Streaming setup
+    streamer = TextIteratorStreamer(_TOKENIZER, skip_prompt=True, skip_special_tokens=True) if stream_callback else None
+
+    generation_kwargs = {
+        "input_ids": inputs["input_ids"],
+        "attention_mask": inputs["attention_mask"],
+        "max_new_tokens": 70,    # Optimized for 5-6 sentences (10-12 words each) - SPEED PRIORITY
+        "min_length": 40,        # Ensure minimum response quality
+        "temperature": 0.7,      # Optimized for speed while maintaining variety
+        "top_p": 0.85,           # Faster sampling, still good quality
+        "do_sample": True,
+        "use_cache": True,       # Reuse attention computations for speed
+        "streamer": streamer,
+        "pad_token_id": _TOKENIZER.eos_token_id or _TOKENIZER.pad_token_id,
+        "eos_token_id": _TOKENIZER.eos_token_id,  # Explicit early stopping
+        "repetition_penalty": 1.1,  # Reduced from 1.15 for faster generation
+    }
+
+    response_text = ""
+
+    # Use inference mode for better performance
+    with torch.inference_mode():
+        if streamer:
+            def _consume():
+                nonlocal response_text
+                for token_text in streamer:
+                    response_text += token_text
+                    try:
+                        stream_callback(token_text)
+                    except Exception:
+                        pass
+            thread = threading.Thread(target=_consume, daemon=True)
+            thread.start()
+            _MODEL.generate(**generation_kwargs)
+            thread.join()
+        else:
+            outputs = _MODEL.generate(**generation_kwargs)
+            raw_text = _TOKENIZER.decode(outputs[0], skip_special_tokens=True)
+            # Strip any echoed instruction
+            response_text = raw_text.replace(instruction, "").strip()
+
+    # Clean response
+    response_text = response_text.strip()
+    response_text = re.sub(r'---.*?---', '', response_text)   # remove separators
+    response_text = re.sub(r'\[.*?\]', '', response_text)     # remove bracketed notes
+    response_text = re.sub(r'^(Student:|' + re.escape(name) + ':)', '', response_text).strip()
+
+    # Truncate at first sign of role switch
+    for stop_token in [f"Student:", f"\nStudent:", f"\n\nStudent:", f"\n{name}:", f"\n\n{name}:"]:
+        if stop_token in response_text:
+            response_text = response_text.split(stop_token)[0].strip()
+            break
+
+    # Remove meta-commentary (questions for students, analysis, etc.)
+    # Stop at any meta-questions or analysis markers
+    meta_markers = [
+        "<|Question|>", "<|Answer|>", "<|Analysis|>",
+        "<|beginning", "<|end", "<|template", "<|conversation",  # Template markers
+        "\n(a)", "\n(b)", "\n(c)",  # Lettered questions
+        " : ", ": Identify", ": What", ": How", ": Why", ": Describe",  # Colon-separated analysis
+        "[Answer:", "[Question:", "[Analysis:",  # Bracketed sections
+        "What emotions", "How might", "Why do you think",  # Question stems
+        "This response shows", "Notice how", "Observe that",  # Analysis stems
+        "Identify the elements", "What possible factors", "Consider how"  # More analysis patterns
+    ]
+    for marker in meta_markers:
+        if marker in response_text:
+            response_text = response_text.split(marker)[0].strip()
+            break
+
+    # Additional cleanup: remove anything after double colon or bracket patterns
+    response_text = re.sub(r'\s*:\s*[A-Z][^.!?]*\?.*$', '', response_text, flags=re.DOTALL)  # Remove ": Question..." patterns
+    response_text = re.sub(r'\[Answer:.*$', '', response_text, flags=re.DOTALL)  # Remove [Answer: ...] patterns
+    response_text = re.sub(r'\[Question:.*$', '', response_text, flags=re.DOTALL)  # Remove [Question: ...] patterns
+    response_text = re.sub(r'<\|[^|]*\|>.*$', '', response_text, flags=re.DOTALL)  # Remove <|anything|> patterns
+
+    # Guard against instruction leakage
+    if response_text.lower().startswith("be sure to") or "use correct" in response_text.lower():
+        response_text = "I'm doing alright today. Just keeping things running, like always."
+    
+    if not response_text:
+        response_text = "Sorry, I didn’t catch that. Could you rephrase?"
+
+    # Update emotional memory
+    if "emotional_memory" in state:
+        if not isinstance(state["emotional_memory"], list):
+            state["emotional_memory"] = []
+        tag = f"{mode}:neutral"
+        state["emotional_memory"].append(tag)
+        state["emotional_memory"] = state["emotional_memory"][-5:]
+
+    # Teaching note
+    teaching_note = generate_teaching_note(state, prompt, mode)
+    teaching_note += f"\n\n💡 Response generated locally with Transformers ({_MODEL_NAME})."
+
+    return response_text, state, teaching_note
+
+
+def generate_response_claude(student_prompt, persona, conversation_history):
+    """
+    Generate response using Claude API (optional premium feature).
+    """
+    try:
+        import anthropic
+        
+        state = persona.get("default_state", {})
+        mode = get_current_mode(state)
+        
+        # Apply response effects to state
+        state = apply_response_effects(state, student_prompt)
+        mode = get_current_mode(state)
+        
+        # Build prompts
+        system_prompt = build_system_prompt_for_ai(persona, state, mode)
+        conversation_context = build_conversation_context(conversation_history)
+        
+        # Call Claude API
+        client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+        message = client.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=400,
+            system=system_prompt,
+            messages=[
+                {"role": "user", "content": f"{conversation_context}\n\nOT Student: {student_prompt}"}
+            ]
+        )
+        
+        response_text = message.content[0].text
+        
+        # Update emotional memory
+        if "emotional_memory" in state:
+            if not isinstance(state["emotional_memory"], list):
+                state["emotional_memory"] = []
+            memory_tag = determine_memory_tag(student_prompt, mode, state)
+            state["emotional_memory"].append(memory_tag)
+            state["emotional_memory"] = state["emotional_memory"][-5:]
+        
+        teaching_note = generate_teaching_note(state, student_prompt, mode)
+        teaching_note += "\n\n✨ Response generated using Claude AI (Premium)"
+        
+        return response_text, state, teaching_note
+        
+    except Exception as e:
+        from engine.utils import safe_log
+        safe_log("Claude API error", str(e))
+        return generate_response_local(student_prompt, persona, conversation_history)
+
+
+def generate_response_local(student_prompt, persona, conversation_history):
+    """
+    Local response generation using persona templates and state-based selection.
+    Fallback when no AI available or as primary mode.
+    """
+    state = persona.get("default_state", {})
+    mode = get_current_mode(state)
+    name = persona.get("persona_name", "Client")
+    
+    # Apply response effects to state
+    state = apply_response_effects(state, student_prompt)
+    
+    # Update mode after response effects
+    mode = get_current_mode(state)
+    
+    # Select response based on mode and prompt analysis
+    response = select_response_template(
+        student_prompt,
+        name,
+        mode,
+        state,
+        persona,
+        conversation_history
+    )
+    
+    # Update emotional memory
+    if "emotional_memory" in state:
+        if not isinstance(state["emotional_memory"], list):
+            state["emotional_memory"] = []
+        
+        memory_tag = determine_memory_tag(student_prompt, mode, state)
+        state["emotional_memory"].append(memory_tag)
+        state["emotional_memory"] = state["emotional_memory"][-5:]
+    
+    # Generate teaching note
+    teaching_note = generate_teaching_note(state, student_prompt, mode)
+    teaching_note += "\n\n🔧 Response generated using template system (Local)"
+    
+    return response, state, teaching_note
+
+
+def build_system_prompt_for_ai(persona, state, mode, student_input):
+    """
+    Build a detailed system prompt for AI models to generate in-character responses.
+    """
+    name = persona.get("persona_name", "Client")
+    age = persona.get("age", "")
+    role = persona.get("role", "")
+
+    # Get tone guidance for current mode
+    tone_guidance = persona.get("tone_guidance", {}).get(mode, {})
+    tone_voice = tone_guidance.get("voice", "Natural and authentic")
+    tone_example = tone_guidance.get("example", "")
+
+    # Get some facts about the persona
+    facts = persona.get("facts", [])
+    key_facts = facts[:5] if isinstance(facts, list) else []
+
+    # Build system prompt
+    system_prompt = f"""You are {name}, a {age}-year-old {role}. You are talking to an occupational therapy student.
+
+CRITICAL INSTRUCTIONS:
+- Respond ONLY as {name} – ONE response, then STOP
+- Do NOT generate both sides of the conversation
+- Do NOT include multiple turns or dialogue
+- Your response should be 2–5 sentences maximum
+- Stay completely in character
+
+YOUR BACKGROUND:
+{chr(10).join(f"- {fact}" for fact in key_facts)}
+
+CURRENT EMOTIONAL STATE:
+- Anxiety: {state.get('anxiety', 0):.2f}/1.0
+- Trust: {state.get('trust', 0):.2f}/1.0
+- Openness: {state.get('openness', 0):.2f}/1.0
+
+HOW TO RESPOND ({mode} mode):
+{tone_voice}
+Example: "{tone_example}"
+
+Now begin the conversation:
+Student: {student_input}
+{name}:"""
+
+    return prompt
+
+
+def build_conversation_context(history):
+    """Build context from conversation history for AI models."""
+    if not history:
+        return "This is the beginning of the conversation."
+    
+    context = "Previous conversation:\n"
+    for i, turn in enumerate(history[-3:], 1):  # Last 3 turns
+        if "student" in turn:
+            context += f"Student: {turn['student']}\n"
+        if "client" in turn:
+            context += f"You: {turn['client']}\n"
+    
+    return context
+
+def handle_greeting(name, mode, state, persona):
+    """Generate responses for initial greetings."""
+    if name == "Jack":
+        if mode == "guarded":
+            return "Hey. So... what exactly are we doing here?"
+        else:
+            return "Hi. I'm Jack. Not really sure what to expect from this, but... yeah, here I am."
+    else:  # Maya
+        if mode == "anxious_but_functional":
+            return "Hi. Um, thanks for meeting with me. I've been... well, things have been a lot lately."
+        else:
+            return "Hello. I'm Maya. I appreciate you taking the time to talk with me."
+
+def select_response_template(prompt, name, mode, state, persona, history):
+    """
+    Select and customize a response based on the current mode and prompt content.
+    Used for local fallback when AI is unavailable.
+    """
+    prompt_lower = prompt.lower()
+    
+    # Handle greetings/introductions FIRST
+    if not history and any(word in prompt_lower for word in ["hi", "hello", "hey", "good morning", "good afternoon"]):
+        return handle_greeting(name, mode, state, persona)
+        
+    # Check for specific scenario triggers
+    if is_crisis_query(prompt_lower) and mode == "decompensating":
+        scripts = persona.get("scripts", {})
+        return scripts.get("crisis", "I don't feel safe right now. I need to pause.")
+    
+    # Check if prompt is about specific topics
+    if any(word in prompt_lower for word in ["work", "job", "boss", "brother", "supervisor"]):
+        return handle_work_topic(name, mode, state, persona, prompt_lower)
+    
+    if any(word in prompt_lower for word in ["pain", "hurt", "physical", "body"]):
+        return handle_pain_topic(name, mode, state, persona)
+    
+    if any(word in prompt_lower for word in ["feel", "feeling", "emotion"]):
+        return handle_feelings_topic(name, mode, state, persona, prompt_lower)
+    
+    if any(word in prompt_lower for word in ["family", "dad", "sister", "parent"]):
+        return handle_family_topic(name, mode, state, persona)
+    
+    # Default mode-based responses
+    return get_mode_based_response(name, mode, state, persona)
+
+
+def is_crisis_query(prompt_lower):
+    """Check if the prompt is asking about crisis/safety."""
+    crisis_terms = ["safe", "hurt yourself", "suicide", "end", "can't take"]
+    return any(term in prompt_lower for term in crisis_terms)
+
+
+def handle_work_topic(name, mode, state, persona, prompt_lower):
+    """Generate responses about work-related topics."""
+    if name == "Jack":
+        if mode == "triggered" or mode == "guarded":
+            return "I'd rather not get into it. Work is work, you know?"
+        elif mode == "trusting":
+            return "My brother's been on my case all week. It's like... I can't do anything right in his eyes. And my dad just backs him up because 'he's the foreman.' It's frustrating."
+        else:
+            return "Work's... fine. Same stuff, different day. Framing houses, dealing with Mike being Mike."
+    else:  # Maya
+        if mode == "triggered" or mode == "guarded":
+            return "It's just work stress. Everyone deals with it, right?"
+        elif mode == "trusting":
+            return "Honestly? I feel like I'm drowning. Between agency work and freelance projects, I'm just... constantly behind. And my review is coming up, so there's that pressure too."
+        else:
+            return "Work's been busy. Lots of deadlines. The usual design agency chaos."
+
+
+def handle_pain_topic(name, mode, state, persona):
+    """Generate responses about physical pain."""
+    pain_level = state.get("physical_discomfort", 0.5)
+    
+    if name == "Jack":
+        if pain_level > 0.6:
+            if mode == "trusting":
+                return "My knee's been killing me lately. Some days I'm limping by noon. I used to be able to do so much more physically, and now... yeah, it's frustrating."
+            else:
+                return "It's whatever. I just take some ibuprofen and push through. Not like I have a choice."
+        else:
+            return "Knee's okay today. Manageable."
+    else:  # Maya
+        if pain_level > 0.6:
+            if mode == "trusting":
+                return "The headaches are almost daily now, and my wrists hurt when I'm working. I keep thinking, what if I'm doing permanent damage? But I can't afford to stop working."
+            else:
+                return "I get headaches sometimes. Probably just from staring at screens all day. Everyone in design deals with it."
+        else:
+            return "Physically I'm okay. Just the usual screen fatigue."
+
+
+def handle_feelings_topic(name, mode, state, persona, prompt_lower):
+    """Generate responses about emotions and feelings."""
+    anxiety = state.get("anxiety", 0.5)
+    
+    if mode == "decompensating":
+        return "I don't... everything's just a lot right now. I can't really explain it. I'm just overwhelmed."
+    
+    if mode == "triggered" or mode == "guarded":
+        if "about" in prompt_lower:
+            return "I don't know. Fine, I guess?"
+        else:
+            return "I'm fine. Just tired."
+    
+    if mode == "trusting":
+        if name == "Jack":
+            if anxiety > 0.6:
+                return "Honestly? Anxious. Like there's this constant pressure I can't shake. Work, family expectations, feeling stuck... it all just builds up."
+            else:
+                return "Better than I have been, actually. Still stressed, but like... manageable stress?"
+        else:  # Maya
+            if anxiety > 0.6:
+                return "Overwhelmed, mostly. And scared that I'm not good enough for this. Everyone else seems to handle everything so much better than me."
+            else:
+                return "I'm doing okay. Some days are harder than others, but I'm managing."
+    
+    return "I'm alright. Just dealing with the usual stuff."
+
+
+def handle_family_topic(name, mode, state, persona):
+    """Generate responses about family relationships."""
+    if name == "Jack":
+        if mode == "triggered":
+            return "Can we talk about something else?"
+        elif mode == "trusting":
+            return "My dad and I mostly just coexist. He works a lot, I work a lot. My brother... that's complicated since he's also my boss. Mom moved to Arizona years ago."
+        else:
+            return "Family's fine. Nothing new there."
+    else:  # Maya
+        if mode == "triggered":
+            return "I don't really want to get into family stuff right now."
+        elif mode == "trusting":
+            return "My parents are supportive but they don't really understand creative work. My sister's a nurse practitioner and everyone's always comparing us. It's... yeah, it's a thing."
+        else:
+            return "Family's good. I talk to them pretty regularly."
+
+
+def get_mode_based_response(name, mode, state, persona):
+    """Generate generic response based on current emotional mode."""
+    resilience_hooks = persona.get("resilience_hooks", [])
+    scripts = persona.get("scripts", {})
+    
+    if mode == "decompensating":
+        return scripts.get("crisis", "I need to step away. This is too much right now.")
+    
+    if mode == "triggered":
+        return scripts.get("resistance", "I'm not really in the mood to talk about this.")
+    
+    if mode == "guarded":
+        return scripts.get("deflection", "It's not that deep. I'm just tired.")
+    
+    if mode == "trusting" and resilience_hooks:
+        return f"You know what? {resilience_hooks[0]}"
+    
+    if mode == "recovering":
+        return "I'm feeling a bit better actually. Still working through things, but... yeah, better."
+    
+    # Baseline
+    return "I'm doing okay. What did you want to talk about?"
+
+
+def determine_memory_tag(prompt, mode, state):
+    """Generate an emotional memory tag based on the interaction."""
+    prompt_lower = prompt.lower()
+    
+    if mode == "trusting":
+        if any(word in prompt_lower for word in ["understand", "hear you", "makes sense"]):
+            return "felt validated"
+        return "felt safe to open up"
+    
+    if mode == "triggered":
+        if any(word in prompt_lower for word in ["should", "need to", "why don't"]):
+            return "felt criticized"
+        return "felt defensive"
+    
+    if mode == "guarded":
+        return "felt cautious"
+    
+    if mode == "decompensating":
+        return "felt overwhelmed"
+    
+    return "shared thoughts"