Update to use Anthropic API instead of OpenAI

app.py

@@ -1,7 +1,6 @@
 import os
 import streamlit as st
-# from anthropic import Anthropic
-import openai # Added OpenAI import
+from anthropic import Anthropic
 from dotenv import load_dotenv
 
 # Load environment variables
@@ -9,23 +8,57 @@ load_dotenv()
 
 # Configure Streamlit page settings
 st.set_page_config(
-    page_title="Attachment Style Roleplay Simulator",
-    page_icon="🎭",
+    page_title="Practice Difficult Conversations",
+    page_icon="🤝",
     layout="centered",
 )
 
-# Initialize OpenAI client
-# anthropic = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY") or os.getenv("ANTHROPIC_KEY"))
+# 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:
-    client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY")) # Use OpenAI client
-    if not client.api_key:
-        st.error("OpenAI API Key not found. Please set the OPENAI_API_KEY environment variable.")
+    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 OpenAI client: {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
@@ -34,29 +67,29 @@ if "messages" not in st.session_state:
     st.session_state.messages = []
 
 # Main page header
-st.markdown("<h1 style='text-align: center; color: #333;'>Attachment Style Roleplay Simulator</h1>", unsafe_allow_html=True)
-st.markdown("<p style='text-align: center; font-size: 18px; color: #555; margin-bottom: 1em;'>A Safe Space for Practicing Difficult Conversations</p>", unsafe_allow_html=True)
+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 built for emotionally charged moments.
-    This tool helps you rehearse boundary-setting and difficult conversations by simulating realistic relational dynamics—tailored to your attachment style.
+    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)
-    - Your attachment style (e.g., anxious, avoidant, disorganized)
-    - And your goal (e.g., "I want to stay calm and not backtrack")
+    - And your practice goal (e.g., "I want to stay calm and not backtrack")
 
-    The AI will take on the role of a realistic human responder—not to therapize you, but to mirror the relational pressure you might encounter in real life. Then, you'll get a reflection summary to help you track your emotional patterns and practice courage.
+    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 vibes when you read it:
+    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."
@@ -78,7 +111,7 @@ with st.sidebar:
     - Help clients and clinicians rehearse courage, regulation, and repair
     - Stay grounded in trauma-informed, developmentally sensitive frameworks
 
-    I use powerful language models like OpenAI's GPT-4o for these tools, chosen for their ability to simulate nuanced human interaction and responsiveness to emotionally complex prompts.
+    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.
 
@@ -170,24 +203,34 @@ else:
         # Prepare messages for API call (already includes system message as the first item)
         api_messages = st.session_state.messages
 
-        # Get OpenAI's response
+        # Get Anthropic's response
         with st.spinner("..."):
             try:
-                # Replace Anthropic call with OpenAI call
-                # response = anthropic.messages.create(
-                #     model="claude-3-opus-20240229",
-                #     max_tokens=1024,
-                #     messages=api_messages
-                # )
-                # assistant_response = response.content[0].text
-
-                response = client.chat.completions.create(
-                    model="gpt-4o", # Use gpt-4o
-                    messages=api_messages, # Pass the whole conversation history
-                    max_tokens=150 # Keep responses relatively brief by default
+                # 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.choices[0].message.content
-
+                assistant_response = response.content[0].text
 
                 # Add assistant response to chat history
                 st.session_state.messages.append(
@@ -210,6 +253,113 @@ else:
                 # 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("---")