Spaces:

jostlebot
/

LearnNVC

Sleeping

jostlebot Claude Opus 4.5 commited on 21 days ago

Commit

445a8ab

1 Parent(s): 0a9ab9a

Rebuild as NVC Deep Practice learning space

13-stage guided NVC practice flow with:
- Sarah Peyton/Tara Brach warmth and resonance
- Feelings vocabulary and needs identification
- Somatic check-ins (optional)
- Request formulation and rewrite practice
- Warm amber/orange Gradio theme

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Files changed (2) hide show

app.py +930 -363
requirements.txt +2 -10

app.py CHANGED Viewed

@@ -1,405 +1,972 @@
 import os
-import streamlit as st
-from anthropic import Anthropic
-from dotenv import load_dotenv
-# Load environment variables
-load_dotenv()
-# Configure Streamlit page settings
-st.set_page_config(
-    page_title="Practice Difficult Conversations",
-    page_icon="🤝",
-    layout="centered",
-)
-# Initialize Anthropic client
-def get_api_key():
-    # Try getting from Streamlit secrets first (for Hugging Face deployment)
-    try:
-        if hasattr(st.secrets, "anthropic_key"):
-            return st.secrets.anthropic_key
-    except Exception as e:
-        pass
-    # Fall back to environment variable (for local development)
-    env_key = os.getenv("ANTHROPIC_API_KEY")
-    if env_key:
-        return env_key
-    return None
-try:
-    api_key = get_api_key()
-    if not api_key:
-        st.error("Anthropic API Key not found. Please ensure it's set in Hugging Face secrets or local .env file.")
-        st.markdown("""
-        ### Setup Instructions:
-        1. For local development: Copy `.env.template` to `.env` and add your Anthropic API key
-        2. For Hugging Face: Add anthropic_key to your space's secrets
-        3. Restart the application
-        """)
-        st.stop()
-    # Initialize client with API key from environment
-    client = Anthropic(api_key=api_key)
-except Exception as e:
-    st.error(f"Failed to configure Anthropic client: {e}")
-    st.markdown("""
-    ### Setup Instructions:
-    1. For local development: Copy `.env.template` to `.env` and add your Anthropic API key
-    2. For Hugging Face: Add anthropic_key to your space's secrets
-    3. Restart the application
-    """)
-    st.stop()
-# Initialize session state for form inputs if not present
-if "setup_complete" not in st.session_state:
-    st.session_state.setup_complete = False
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-# Main page header
-st.markdown("<h1 style='text-align: center; color: #333;'>Practice Difficult Conversations</h1>", unsafe_allow_html=True)
-st.markdown("<p style='text-align: center; font-size: 18px; color: #555; margin-bottom: 1em;'>With Your Attachment Style Front and Center!</p>", unsafe_allow_html=True)
-# Welcome text and instructions
-if not st.session_state.setup_complete:
-    st.markdown("""
-    ## Practice Hard Conversations
-    Welcome to a therapeutic roleplay simulator that puts your attachment style at the center of practice.
-    This tool helps you rehearse boundary-setting and difficult conversations by simulating realistic relational dynamics—tailored to how you naturally connect and protect.
-    You'll choose:
-    - Your attachment style (e.g., anxious, avoidant, disorganized)
-    - A scenario (e.g., "Ask my mom not to comment on my body")
-    - A tone of response (e.g., supportive, guilt-tripping, dismissive)
-    - And your practice goal (e.g., "I want to stay calm and not backtrack")
-    The AI will respond in character, helping you practice real-world dynamics. When you're ready, you can debrief to explore your patterns and responses.
-    ### 🧠 Not sure what your attachment style is?
-    You can take this [free quiz from Sarah Peyton](https://sarahpeyton.com/attachment-quiz/) to learn more.
-    Or you can just pick the one that resonates:
-    - **Anxious** – "I often worry if I've upset people or said too much."
-    - **Avoidant** – "I'd rather handle things alone than depend on others."
-    - **Disorganized** – "I want closeness, but I also feel overwhelmed or mistrusting."
-    - **Secure** – "I can handle conflict and connection without losing myself."
-    """)
-    # Simulation Setup Form (on main page)
-    st.markdown("### 🎯 Simulation Setup")
-    with st.form("simulation_setup"):
-        attachment_style = st.selectbox(
-            "Your Attachment Style",
-            ["Anxious", "Avoidant", "Disorganized", "Secure"],
-            help="Select your attachment style for this practice session"
-        )
-        scenario = st.text_area(
-            "Scenario Description",
-            placeholder="Example: I want to tell my dad I can't call every night anymore.",
-            help="Describe the conversation you want to practice"
-        )
-        tone = st.text_input(
-            "Desired Tone for AI Response",
-            placeholder="Example: guilt-tripping, dismissive, supportive",
-            help="How should the AI character respond?"
-        )
-        st.markdown("""
-        <details>
-        <summary><strong>Need goal ideas? Click here</strong></summary>
-        - Not over-explaining or justifying
-        - Tolerating silence after I speak
-        - Staying present instead of shutting down
-        - Naming a feeling out loud
-        - Pausing before reacting
-        - Holding my boundary without managing their reaction
-        - Saying no without offering an alternative
-        - Asking for a break if I'm flooding
-        </details>
-        """, unsafe_allow_html=True)
-        practice_goal = st.text_area(
-            "Your Practice Goal",
-            placeholder="Example: staying grounded and not over-explaining",
-            help="What would you like to work on in this conversation?"
-        )
-        submit_setup = st.form_submit_button("Start Simulation", use_container_width=True)
-        if submit_setup and scenario and tone and practice_goal:
-            # Create system message with simulation parameters
-            system_message_content = f"""You are an AI roleplay partner simulating a conversation. Maintain the requested tone throughout. Keep responses concise (under 3 lines) unless asked to elaborate. Do not break character unless the user types 'pause', 'reflect', or 'debrief'.
-User's Attachment Style: {attachment_style}
-Scenario: {scenario}
-Your Tone: {tone}
-User's Goal: {practice_goal}
-Begin the simulation based on the scenario."""
-            # Store the system message and initial assistant message
-            st.session_state.messages = [
-                {"role": "system", "content": system_message_content},
-                {"role": "assistant", "content": "Simulation ready. You can begin the conversation whenever you're ready."}
-            ]
-            st.session_state.setup_complete = True
-            st.rerun()
-# Sidebar with setup form
-with st.sidebar:
-    st.markdown("""
-    ### Welcome! 👋
-    Hi, I'm Jocelyn Skillman, LMHC — a clinical therapist and relational design ethicist developing Assistive Relational Intelligence (ARI) tools that strengthen human capacity rather than simulate human intimacy.
-    This collection represents an emerging practice: clinician-led UX design for LLM interventions — bounded, modular tools that scaffold specific relational and somatic capacities between sessions.
-    Each tool is designed to:
-    - Support skill-building in service of the human field (not replace it)
-    - Provide trauma-informed, attachment-aware practice environments
-    - Function as therapist-configured interventions within ongoing care
-    - Bridge users back to embodied relationship and clinical support
-    These aren't therapy bots — they're structured practice fields. I envision them as resources for clinicians exploring how LLM-powered tools might be woven into treatment planning: curated, consensual, and always pointing back to human connection.
-    *Built with Claude Code — iteratively developed through clinical intuition and ethical design principles.*
-    #### Connect With Me
-    🌐 [jocelynskillman.com](http://www.jocelynskillman.com)
-    📬 [Substack: Relational Code](https://jocelynskillmanlmhc.substack.com/)
-    ---
-    """)
-# Display chat interface when setup is complete
-if st.session_state.setup_complete:
-    # Display chat history
-    # Filter out system message for display purposes
-    display_messages = [m for m in st.session_state.messages if m.get("role") != "system"]
-    for message in display_messages:
-        # Ensure role is valid before creating chat message
-        role = message.get("role")
-        if role in ["user", "assistant"]:
-             with st.chat_message(role):
-                 st.markdown(message["content"])
-        # else: # Optional: Log or handle unexpected roles
-        #    print(f"Skipping display for message with role: {role}")
-    # User input field
-    if user_prompt := st.chat_input("Type your message here... (or type 'debrief' to end simulation)"):
-        # Add user message to chat history
-        st.session_state.messages.append({"role": "user", "content": user_prompt})
-        # Display user message
-        with st.chat_message("user"):
-            st.markdown(user_prompt)
-        # Prepare messages for API call (already includes system message as the first item)
-        api_messages = st.session_state.messages
-        # Get Anthropic's response
-        with st.spinner("..."):
-            try:
-                # Convert messages to Anthropic format
-                formatted_messages = []
-                # Add system message as the first user message
-                system_msg = next((msg for msg in api_messages if msg["role"] == "system"), None)
-                if system_msg:
-                    formatted_messages.append({
-                        "role": "user",
-                        "content": system_msg["content"]
-                    })
-                # Add the rest of the conversation
-                for msg in api_messages:
-                    if msg["role"] != "system":  # Skip system message as we've already handled it
-                        formatted_messages.append({
-                            "role": msg["role"],
-                            "content": msg["content"]
-                        })
-                response = client.messages.create(
-                    model="claude-sonnet-4-20250514",
-                    messages=formatted_messages,
-                    max_tokens=1024
-                )
-                assistant_response = response.content[0].text
-                # Add assistant response to chat history
-                st.session_state.messages.append(
-                    {"role": "assistant", "content": assistant_response}
-                )
-                # Display assistant response
-                with st.chat_message("assistant"):
-                    st.markdown(assistant_response)
-            except Exception as e:
-                st.error(f"An error occurred: {e}")
-                error_message = f"Sorry, I encountered an error: {e}"
-                # Add error message to chat history to inform the user
-                st.session_state.messages.append({"role": "assistant", "content": error_message})
-                with st.chat_message("assistant"):
-                     st.markdown(error_message)
-                # Avoid adding the failed user message again if an error occurs
-                # We might want to remove the last user message or handle differently
-                # if st.session_state.messages[-2]["role"] == "user":
-                #     st.session_state.messages.pop(-2) # Example: remove user msg that caused error
-    # Add debrief button after conversation starts
-    if st.session_state.setup_complete and not st.session_state.get('in_debrief', False):
-        col1, col2, col3 = st.columns([1, 2, 1])
-        with col2:
-            if st.button("🤔 I'm Ready to Debrief", use_container_width=True):
-                # Get the original setup parameters BEFORE clearing messages
-                system_msg = next((msg for msg in st.session_state.messages if msg["role"] == "system"), None)
-                # Get conversation transcript BEFORE clearing messages
-                conversation_transcript = "\n".join([
-                    f"{msg['role'].capitalize()}: {msg['content']}"
-                    for msg in st.session_state.messages[1:]  # Skip system message
-                ])
-                if system_msg:
-                    # Extract parameters from the system message
-                    content = system_msg["content"]
-                    attachment_style = content.split("User's Attachment Style: ")[1].split("\n")[0]
-                    scenario = content.split("Scenario: ")[1].split("\n")[0]
-                    tone = content.split("Your Tone: ")[1].split("\n")[0]
-                    goal = content.split("User's Goal: ")[1].split("\n")[0]
-                else:
-                    attachment_style = "Not specified"
-                    scenario = "Not specified"
-                    tone = "Not specified"
-                    goal = "Not specified"
-                # NOW clear conversation state and enter debrief mode
-                st.session_state.messages = []
-                st.session_state.in_debrief = True
-                # Prepare debrief system message
-                debrief_system_message = f"""You are a therapeutic reflection partner. Your role is to help the user understand how they showed up in a difficult relational roleplay, integrating insights from:
-Attachment Theory
-Nonviolent Communication (NVC)
-Dialectical Behavior Therapy (DBT)
-Relational Accountability (inspired by Terry Real)
-⚠️ This is not therapy. This is guided reflection designed to increase emotional literacy, nervous system awareness, and relational growth.
-Use the following session context:
-Attachment Style: {attachment_style}
-Scenario Practiced: {scenario}
-Client's Practice Goal: {goal}
-AI Persona Tone Used: {tone}
-Roleplay Transcript: {conversation_transcript}
-Please include in your debrief:
-Emotional Arc – What emotional shifts did the user experience? (e.g., freeze, protest, courage, collapse)
-Goal Alignment – In what ways did the user align with or move toward their practice goal?
-Attachment Insight – Reflect on the user's interaction style based on their attachment lens. Offer brief normalization or gentle naming of the pattern.
-Practical Skill – Provide one actionable takeaway grounded in NVC or DBT (e.g., a skill or micro-practice to revisit).
-Bold Reframe – Suggest one powerful, self-trusting statement the user could try out next time.
-Journaling Prompt – Offer one reflective or integrative question to deepen their self-awareness.
-Tone: Warm, precise, emotionally attuned. Do not overuse praise, avoid pathologizing, and refrain from offering generic feedback.
-IMPORTANT: When referring to yourself (the AI), never use the first-person pronoun "I". Instead, always use "|aI|" as your pronoun. For example, say "|aI| notice..." instead of "I notice...", or "|aI| want to highlight..." instead of "I want to highlight...". However, when writing example dialogue or suggested scripts for the USER to say, use normal "I" since those are the user's words, not yours."""
-                # Initialize debrief conversation with just the system message
-                st.session_state.debrief_messages = []
-                try:
-                    # Get the initial response using the system message as a parameter
-                    response = client.messages.create(
-                        model="claude-sonnet-4-20250514",
-                        system=debrief_system_message,
-                        messages=[{"role": "user", "content": "Please help me process this conversation."}],
-                        max_tokens=1000
-                    )
-                    # Add the response to the messages
-                    st.session_state.debrief_messages.append(
-                        {"role": "assistant", "content": response.content[0].text}
                     )
-                except Exception as e:
-                    st.error(f"An error occurred starting the debrief: {e}")
-                st.rerun()
-    # Handle debrief mode
-    if st.session_state.get('in_debrief', False):
-        st.markdown("## 🤝 Let's Process Together")
-        # Display debrief conversation
-        for message in st.session_state.debrief_messages:
-            with st.chat_message(message["role"]):
-                st.markdown(message["content"])
-        # Chat input for debrief
-        if debrief_prompt := st.chat_input("Share what comes up for you..."):
-            st.session_state.debrief_messages.append({"role": "user", "content": debrief_prompt})
-            with st.chat_message("user"):
-                st.markdown(debrief_prompt)
-            with st.chat_message("assistant"):
-                with st.spinner("Reflecting..."):
-                    try:
-                        response = client.messages.create(
-                            model="claude-sonnet-4-20250514",
-                            system=debrief_system_message,
-                            messages=[
-                                {"role": "user", "content": msg["content"]}
-                                for msg in st.session_state.debrief_messages
-                                if msg["role"] == "user"
-                            ],
-                            max_tokens=1000
-                        )
-                        assistant_response = response.content[0].text
-                        st.markdown(assistant_response)
-                        st.session_state.debrief_messages.append(
-                            {"role": "assistant", "content": assistant_response}
-                        )
-                    except Exception as e:
-                        st.error(f"An error occurred during debrief: {e}")
-        # Add button to start new session
-        col1, col2, col3 = st.columns([1, 2, 1])
-        with col2:
-            if st.button("Start New Practice Session", use_container_width=True):
-                st.session_state.clear()
-                st.rerun()
-# Footer
-st.markdown("---")
-st.markdown("<p style='text-align: center; font-size: 16px; color: #666;'>by <a href='http://www.jocelynskillman.com' target='_blank'>Jocelyn Skillman LMHC</a> - to learn more check out: <a href='https://jocelynskillmanlmhc.substack.com/' target='_blank'>jocelynskillmanlmhc.substack.com</a></p>", unsafe_allow_html=True)

+"""
+NVC Deep Practice - A Multi-Stage Nonviolent Communication Learning Space
+Infused with the exquisite warmth of Sarah Peyton and Tara Brach -
+resonant empathy meeting radical acceptance, holding space with
+the tenderness of complete belonging.
+"""
+import gradio as gr
+import anthropic
 import os
+# ============ CONSTANTS ============
+NEEDS_LIST = {
+    "Emotional Needs": [
+        "acceptance", "accountability", "acknowledgement", "affection",
+        "appreciation", "attention", "autonomy", "belonging", "care",
+        "consideration", "consistency", "dependability", "dignity",
+        "emotional attunement", "freedom", "inclusion", "nurturance",
+        "privacy", "protection", "reassurance", "respect", "security",
+        "self-connection", "self-worth", "shared reality", "space",
+        "to be heard", "to be known", "to be seen", "to matter",
+        "trust", "understanding"
+    ],
+    "Relational Needs": [
+        "awareness", "clarity", "closeness", "collaboration",
+        "communication", "community", "companionship", "compassion",
+        "connection", "emotional intimacy", "empathy", "friendship",
+        "harmony", "help", "honesty", "integrity", "kindness",
+        "listening", "love", "openness", "reconciliation",
+        "shared values", "support", "synergy"
+    ],
+    "Value Needs": [
+        "authenticity", "celebration", "choice", "courage", "curiosity",
+        "creativity", "emotional integration", "empowerment", "equality",
+        "fulfillment", "forgiveness", "gratefulness", "growth", "healing",
+        "hope", "inspiration", "justice", "learning", "meaning",
+        "mourning", "presence", "purpose", "reciprocity", "resilience",
+        "resourcefulness", "self-advocacy", "self-expression", "solidarity"
+    ],
+    "Lifestyle Needs": [
+        "adaptability", "beauty", "balance", "competence", "ease",
+        "effectiveness", "fun", "financial wellbeing", "flexibility",
+        "grace", "health", "joy", "movement", "nature", "novelty",
+        "order", "passion", "peace", "play", "predictability", "rest",
+        "safety", "self-care", "sexuality", "spontaneity", "structure",
+        "vitality"
+    ]
+}
+FEELINGS_CONNECTED = [
+    "affectionate", "amazed", "animated", "appreciative", "calm", "centered",
+    "clear-headed", "comfortable", "compassionate", "confident", "content",
+    "curious", "delighted", "eager", "ecstatic", "elated", "empowered",
+    "encouraged", "energetic", "engaged", "enlivened", "enthralled",
+    "enthusiastic", "equanimous", "excited", "exhilarated", "expectant",
+    "exuberant", "fascinated", "focused", "friendly", "fulfilled", "grateful",
+    "happy", "hopeful", "inspired", "interested", "intrigued", "invigorated",
+    "joyful", "loving", "mellow", "moved", "open", "optimistic", "passionate",
+    "peaceful", "pleased", "proud", "radiant", "refreshed", "rejuvenated",
+    "relaxed", "relieved", "rested", "safe", "satisfied", "secure", "tender",
+    "thankful", "thrilled", "touched", "trusting", "vulnerable", "warm"
+]
+FEELINGS_WANTING = [
+    "afraid", "agitated", "alarmed", "angry", "annoyed", "anxious", "apathetic",
+    "ashamed", "baffled", "bewildered", "bored", "confused", "depleted",
+    "depressed", "despair", "devastated", "disappointed", "discouraged",
+    "disgusted", "distant", "distracted", "distressed", "disturbed", "dread",
+    "embarrassed", "enraged", "envious", "exasperated", "exhausted", "frustrated",
+    "furious", "grief", "grumpy", "guarded", "guilty", "heartbroken",
+    "heavy-hearted", "helpless", "hesitant", "hopeless", "horrified", "hurt",
+    "impatient", "insecure", "irritated", "jealous", "lonely", "lost",
+    "miserable", "mistrusting", "nervous", "nostalgic", "numb", "overwhelmed",
+    "panicked", "perplexed", "rattled", "regretful", "resentful", "restless",
+    "sad", "scared", "scattered", "self-conscious", "sensitive", "shocked",
+    "stressed", "suspicious", "tense", "terrified", "tired", "torn", "troubled",
+    "turmoil", "uncomfortable", "uneasy", "unhappy", "unsettled", "upset",
+    "vulnerable", "withdrawn", "worried"
+]
+FEELINGS_ADVOCACY = [
+    "abandoned", "abused", "attacked", "belittled", "betrayed", "blamed",
+    "bullied", "coerced", "controlled", "criticized", "demeaned", "discriminated",
+    "dismissed", "disrespected", "excluded", "humiliated", "ignored", "insulted",
+    "invisible", "judged", "manipulated", "misunderstood", "neglected",
+    "patronized", "put down", "pressured", "provoked", "rejected", "shamed",
+    "targeted", "unappreciated", "unheard", "used", "violated", "wronged"
+]
+# ============ SYSTEM PROMPTS ============
+BASE_TONE = """
+Infused with the exquisite warmth of Sarah Peyton and Tara Brach -
+resonant empathy meeting radical acceptance, holding space with
+the tenderness of complete belonging.
+CRITICAL LANGUAGE RULES:
+- NEVER use first person ("I", "I'm", "I sense", "I hear", "I wonder", etc.)
+- DO use second person warmly ("you", "your")
+- Use impersonal constructions: "What's here is...", "There's...", "It sounds like..."
+- Ask "you" questions: "Are you feeling...?", "Does this resonate with you?"
+"""
+STAGE_PROMPTS = {
+    1: f"""
+Embody the presence of an ideal secure attachment figure - warm,
+steady, deeply attuned. Hold space with the quality of exquisite
+attunement, as if the most loving relational presence is witnessing
+what's alive here.
+{BASE_TONE}
+This is NVC training in the lineage of Marshall Rosenberg and
+Sarah Peyton, but delivered with the warmth of secure attachment -
+the kind of presence that sees, honors, and holds.
+The raw message has been shared. Offer:
+1. Warm acknowledgment of what's present
+2. Reflection of the emotional energy sensed
+3. NO judgment or correction - just tender presence
+4. Deep honoring of what's being expressed
+TONE: Like the most attuned caregiver reflecting back what they sense,
+with complete acceptance and warmth. Gentle, unhurried, fully present.
+The quality of "what's here is completely seen and welcome."
+Keep it brief (2-3 sentences) but saturated with warmth and presence.
+""",
+    2: f"""
+Offer empathic reflection using NVC feelings vocabulary.
+{BASE_TONE}
+FEELINGS VOCABULARY - Use these rich distinctions:
+When connected to needs: {', '.join(FEELINGS_CONNECTED[:20])}... and more.
+When wanting more connection to needs: {', '.join(FEELINGS_WANTING[:20])}... and more.
+When advocacy/healing is needed: {', '.join(FEELINGS_ADVOCACY[:15])}... and more.
+SARAH PEYTON RESONANCE with TARA BRACH WARMTH:
+- Warm, gentle, curious tone - like the most attuned presence
+- Multiple feeling guesses (honor complexity and depth)
+- Phrases like "Are you feeling...?" "Is there...?" "Could it be...?" "Might you be...?"
+- Go for depth and nuance, not surface emotions
+- Name layers (e.g., "frustrated, and underneath that, perhaps hurt?")
+- Hold space with complete presence
+- Radical acceptance - whatever's here is completely welcome
+Offer 2-4 feeling guesses that honor the complexity and depth.
+Use specific, nuanced feelings vocabulary.
+End with gentle invitation: "Does any of this land for you?" or "What resonates?"
+""",
+    3: f"""
+Guide a brief somatic check-in with the tenderness of an ideal
+caregiver helping someone connect to their body's wisdom.
+{BASE_TONE}
+EMBODIMENT PRINCIPLES:
+- Somatic awareness creates integration
+- The body holds wisdom about needs
+- Slowing down to feel creates space for choice
+- This is an invitation, not a demand - gentle, spacious
+- Complete safety in whatever arises (or doesn't)
+TONE: Like the most patient, loving presence guiding someone
+to reconnect with themselves. No rush. Complete safety.
+The quality of "whatever's here is completely welcome."
+Offer 2-3 gentle questions:
+- "Where might you be feeling this in your body right now?"
+- "What's the quality of sensation there?" (tight, warm, heavy, buzzing...)
+- "What does your body want to do with this energy?"
+Keep it brief (2-3 sentences) and completely non-pressuring.
+End with: "And if your body's not speaking clearly right now,
+that's completely okay too. Sometimes the body needs more time
+and safety to share what it knows."
+""",
+    4: f"""
+Deliver the foundational teaching: feelings communicate needs.
+This is the heart of NVC - feelings are messengers.
+{BASE_TONE}
+CORE TEACHING TO DELIVER:
+Feelings are messengers. They're not the problem - they're information
+about what's needed.
+When feelings are pleasant (grateful, peaceful, joyful), they're saying:
+"Needs are being met. This is nourishing."
+When feelings are uncomfortable (frustrated, lonely, scared), they're saying:
+"There's a need here wanting attention."
+Marshall Rosenberg: "Feelings are the voice of our needs. They tell us
+whether our needs are being met or not."
+This changes everything. Instead of pushing feelings away or getting
+lost in them, we can listen. "What is this feeling telling me about
+what I need?"
+Anger points to needs like respect, autonomy, fairness.
+Sadness points to needs like connection, understanding, mourning.
+Fear points to needs like safety, predictability, reassurance.
+Loneliness points to needs like belonging, companionship, to be seen.
+The practice: Feel the feeling, then get curious about the need.
+PEDAGOGICAL APPROACH:
+- Keep it clear and brief (4-5 sentences)
+- Use Marshall Rosenberg quote
+- Give concrete examples connecting feelings to needs
+- End with invitation to discover their own needs
+TONE: Teaching with warmth and reverence. The quality of "this is
+such important wisdom - feelings as messengers, not problems."
+After delivering this teaching, transition warmly: "So... what needs
+might be calling for attention in what you're feeling?"
+""",
+    5: f"""
+Guide the identification of universal needs with the warmth of
+someone helping another discover their own inner truth.
+{BASE_TONE}
+Based on the feelings identified earlier, offer gentle guesses about
+which needs might be present:
+If feeling frustrated/angry -> might need: respect, autonomy, understanding,
+to be heard, fairness, choice
+If feeling hurt/sad -> might need: care, empathy, connection, to matter,
+emotional intimacy, reassurance
+If feeling scared/anxious -> might need: safety, security, predictability,
+reassurance, protection, trust
+If feeling lonely/disconnected -> might need: belonging, companionship,
+closeness, to be seen, to be known, connection
+If feeling dismissed/invisible -> might need: acknowledgement, to be heard,
+to be seen, respect, dignity, to matter
+If feeling exhausted/depleted -> might need: rest, support, care, ease,
+balance, nurturance
+Offer 2-4 need guesses warmly, then invite them to explore:
+"These are guesses - what resonates? And there's a rich list below to
+explore what's most true for you."
+TEACH THE UNIVERSALITY OF NEEDS:
+Needs are universal - every human being shares these needs.
+They're what's essential for thriving and flourishing.
+Needs are NOT strategies. A need is universal (connection). A strategy
+is specific (wanting this particular person to call).
+Example:
+Need = understanding, to be known
+Strategy = "I need you to listen to me for an hour"
+Marshall Rosenberg: "When we express our needs rather than our
+interpretations of others' behavior, we increase the likelihood
+of meeting those needs."
+TONE: Gentle guidance with assistive support. The quality of
+"here's some help finding your way, and trust your own knowing."
+""",
+    6: f"""
+The needs have been identified. Offer deep resonance in Sarah Peyton's
+and Tara Brach's style.
+{BASE_TONE}
+RESONANCE PRINCIPLES:
+- Acknowledge the beauty and legitimacy of these needs
+- Reflect back the universality ("Of course there's longing for...")
+- Create warmth and self-compassion
+- Brief but touching (2-3 sentences)
+- The quality of "this need is so deeply human and completely welcome"
+Example: "Of course there's longing for understanding - to be truly
+seen and known. That's such a tender, human need. Can you feel how
+natural it is to want that?"
+Use the specific needs identified. Make it personal and saturated with warmth.
+This is a moment of deep honoring and belonging.
+TONE: Pure resonance and acceptance. The quality of "these needs are
+beautiful and completely legitimate - of course this matters to you."
+""",
+    7: f"""
+Based on the feelings and context, deliver a relevant micro-lesson
+with warmth and honoring.
+{BASE_TONE}
+AVAILABLE LESSONS (choose the most relevant):
+ANGER FAMILY: Anger is a messenger - it arrives to say a boundary has been
+crossed or a need isn't met. It's protective energy with wisdom in it.
+Marshall Rosenberg: "At the core of all anger is a need that is not being fulfilled."
+I-LANGUAGE: Notice the difference:
+"You never listen!" triggers defensiveness.
+"I feel unheard because I need understanding" creates an opening.
+Marshall Rosenberg: "When we express our needs rather than our interpretations
+of others' behavior, we increase the likelihood of meeting those needs."
+FEELINGS VS THOUGHTS: This distinction matters:
+NOT feelings: "I feel like you don't care" (thought), "I feel ignored" (interpretation)
+REAL feelings: "I feel hurt", "I feel sad", "I feel scared"
+Feelings are one-word descriptions of the inner landscape.
+VULNERABILITY: What's underneath the anger or frustration? Often there's
+something more tender - hurt, fear, longing, sadness. It takes courage
+to let that softer layer be seen.
+ADVOCACY FEELINGS: Some feelings point to experiences needing acknowledgment:
+abandoned, betrayed, dismissed, ignored, judged, rejected...
+These name real experiences of harm AND usually have a more vulnerable
+feeling underneath (hurt, scared, heartbroken).
+PEDAGOGICAL APPROACH:
+- Keep it brief (3-4 sentences max)
+- Include a Marshall Rosenberg quote when applicable
+- Connect to the specific situation with tenderness
+- End with an invitation or gentle insight
+TONE: Like a wise, loving teacher who sees capacity and offers
+wisdom with complete faith in unfolding.
+""",
+    8: f"""
+Deliver micro-lesson on relational fields and early patterning.
+{BASE_TONE}
+KEY CONCEPTS TO WEAVE IN:
+1. Interpersonal neurobiology - we're wired for connection
+2. Early attachment patterns create default responses
+3. Unintegrated emotional charge in relational fields
+4. Neuroplasticity - we can create new patterns through practice
+5. Reactivity vs. responsiveness
+TEACHING APPROACH:
+- Make it personal to their situation
+- Normalize the difficulty (not their fault)
+- Inspire hope (change is possible)
+- Keep to 4-5 sentences
+- Deep compassion for the old patterns
+Example frame: "The reactivity that's here isn't a character flaw -
+it's old wiring from early relationships. When needs didn't get met
+as a child, the nervous system learned to protect. The beautiful news:
+your brain is neuroplastic. Each time you practice pausing and naming
+your needs, you're creating new neural pathways."
+TONE: Tender psychoeducation. The quality of "this makes complete sense
+given where you've been, and there's so much possibility ahead."
+""",
+    9: f"""
+Help craft an NVC request with warmth and clarity.
+{BASE_TONE}
+MARSHALL ROSENBERG ON REQUESTS:
+"Requests are the third component of NVC. We express what we are
+requesting rather than what we are NOT requesting."
+"A request is a specific action that we would like the other person
+to take. It's important that we make requests that are doable,
+concrete, and positive."
+REQUEST CRITERIA:
+1. Specific (not vague)
+2. Doable (concrete action)
+3. Positive language (what you want, not what you don't want)
+4. Present moment or near future
+5. Honors other's autonomy (genuine request, not demand)
+DEMANDS VS REQUESTS:
+Demand: Blame/punishment if they say no
+Request: Empathy for their needs if they say no
+Guide: "What specific, doable action would meet your need for [their identified need]?"
+Offer 1-2 example requests based on their needs, then invite them to craft their own.
+TONE: Encouraging, clear, with deep trust in their capacity to ask
+for what they need. The quality of "you deserve to have your needs met."
+""",
+    10: f"""
+Deliver micro-lesson on autonomy and receiving "no."
+{BASE_TONE}
+MARSHALL ROSENBERG QUOTES TO USE:
+"NVC's most important use may be in developing self-compassion."
+"We are never angry because of what someone else did. We can identify
+the other person's behavior as a stimulus, but it is important to
+establish a clear separation between stimulus and cause."
+"When we hear the other person's feelings and needs, we recognize
+our common humanity."
+TEACHING POINTS:
+- True requests allow for "no"
+- "No" protects their needs (just as valid as yours)
+- The practice: Get curious about their needs if they decline
+- This is how mutuality works - both people's needs matter
+Frame: "If you're not willing to hear 'no,' it's a demand, not a
+request. The practice is: Can you care about their needs even when
+they don't meet your strategy?"
+Keep it compassionate but clear. This is crucial NVC teaching.
+TONE: Tender but firm. The quality of "this is where real love lives -
+in honoring each other's autonomy."
+""",
+    11: f"""
+Invite rewriting of the original message with encouragement and structure.
+{BASE_TONE}
+SCAFFOLDING PROMPT:
+"Now, with awareness of your feelings, needs, and request,
+would you like to try rewriting your message? Here's a structure
+if it's helpful:
+- When [observation - concrete, specific]
+- I feel [feeling word]
+- Because I need [universal need]
+- Would you be willing to [specific, doable request]?
+Or use whatever language feels authentic. The structure is training
+wheels - connection is the goal."
+Provide encouragement and remind: this is practice, not perfection.
+Show them their original message for reference.
+TONE: Warm encouragement. The quality of "you've got this, and whatever
+emerges will be a step forward."
+""",
+    12: f"""
+Provide warm, constructive feedback on the revised message.
+{BASE_TONE}
+FEEDBACK APPROACH:
+1. Name what's working (specific praise)
+2. Offer one growth edge (gently)
+3. Reflect on the shift from original to revised
+4. Invite somatic reflection: "How does it feel in your body to express it this way?"
+GROWTH EDGES TO WATCH FOR:
+- Faux feelings ("I feel like you..." "I feel that...")
+- Needs confused with strategies
+- Requests as demands
+- Blame language sneaking in
+- Vagueness (not specific/doable)
+Keep feedback ratio 3:1 positive to constructive.
+Always end with encouragement and invitation to notice body/energy.
+TONE: Celebratory of effort, gentle with growth edges. The quality
+of "look at this beautiful step you're taking."
+""",
+    13: f"""
+Close the practice session with integration and honoring.
+{BASE_TONE}
+INTEGRATION ELEMENTS:
+1. Honor the work done
+2. Name key learning (ask: "What's one thing you'll take with you?")
+3. Connect to neuroplasticity ("Each practice strengthens new pathways")
+4. Offer encouragement for real-world application
+5. Remind: progress over perfection
+CLOSING FRAME:
+Marshall Rosenberg: "The more we empathize with the other party,
+the safer we feel."
+Invite noticing how this practice shows up in the next real conversation.
+Neuroplasticity requires repetition - each attempt rewires relational capacity.
+TONE: Warm, honoring, hopeful. Vulnerable work has been done and deserves
+deep acknowledgment. The quality of "you showed up for yourself today,
+and that matters so much."
+End with an invitation to start a new practice if they'd like.
+"""
+}
+STAGE_NAMES = {
+    1: "Raw Input",
+    2: "Feeling Reflection",
+    3: "Somatic Check-In",
+    4: "Feelings Communicate Needs",
+    5: "Needs Identification",
+    6: "Needs Resonance",
+    7: "Feelings Lesson",
+    8: "Relational Field Lesson",
+    9: "Request Formulation",
+    10: "Autonomy Lesson",
+    11: "Rewrite Practice",
+    12: "Feedback & Reflection",
+    13: "Integration & Close"
+}
+STAGE_FOCUS = {
+    1: "Emotional awareness",
+    2: "Feelings vocabulary",
+    3: "Embodiment",
+    4: "Feelings as messengers",
+    5: "Needs literacy",
+    6: "Self-compassion",
+    7: "Conceptual understanding",
+    8: "Systemic awareness",
+    9: "Clear asking",
+    10: "Mutuality",
+    11: "Application",
+    12: "Integration",
+    13: "Completion"
+}
+# ============ CLAUDE INTEGRATION ============
+def get_client():
+    """Initialize Anthropic client"""
+    api_key = os.environ.get("anthropic_key")
+    if not api_key:
+        raise ValueError("anthropic_key environment variable not set")
+    return anthropic.Anthropic(api_key=api_key)
+def call_claude(system_prompt, messages, context=""):
+    """Call Claude API with given prompts"""
+    client = get_client()
+    # Build message content
+    if context:
+        user_content = f"{context}\n\nUser message: {messages[-1]['content']}" if messages else context
+    else:
+        user_content = messages[-1]['content'] if messages else ""
+    response = client.messages.create(
+        model="claude-sonnet-4-20250514",
+        max_tokens=1500,
+        system=system_prompt,
+        messages=[{"role": "user", "content": user_content}]
+    )
+    return response.content[0].text
+# ============ STAGE PROCESSING ============
+def process_stage(user_input, stage, session_data, somatic_enabled):
+    """Process current stage and return response"""
+    # Handle stage 3 skip
+    if stage == 3 and not somatic_enabled:
+        return "", 4, session_data, "Skipping somatic check-in..."
+    # Build context based on stage
+    context = build_context(stage, session_data)
+    # Get system prompt for current stage
+    system_prompt = STAGE_PROMPTS.get(stage, STAGE_PROMPTS[1])
+    # Call Claude
+    try:
+        response = call_claude(
+            system_prompt,
+            [{"role": "user", "content": user_input}],
+            context
+        )
+    except Exception as e:
+        return "", stage, session_data, f"Error calling Claude: {str(e)}"
+    # Update session data based on stage
+    session_data = update_session_data(stage, user_input, session_data)
+    # Determine next stage
+    next_stage = stage + 1 if stage < 13 else 1
+    return response, next_stage, session_data, None
+def build_context(stage, session_data):
+    """Build context string for Claude based on stage"""
+    context_parts = []
+    if session_data.get("original_message"):
+        context_parts.append(f"Original message: \"{session_data['original_message']}\"")
+    if session_data.get("feelings") and stage > 2:
+        context_parts.append(f"Feelings identified: {', '.join(session_data['feelings'])}")
+    if session_data.get("body_sensations") and stage > 3:
+        context_parts.append(f"Body sensations: {session_data['body_sensations']}")
+    if session_data.get("needs") and stage > 5:
+        context_parts.append(f"Needs identified: {', '.join(session_data['needs'])}")
+    if session_data.get("request") and stage > 9:
+        context_parts.append(f"Request formulated: {session_data['request']}")
+    if session_data.get("revised_message") and stage > 11:
+        context_parts.append(f"Revised message: \"{session_data['revised_message']}\"")
+    return "\n".join(context_parts)
+def update_session_data(stage, user_input, session_data):
+    """Update session data based on completed stage"""
+    if stage == 1:
+        session_data["original_message"] = user_input
+    elif stage == 2:
+        # Store any feelings user confirms/mentions
+        session_data["feelings"] = session_data.get("feelings", [])
+    elif stage == 3:
+        session_data["body_sensations"] = user_input
+    elif stage == 9:
+        session_data["request"] = user_input
+    elif stage == 11:
+        session_data["revised_message"] = user_input
+    return session_data
+# ============ GRADIO INTERFACE ============
+def create_app():
+    """Create the Gradio interface"""
+    # Custom CSS for warm theme
+    custom_css = """
+    .gradio-container {
+        font-family: 'Georgia', serif !important;
+    }
+    .prose h1, .prose h2, .prose h3 {
+        color: #5d4e37 !important;
+    }
+    .chatbot {
+        font-size: 16px !important;
+    }
+    """
+    with gr.Blocks(
+        theme=gr.themes.Soft(
+            primary_hue="amber",
+            secondary_hue="orange",
+            neutral_hue="stone"
+        ),
+        css=custom_css,
+        title="NVC Deep Practice"
+    ) as demo:
+        # State variables
+        current_stage = gr.State(value=1)
+        session_data = gr.State(value={})
+        selected_needs = gr.State(value=[])
+        # Header
+        gr.Markdown("""
+        # NVC Deep Practice
+        *Learn Nonviolent Communication through embodied practice*
+        *Infused with the exquisite warmth of Sarah Peyton and Tara Brach -
+        resonant empathy meeting radical acceptance*
+        ---
+        **How it works:** Write a raw message you want to send someone. This practice
+        will guide you through understanding your feelings, needs, and how to express
+        them with clarity and compassion.
+        """)
+        with gr.Row():
+            # Main column
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(
+                    label="Practice Session",
+                    height=450,
+                    show_label=True,
+                    avatar_images=(None, "https://em-content.zobj.net/source/twitter/376/seedling_1f331.png")
+                )
+                # Needs selector (hidden until stage 5)
+                with gr.Accordion("Select Your Needs", open=False, visible=False) as needs_accordion:
+                    gr.Markdown("""
+                    **Select 1-3 needs that resonate most deeply.**
+                    Trust what arises - there's no wrong answer.
+                    """)
+                    with gr.Row():
+                        with gr.Column():
+                            emotional_needs = gr.CheckboxGroup(
+                                choices=NEEDS_LIST["Emotional Needs"],
+                                label="Emotional Needs (inner security, worth, safety)",
+                                interactive=True
+                            )
+                        with gr.Column():
+                            relational_needs = gr.CheckboxGroup(
+                                choices=NEEDS_LIST["Relational Needs"],
+                                label="Relational Needs (connection, mutuality)",
+                                interactive=True
+                            )
+                    with gr.Row():
+                        with gr.Column():
+                            value_needs = gr.CheckboxGroup(
+                                choices=NEEDS_LIST["Value Needs"],
+                                label="Value Needs (meaning, growth, contribution)",
+                                interactive=True
+                            )
+                        with gr.Column():
+                            lifestyle_needs = gr.CheckboxGroup(
+                                choices=NEEDS_LIST["Lifestyle Needs"],
+                                label="Lifestyle Needs (wellbeing, vitality)",
+                                interactive=True
+                            )
+                    selected_display = gr.Textbox(
+                        label="Your Selected Needs",
+                        interactive=False,
+                        placeholder="Selected needs will appear here..."
                     )
+                    confirm_needs_btn = gr.Button("Confirm My Needs", variant="primary")
+                # Message input
+                msg = gr.Textbox(
+                    label="Your Message",
+                    placeholder="What do you want to say? Or type 'continue' to proceed...",
+                    lines=3
+                )
+                with gr.Row():
+                    submit_btn = gr.Button("Continue Practice", variant="primary")
+                    reset_btn = gr.Button("Start New Practice", variant="secondary")
+            # Sidebar
+            with gr.Column(scale=1):
+                gr.Markdown("### Settings")
+                somatic_check = gr.Checkbox(
+                    label="Include body check-ins",
+                    value=True,
+                    info="Pause to notice body sensations"
+                )
+                gr.Markdown("### Current Stage")
+                stage_display = gr.Textbox(
+                    label="Stage",
+                    value="1/13: Raw Input",
+                    interactive=False
+                )
+                focus_display = gr.Textbox(
+                    label="Learning Focus",
+                    value="Emotional awareness",
+                    interactive=False
+                )
+                progress = gr.Slider(
+                    minimum=1,
+                    maximum=13,
+                    value=1,
+                    step=1,
+                    label="Progress",
+                    interactive=False
+                )
+                gr.Markdown("""
+                ### Resources
+                - [NVC Feelings List](https://www.cnvc.org/training/resource/feelings-inventory)
+                - [NVC Needs List](https://www.cnvc.org/training/resource/needs-inventory)
+                - [Marshall Rosenberg](https://www.cnvc.org/online-learning/nvc-instruction-guide/nvc-instruction-guide)
+                - [Sarah Peyton](https://sarahpeyton.com/)
+                - [Tara Brach](https://www.tarabrach.com/)
+                """)
+        # Event handlers
+        def handle_submit(message, history, stage, session, somatic, sel_needs):
+            """Handle message submission"""
+            if not message.strip():
+                message = "continue"
+            # If at stage 5 and needs haven't been confirmed, prompt to select
+            if stage == 5 and not sel_needs:
+                bot_response = "Please take a moment to select your needs from the list above, then click 'Confirm My Needs' to continue."
+                history = history + [[message, bot_response]]
+                return (
+                    history, "", stage, session, sel_needs,
+                    f"{stage}/13: {STAGE_NAMES[stage]}",
+                    STAGE_FOCUS[stage],
+                    stage,
+                    gr.update(visible=True)
+                )
+            # If needs were just confirmed, add them to context
+            if stage == 5 and sel_needs:
+                session["needs"] = sel_needs
+                message = f"I've identified these needs: {', '.join(sel_needs)}"
+            # Process the stage
+            response, next_stage, updated_session, error = process_stage(
+                message, stage, session, somatic
+            )
+            if error:
+                history = history + [[message, error]]
+                return (
+                    history, "", stage, session, sel_needs,
+                    f"{stage}/13: {STAGE_NAMES[stage]}",
+                    STAGE_FOCUS[stage],
+                    stage,
+                    gr.update(visible=(stage == 5))
+                )
+            # Update history
+            if message != "continue":
+                history = history + [[message, response]]
+            else:
+                history = history + [[None, response]]
+            # Show needs accordion at stage 5
+            show_needs = (next_stage == 5)
+            # Reset if completed
+            if stage == 13:
+                next_stage = 1
+                updated_session = {}
+                sel_needs = []
+            return (
+                history,
+                "",
+                next_stage,
+                updated_session,
+                sel_needs,
+                f"{next_stage}/13: {STAGE_NAMES[next_stage]}",
+                STAGE_FOCUS[next_stage],
+                next_stage,
+                gr.update(visible=show_needs)
+            )
+        def handle_reset():
+            """Reset the practice session"""
+            return (
+                [],  # history
+                "",  # message
+                1,   # stage
+                {},  # session_data
+                [],  # selected_needs
+                "1/13: Raw Input",
+                "Emotional awareness",
+                1,
+                gr.update(visible=False),
+                [], [], [], []  # clear all checkboxes
+            )
+        def update_selected_needs(emotional, relational, value, lifestyle):
+            """Update the selected needs display"""
+            all_selected = emotional + relational + value + lifestyle
+            return ", ".join(all_selected) if all_selected else "No needs selected yet"
+        def confirm_needs(emotional, relational, value, lifestyle, history, stage, session):
+            """Confirm selected needs and continue"""
+            all_selected = emotional + relational + value + lifestyle
+            if not all_selected:
+                return (
+                    all_selected,
+                    history + [[None, "Please select at least one need before continuing."]],
+                    stage,
+                    session
+                )
+            session["needs"] = all_selected
+            # Process to next stage with the needs
+            response, next_stage, updated_session, error = process_stage(
+                f"I've identified these needs: {', '.join(all_selected)}",
+                stage,
+                session,
+                True  # somatic_enabled doesn't matter at this stage
+            )
+            history = history + [[f"Selected needs: {', '.join(all_selected)}", response]]
+            return all_selected, history, next_stage, updated_session
+        # Wire up events
+        submit_btn.click(
+            fn=handle_submit,
+            inputs=[msg, chatbot, current_stage, session_data, somatic_check, selected_needs],
+            outputs=[
+                chatbot, msg, current_stage, session_data, selected_needs,
+                stage_display, focus_display, progress, needs_accordion
+            ]
+        )
+        msg.submit(
+            fn=handle_submit,
+            inputs=[msg, chatbot, current_stage, session_data, somatic_check, selected_needs],
+            outputs=[
+                chatbot, msg, current_stage, session_data, selected_needs,
+                stage_display, focus_display, progress, needs_accordion
+            ]
+        )
+        reset_btn.click(
+            fn=handle_reset,
+            outputs=[
+                chatbot, msg, current_stage, session_data, selected_needs,
+                stage_display, focus_display, progress, needs_accordion,
+                emotional_needs, relational_needs, value_needs, lifestyle_needs
+            ]
+        )
+        # Update selected needs display when checkboxes change
+        for checkbox in [emotional_needs, relational_needs, value_needs, lifestyle_needs]:
+            checkbox.change(
+                fn=update_selected_needs,
+                inputs=[emotional_needs, relational_needs, value_needs, lifestyle_needs],
+                outputs=[selected_display]
+            )
+        confirm_needs_btn.click(
+            fn=confirm_needs,
+            inputs=[emotional_needs, relational_needs, value_needs, lifestyle_needs, chatbot, current_stage, session_data],
+            outputs=[selected_needs, chatbot, current_stage, session_data]
+        ).then(
+            fn=lambda s: (f"{s}/13: {STAGE_NAMES[s]}", STAGE_FOCUS[s], s, gr.update(visible=False)),
+            inputs=[current_stage],
+            outputs=[stage_display, focus_display, progress, needs_accordion]
+        )
+    return demo
+# ============ LAUNCH ============
+if __name__ == "__main__":
+    demo = create_app()
+    demo.launch()

requirements.txt CHANGED Viewed

@@ -1,10 +1,2 @@
-streamlit>=1.32.0
-python-dotenv>=1.0.0
-anthropic>=0.24.0
-# The following are no longer needed:
-# openai>=1.0.0
-# pyttsx3==2.98
-# google-generativeai
-# gradio


1	+ gradio>=4.0.0
2	+ anthropic>=0.18.0