Spaces:
Sleeping
Sleeping
| def normalize_emotional_state(persona): | |
| """Extract and normalize emotional state from the new persona structure.""" | |
| default = { | |
| "emotional_tension": 0.0, | |
| "relational_openness": 0.0, | |
| "narrative_fluidity": 0.0, | |
| "guilt": 0.0, | |
| "mode": "baseline" | |
| } | |
| return persona.get("emotional_state", default).copy() | |
| def apply_context_shift(persona, scenario): | |
| """Apply contextual scenario effects to persona's current emotional state.""" | |
| state = normalize_emotional_state(persona) | |
| effects = scenario.get("effects", {}) | |
| for key, change in effects.items(): | |
| if key in state and isinstance(state[key], (int, float)): | |
| current_value = state[key] | |
| new_value = current_value + change | |
| state[key] = max(0.0, min(1.0, round(new_value, 3))) | |
| persona["emotional_state"] = state | |
| return persona | |
| def get_current_mode(state): | |
| """Determine the client's current emotional mode based on emotional state values.""" | |
| tension = state.get("emotional_tension", 0.5) | |
| openness = state.get("relational_openness", 0.5) | |
| fluidity = state.get("narrative_fluidity", 0.5) | |
| if tension > 0.8: | |
| return "crisis" | |
| if tension > 0.6 and openness < 0.3: | |
| return "defensive" | |
| if fluidity < 0.4 and openness < 0.5: | |
| return "guarded" | |
| if openness > 0.6 and fluidity > 0.6: | |
| return "vulnerable" | |
| if tension < 0.4 and fluidity > 0.5: | |
| return "recovering" | |
| return state.get("mode", "baseline") | |
| def calculate_state_change(state, student_response): | |
| """Calculate how the student's response affects the client's emotional state.""" | |
| if hasattr(student_response, 'value'): | |
| student_response = student_response.value | |
| student_response = str(student_response) if student_response is not None else "" | |
| response_lower = student_response.lower() | |
| validating_words = ["understand", "sounds like", "seems", "feel", "must be", "makes sense"] | |
| open_questions = ["tell me more", "what's that like", "how", "what"] | |
| empathy_phrases = ["hard", "difficult", "challenging", "tough"] | |
| advice_words = ["should", "need to", "have to", "must", "why don't you"] | |
| minimizing = ["just", "simply", "easy", "only", "at least"] | |
| validation_score = sum(1 for word in validating_words if word in response_lower) | |
| open_q_score = sum(1 for phrase in open_questions if phrase in response_lower) | |
| empathy_score = sum(1 for phrase in empathy_phrases if phrase in response_lower) | |
| advice_score = sum(1 for word in advice_words if word in response_lower) | |
| minimizing_score = sum(1 for word in minimizing if word in response_lower) | |
| positive_impact = (validation_score * 0.05 + open_q_score * 0.04 + empathy_score * 0.03) | |
| negative_impact = (advice_score * 0.08 + minimizing_score * 0.06) | |
| changes = { | |
| "relational_openness": positive_impact * 0.8 - negative_impact * 0.5, | |
| "emotional_tension": negative_impact * 0.5 - positive_impact * 0.3, | |
| "narrative_fluidity": positive_impact * 0.4 - negative_impact * 0.2, | |
| "guilt": empathy_score * 0.05 if "guilt" in response_lower else 0.0 | |
| } | |
| word_count = len(student_response.split()) | |
| if word_count < 5: | |
| changes["relational_openness"] -= 0.05 | |
| elif word_count > 100: | |
| changes["emotional_tension"] += 0.05 | |
| return changes | |
| def apply_response_effects(state, student_response): | |
| """Apply the effects of the student's response to the client's emotional state.""" | |
| changes = calculate_state_change(state, student_response) | |
| for key, change in changes.items(): | |
| if key in state and isinstance(state[key], (int, float)): | |
| current_value = state[key] | |
| new_value = current_value + change | |
| state[key] = max(0.0, min(1.0, round(new_value, 3))) | |
| return state | |
| def generate_teaching_note(state, student_response, mode): | |
| """Generate teaching feedback based on the interaction.""" | |
| response_lower = student_response.lower() | |
| notes = [] | |
| if any(word in response_lower for word in ["should", "need to", "have to"]): | |
| notes.append("⚠️ Advice-giving detected. Consider asking open questions instead of giving directives.") | |
| if any(word in response_lower for word in ["just", "simply", "only"]): | |
| notes.append("⚠️ Potential minimizing language. Avoid words that might diminish the client's experience.") | |
| if response_lower.count("?") > 2: | |
| notes.append("⚠️ Multiple questions detected. Consider asking one question at a time to avoid overwhelming the client.") | |
| if len(student_response.split()) < 10: | |
| notes.append("💡 Very brief response. Consider adding validation or reflection before asking questions.") | |
| if any(phrase in response_lower for phrase in ["sounds like", "seems", "hear you"]): | |
| notes.append("✅ Good use of reflection and validation.") | |
| if "tell me more" in response_lower or "what's that like" in response_lower: | |
| notes.append("✅ Effective use of open-ended questions.") | |
| if mode == "defensive" and state.get("relational_openness", 0) < 0.4: | |
| notes.append("📊 Client is emotionally guarded. Consider using reflection or shared experience.") | |
| if mode == "vulnerable" and state.get("emotional_tension", 0) > 0.6: | |
| notes.append("📊 Client is opening up under emotional strain. Proceed with care.") | |
| if mode == "crisis": | |
| notes.append("🚨 Client may be emotionally overwhelmed. Consider grounding or referral.") | |
| if not notes: | |
| notes.append("✅ Solid therapeutic response. Continue building rapport.") | |
| return "\n".join(notes) |