app.py

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"):
            st.write("Debug: Found key in Streamlit secrets")
            return st.secrets.anthropic_key
    except Exception as e:
        st.write(f"Debug: Error accessing Streamlit secrets: {e}")
    
    # Fall back to environment variable (for local development)
    env_key = os.getenv("ANTHROPIC_API_KEY")
    if env_key:
        st.write("Debug: Found key in environment variables")
        return env_key
    else:
        st.write("Debug: No key found in environment variables")
        
    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)
    st.write("Debug: Successfully created Anthropic client")
    
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—Safely.

    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://www.yourresonantself.com/attachment-assessment) 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."
    """)

# Sidebar with setup form
with st.sidebar:
    st.markdown("""
    ### Welcome! 👋

    Hi, I'm Jocelyn Skillman, LMHC — a clinical therapist, relational design ethicist, and creator of experimental tools that explore how AI can support (not replace) human care.

    Each tool in this collection is thoughtfully designed to:

    - Extend therapeutic support between sessions
    - Model emotional safety and relational depth
    - Help clients and clinicians rehearse courage, regulation, and repair
    - Stay grounded in trauma-informed, developmentally sensitive frameworks

    I use powerful language models like Anthropic's Claude for these tools, chosen for their ability to simulate nuanced human interaction and responsiveness to emotionally complex prompts.

    As a practicing therapist, I imagine these resources being especially helpful to clinicians like myself — companions in the work of tending to others with insight, warmth, and care.

    #### Connect With Me
    🌐 [jocelynskillman.com](http://www.jocelynskillman.com)
    📬 [Substack: Relational Code](https://jocelynskillmanlmhc.substack.com/)

    ---
    """)

    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?"
        )

        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")

        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
            # OpenAI expects the system message as the first message in the list
            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
            # No need to store system_message separately in session state anymore
            # if "system_message" in st.session_state:
            #      del st.session_state["system_message"]
            st.rerun()


# Display simulation status
if not st.session_state.setup_complete:
    st.info("👈 Please complete the simulation setup in the sidebar to begin.")
else:
    # 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-3-opus-20240229",
                    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):
                st.session_state.in_debrief = True
                
                # Prepare debrief system message
                debrief_system_message = """You are a warm, trauma-informed reflection guide. Your role is to help users process their experience from the previous roleplay conversation. Important notes:

- Start with: "I'm not a therapist, even though I may sound relational. I've been trained as a language model to support emotional reflection, but I encourage you to bring these insights into connection with a trusted therapist, mentor, or support circle who can help you explore them more deeply."

Then analyze the conversation following this structure:

1. Tone / Persona Used:
   - Note the AI role they interacted with
   - Describe key patterns in that communication style
   - Ask how that style impacted them

2. Emotional Shifts:
   - Track their emotional journey
   - Note any significant changes in tone or engagement
   - Invite reflection on those shifts

3. Signs of:
   - Courage: Moments of speaking up, setting boundaries, expressing needs
   - Avoidance: When they might have pulled back or deflected
   - Protest: Times they pushed back or expressed disagreement

4. Rupture & Repair:
   - Identify moments of disconnection or tension
   - Note any attempts to rebuild connection
   - Ask about the felt experience of these moments

5. Integration:
   - Offer a gentle somatic or journaling prompt
   - Focus on body awareness and felt sense
   - Use language like "if you're willing..." or "you might notice..."

Remember to:
- Use phrases like "I notice..." or "I'm curious about..."
- Validate all emotional responses
- Keep focus on their experience, not your analysis
- Offer observations as invitations, not declarations
- Stay grounded in the present moment"""

                # Store previous conversation for analysis
                conversation_history = st.session_state.messages[1:]  # Skip system message
                
                # Initialize debrief conversation
                st.session_state.debrief_messages = [
                    {"role": "system", "content": debrief_system_message},
                    {"role": "user", "content": f"Please help me process this conversation. Here's what happened: {str(conversation_history)}"}
                ]
                
                try:
                    response = client.messages.create(
                        model="claude-3-opus-20240229",
                        messages=st.session_state.debrief_messages,
                        max_tokens=1000
                    )
                    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[1:]:  # Skip system message
            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-3-opus-20240229",
                            messages=st.session_state.debrief_messages,
                            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)