Add complete Pen Pal AI application for Hugging Face deployment

- Add main Gradio interface (app.py) with letter-writing UI
- Add requirements.txt with dependencies
- Update README.md with Hugging Face YAML frontmatter
- Add demo header and UI images
- Add avatar images for user and AI
- Add .env.example and .gitignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

.env.example

@@ -0,0 +1 @@
+OPENAI_API_KEY=your_openai_api_key_here

.gitignore

@@ -0,0 +1,14 @@
+.env
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+flagged/
+gradio_cached_examples/

CLAUDE.md

@@ -0,0 +1,110 @@
+# CLAUDE.md - Pen Pal AI Project
+
+## Project Concept
+
+Pen Pal AI is an experimental Gradio interface that reimagines conversational AI through the metaphor of letter writing. Instead of typical chatbot interfaces, this creates an asynchronous, thoughtful correspondence experience.
+
+## Core Philosophy
+
+### Long-Form Prompting
+- User writes substantial, detailed prompts (like composing a letter)
+- AI responds comprehensively in a single turn (like writing a reply letter)
+- Focus on thoughtful, asynchronous communication rather than rapid chat exchanges
+
+### Inspiration
+The project stems from discovering that long-form prompts:
+- Pose no challenge to modern context windows
+- Allow dramatically better inference by seeding context within prompts
+- Eliminate the need for RAG or other complex context management
+- Work particularly well with voice-to-text input (STT)
+
+## UI/UX Design
+
+### Letter-Writing Interface
+- Large text area for composing letters (styled like writing paper)
+- "Send to AI" button (conceptually like mailing a letter)
+- Subject line system based on formal correspondence conventions
+- Letter headers showing: `Re: [Topic] (User Prompt N)` or `Re: [Topic] (AI Reply N)`
+
+### Thread Management
+- First user prompt triggers AI-generated subject line
+- Subject line persists throughout the exchange
+- Turn numbering: User Prompt 1, AI Reply 1, User Prompt 2, AI Reply 2, etc.
+- Thread history displays all letters in sequence
+
+### Features
+- **Download functionality**: Each letter can be downloaded as markdown
+- **Thread history**: Visual display of all letters in the conversation
+- **AI avatar**: Visual representation for the AI correspondent
+- **Inbox concept**: Future enhancement could include inbox symbols/animations
+
+## Technical Implementation
+
+### Context Window Strategy
+The "secret sauce" is single-turn interaction with no persistent context window:
+- Each letter is treated as an independent interaction
+- Optional: Context truncation to enforce this paradigm
+- Prevents the AI from building up conversation history
+- Encourages users to be thorough in each letter
+
+### Technology Stack
+- **Frontend**: Gradio (for rapid prototyping and Hugging Face deployment)
+- **LLM**: OpenAI API (completions endpoint preferred for single-turn responses)
+- **Format**: Markdown for letter content and downloads
+
+## Use Cases
+
+### Conversational but Asynchronous
+This sits between two paradigms:
+- **Workflow AI**: Non-interactive, task-oriented
+- **Conversational AI**: Interactive, real-time chat
+
+Pen Pal AI creates a third category:
+- Conversational (back-and-forth exchange)
+- Asynchronous (thoughtful, non-real-time)
+- Relaxed correspondence style
+
+### Target Users
+Ideal for people who:
+- Prefer thoughtful, detailed communication over rapid chat
+- Want to explore ideas in depth
+- Appreciate the ritual of letter writing
+- Use voice-to-text for input (natural fit for long-form)
+
+## Future Enhancements
+
+### Notification System
+- Email-like notifications when "letter arrives"
+- Actual inbox interface showing received letters
+- Could integrate with email for true async correspondence
+
+### Context Management
+- Optional context truncation settings
+- User control over how much history AI can "remember"
+- Experimentation with single-turn vs. limited context
+
+## Deployment
+
+### Local Testing
+- Gradio interface for rapid iteration
+- OpenAI API integration for testing
+
+### Hugging Face Spaces
+- Deploy as public Hugging Face Space
+- Use Hugging Face Secrets for API key management
+- Share as experimental interface for community feedback
+
+## Project Goals
+
+1. **Validate the concept**: Does letter-writing metaphor resonate with users?
+2. **Test single-turn paradigm**: Is this more effective than traditional chat?
+3. **Gather feedback**: Learn what works and what doesn't
+4. **Explore async AI**: Create a new category of AI interaction
+
+## Development Notes
+
+- Keep Gradio implementation simple for initial prototype
+- Focus on core letter-writing experience first
+- Add advanced features (context control, notifications) after validation
+- Prioritize markdown formatting for readability
+- Ensure clean download functionality for archiving letters

README.md

@@ -1 +1,183 @@
-# Penpal-AI
+---
+title: Pen Pal AI
+emoji: 📮
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Pen Pal AI - Letter Exchange
+
+![alt text](image.png)
+
+An experimental AI interface that reimagines conversational AI through the timeless metaphor of letter writing. Instead of rapid-fire chatbot exchanges, Pen Pal AI encourages thoughtful, long-form correspondence with an AI pen pal.
+
+## 🎯 Concept
+
+Traditional conversational AI is modeled after instant messaging - quick back-and-forth exchanges. Pen Pal AI explores a different paradigm:
+
+- **Asynchronous**: Take your time composing thoughtful letters
+- **Long-form**: Write detailed, context-rich prompts without worrying about length
+- **Single-turn focus**: Each letter gets a complete, comprehensive response
+- **Relaxed correspondence**: More like writing to a friend than querying a chatbot
+
+## ✨ Features
+
+- 📝 **Letter-writing interface** with serif fonts and comfortable styling
+- 📬 **Automatic subject line generation** for each conversation thread
+- 🔢 **Turn tracking** - User Prompt 1, AI Reply 1, User Prompt 2, etc.
+- 📚 **Thread history** showing all letters in chronological order
+- 💾 **Markdown downloads** for each letter (preserve your correspondence!)
+- 🔄 **New conversation** button to start fresh threads
+
+## 🚀 Quick Start
+
+### Local Installation
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/danielrosehill/Penpal-AI.git
+   cd Penpal-AI
+   ```
+
+2. **Set up virtual environment:**
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Configure API key:**
+   ```bash
+   cp .env.example .env
+   # Edit .env and add your OpenAI API key
+   ```
+
+5. **Run the application:**
+   ```bash
+   python app.py
+   ```
+
+6. **Open your browser** to the URL shown in the terminal (typically `http://localhost:7860`)
+
+## 🔑 API Key Setup
+
+This application uses OpenAI's API. You'll need:
+
+1. An OpenAI API account ([sign up here](https://platform.openai.com/signup))
+2. An API key ([get one here](https://platform.openai.com/api-keys))
+3. Add the key to your `.env` file:
+   ```
+   OPENAI_API_KEY=sk-...your-key-here
+   ```
+
+## 📖 How to Use
+
+1. **Compose your letter** in the text area on the left
+2. Click **"📮 Send Letter"**
+3. Your letter appears in the "Your Last Letter" section
+4. The AI's reply appears on the right side
+5. View the **complete thread history** at the bottom
+6. Download any letter using the **💾 Download** buttons
+7. Start a **new conversation** anytime with the 🔄 button
+
+## 💡 Tips for Best Results
+
+- **Write naturally** - compose as if writing to a thoughtful friend
+- **Provide context** - since each letter is self-contained, include relevant background
+- **Ask complex questions** - this format excels at exploring ideas in depth
+- **Take your time** - this isn't instant messaging, it's correspondence
+- **Use voice-to-text** - long-form prompts work wonderfully with STT
+
+## 🎨 The Philosophy
+
+This project explores what happens when we:
+- Reject the chat interface paradigm
+- Embrace asynchronous, thoughtful communication
+- Encourage long-form, context-rich prompts
+- Treat AI interaction more like correspondence than commands
+
+The hypothesis: This approach might work better for certain types of thinking, exploration, and creative work.
+
+## 🌐 Deployment to Hugging Face
+
+### Option 1: Deploy via Hugging Face Spaces UI
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose "Gradio" as the SDK
+4. Upload `app.py` and `requirements.txt`
+5. Add your `OPENAI_API_KEY` in Settings → Repository Secrets
+6. Your space will build and deploy automatically!
+
+### Option 2: Deploy via Git
+
+1. Create a new Space on Hugging Face
+2. Clone the Space repository:
+   ```bash
+   git clone https://huggingface.co/spaces/YOUR_USERNAME/SPACE_NAME
+   cd SPACE_NAME
+   ```
+3. Copy files:
+   ```bash
+   cp /path/to/Penpal-AI/app.py .
+   cp /path/to/Penpal-AI/requirements.txt .
+   ```
+4. Commit and push:
+   ```bash
+   git add app.py requirements.txt
+   git commit -m "Initial deployment of Pen Pal AI"
+   git push
+   ```
+5. Add `OPENAI_API_KEY` in Space Settings → Repository Secrets
+
+## 🛠️ Technical Details
+
+- **Framework**: Gradio 5.49.1
+- **LLM**: OpenAI GPT-4o (for responses) and GPT-4o-mini (for subject generation)
+- **Language**: Python 3.12+
+- **Deployment**: Compatible with Hugging Face Spaces
+
+## 🤔 Why This Exists
+
+The creator discovered that long-form prompting, especially with voice-to-text input, produces better AI interactions than traditional chat. This interface explores that insight by creating a UI that encourages and celebrates long-form correspondence.
+
+It sits between:
+- **Workflow AI** (non-interactive, task-oriented)
+- **Conversational AI** (interactive chat)
+
+Creating a third category: **Correspondence AI** (conversational but asynchronous)
+
+## 🔮 Future Ideas
+
+- Email-style notifications when "letters arrive"
+- Context truncation controls (experiment with memory vs. fresh-start)
+- User-selectable AI "personalities" or writing styles
+- Export entire threads as formatted PDFs
+- Integration with actual email for true async correspondence
+
+## 📝 License
+
+MIT License
+
+## 🙏 Acknowledgments
+
+Inspired by the art of letter writing and the belief that slower, more thoughtful communication can be powerful even (or especially) with AI.
+
+## 📧 Contact
+
+For questions, suggestions, or to share your experience:
+- **Website**: danielrosehill.com
+- **Email**: public@danielrosehill.com
+
+---
+
+*Built with ✉️ by Daniel Rosehill*

app.py

@@ -0,0 +1,472 @@
+import gradio as gr
+import os
+from datetime import datetime
+from openai import OpenAI
+from typing import List, Tuple, Optional
+import json
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Initialize OpenAI client
+client = None
+api_key = os.getenv("OPENAI_API_KEY")
+if api_key:
+    client = OpenAI(api_key=api_key)
+
+def set_api_key(key: str) -> str:
+    """Set the OpenAI API key."""
+    global client, api_key
+    if key.strip():
+        api_key = key.strip()
+        client = OpenAI(api_key=api_key)
+        return "API key set successfully!"
+    return "Please enter a valid API key."
+
+# Global state to store conversation threads
+conversation_state = {
+    "thread_history": [],
+    "current_subject": None,
+    "user_turn": 0,
+    "ai_turn": 0
+}
+
+def generate_subject_line(user_letter: str) -> str:
+    """Generate a subject line for the first letter using OpenAI."""
+    if not client:
+        return "General Correspondence"
+
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that generates concise, descriptive subject lines for letters. Generate a subject line (max 6 words) that captures the main topic. Return ONLY the subject line, nothing else."
+                },
+                {
+                    "role": "user",
+                    "content": f"Generate a subject line for this letter:\n\n{user_letter}"
+                }
+            ],
+            max_tokens=20,
+            temperature=0.7
+        )
+        subject = response.choices[0].message.content.strip()
+        # Remove any quotes if the model added them
+        subject = subject.strip('"').strip("'")
+        return subject
+    except Exception as e:
+        return f"General Correspondence"
+
+def generate_ai_response(user_letter: str, subject: str) -> str:
+    """Generate AI response in letter format."""
+    if not client:
+        return "⚠️ OpenAI API key not found. Please set OPENAI_API_KEY environment variable."
+
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[
+                {
+                    "role": "system",
+                    "content": """You are a thoughtful pen pal who writes detailed, meaningful letters.
+
+Your writing style should be:
+- Warm and personal, like writing to a friend
+- Structured like a proper letter (greeting, body, closing)
+- Thoughtful and substantive - take time to explore ideas thoroughly
+- Formatted in markdown for readability
+
+Start each letter with a greeting (e.g., "Dear Friend," or "Hello,") and end with a closing (e.g., "Warm regards," or "Best wishes,") followed by "Your AI Pen Pal".
+
+Respond to the user's letter comprehensively. This is asynchronous correspondence - take your time to provide a complete, thoughtful response in a single letter."""
+                },
+                {
+                    "role": "user",
+                    "content": user_letter
+                }
+            ],
+            temperature=0.8,
+            max_tokens=2000
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"⚠️ Error generating response: {str(e)}"
+
+def format_letter_header(subject: str, turn_type: str, turn_number: int) -> str:
+    """Format the letter header with subject line."""
+    date_str = datetime.now().strftime("%B %d, %Y")
+    return f"**Re: {subject} ({turn_type} {turn_number})**\n\n*{date_str}*\n\n---\n\n"
+
+def send_letter(user_letter: str, thread_history: List):
+    """Process user letter and generate AI response."""
+    if not user_letter.strip():
+        # Determine labels based on conversation state
+        is_first = conversation_state["current_subject"] is None
+        btn_text = "Send Letter" if is_first else "Send Reply"
+        input_label = "Your Letter" if is_first else "Your Reply"
+        input_placeholder = "Dear AI Pen Pal,\n\nI've been thinking about..." if is_first else "Dear AI Pen Pal,\n\nThank you for your letter. In response..."
+        section_title = "## Compose Your Letter" if is_first else "## Compose Your Reply"
+
+        return (
+            "",
+            "Please write a letter before sending.",
+            thread_history,
+            "",
+            "",
+            gr.update(value=btn_text),
+            gr.update(label=input_label, placeholder=input_placeholder),
+            gr.update(value=section_title)
+        )
+
+    # Generate subject line if this is the first letter
+    if conversation_state["current_subject"] is None:
+        conversation_state["current_subject"] = generate_subject_line(user_letter)
+        conversation_state["user_turn"] = 0
+        conversation_state["ai_turn"] = 0
+
+    # Increment turn counters
+    conversation_state["user_turn"] += 1
+    subject = conversation_state["current_subject"]
+
+    # Format user letter with header
+    user_header = format_letter_header(subject, "User Prompt", conversation_state["user_turn"])
+    formatted_user_letter = user_header + user_letter
+
+    # Add user letter to thread
+    thread_history.append({
+        "type": "user",
+        "content": formatted_user_letter,
+        "timestamp": datetime.now().isoformat()
+    })
+
+    # Generate AI response
+    ai_response_content = generate_ai_response(user_letter, subject)
+
+    # Increment AI turn
+    conversation_state["ai_turn"] += 1
+
+    # Format AI response with header
+    ai_header = format_letter_header(subject, "AI Reply", conversation_state["ai_turn"])
+    formatted_ai_response = ai_header + ai_response_content
+
+    # Add AI response to thread
+    thread_history.append({
+        "type": "ai",
+        "content": formatted_ai_response,
+        "timestamp": datetime.now().isoformat()
+    })
+
+    # Build thread display
+    thread_display = build_thread_display(thread_history)
+
+    # Update UI labels for reply mode
+    btn_text = "Send Reply"
+    input_label = "Your Reply"
+    input_placeholder = "Dear AI Pen Pal,\n\nThank you for your letter. In response..."
+    section_title = "## Compose Your Reply"
+
+    # Clear user input and show AI response
+    return (
+        "",
+        formatted_ai_response,
+        thread_history,
+        thread_display,
+        formatted_user_letter,
+        gr.update(value=btn_text),
+        gr.update(label=input_label, placeholder=input_placeholder),
+        gr.update(value=section_title)
+    )
+
+def build_thread_display(thread_history: List) -> str:
+    """Build formatted thread history display."""
+    if not thread_history:
+        return "*No letters yet. Start writing!*"
+
+    thread_md = "# Letter Thread\n\n"
+    for i, letter in enumerate(thread_history):
+        if letter["type"] == "user":
+            avatar_img = '<img src="file/images/human.png" width="40" style="border-radius: 50%; vertical-align: middle; margin-right: 10px;">'
+            sender = f'{avatar_img} **You**'
+        else:
+            avatar_img = '<img src="file/images/ai.png" width="40" style="border-radius: 50%; vertical-align: middle; margin-right: 10px;">'
+            sender = f'{avatar_img} **AI Pen Pal**'
+
+        thread_md += f"### {sender}\n\n{letter['content']}\n\n---\n\n"
+
+    return thread_md
+
+def download_letter(letter_content: str, letter_type: str) -> str:
+    """Prepare letter content for download."""
+    if not letter_content:
+        return "# No letter to download\n\nPlease send a letter first."
+    return letter_content
+
+def new_conversation():
+    """Start a new conversation thread."""
+    conversation_state["thread_history"] = []
+    conversation_state["current_subject"] = None
+    conversation_state["user_turn"] = 0
+    conversation_state["ai_turn"] = 0
+
+    return (
+        "",
+        "",
+        [],
+        "*No letters yet. Start writing!*",
+        "",
+        gr.update(value="Send Letter"),
+        gr.update(label="Your Letter", placeholder="Dear AI Pen Pal,\n\nI've been thinking about..."),
+        gr.update(value="## Compose Your Letter")
+    )
+
+# Custom CSS for letter-writing aesthetic
+custom_css = """
+.letter-box textarea {
+    font-family: 'Georgia', 'Times New Roman', serif !important;
+    font-size: 16px !important;
+    line-height: 1.8 !important;
+    padding: 20px !important;
+}
+
+.gradio-container {
+    font-family: 'Georgia', 'Times New Roman', serif !important;
+}
+
+#thread-history {
+    background-color: #f9f7f4;
+    padding: 20px;
+    border-radius: 8px;
+    border: 1px solid #d4c5b9;
+}
+
+.letter-display {
+    background-color: #fffef8;
+    padding: 25px;
+    border-left: 4px solid #8b7355;
+}
+
+.mic-button {
+    min-width: 50px !important;
+}
+"""
+
+# JavaScript for speech-to-text
+speech_to_text_js = """
+function setupSpeechRecognition() {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+
+    if (!SpeechRecognition) {
+        alert('Speech recognition is not supported in your browser. Please use Chrome, Edge, or Safari.');
+        return null;
+    }
+
+    const recognition = new SpeechRecognition();
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.lang = 'en-US';
+
+    return recognition;
+}
+
+let recognition = null;
+let isRecording = false;
+let fullTranscript = '';
+
+function toggleSpeechRecognition(currentText) {
+    if (!recognition) {
+        recognition = setupSpeechRecognition();
+        if (!recognition) return [currentText, 'Start Dictation'];
+    }
+
+    if (isRecording) {
+        recognition.stop();
+        isRecording = false;
+        return [currentText, 'Start Dictation'];
+    } else {
+        fullTranscript = currentText || '';
+
+        recognition.onresult = (event) => {
+            let interimTranscript = '';
+
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                const transcript = event.results[i][0].transcript;
+                if (event.results[i].isFinal) {
+                    fullTranscript += (fullTranscript ? ' ' : '') + transcript;
+                } else {
+                    interimTranscript += transcript;
+                }
+            }
+
+            const textarea = document.querySelector('.letter-box textarea');
+            if (textarea) {
+                textarea.value = fullTranscript + (interimTranscript ? ' ' + interimTranscript : '');
+                textarea.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        };
+
+        recognition.onerror = (event) => {
+            console.error('Speech recognition error:', event.error);
+            isRecording = false;
+            const button = document.querySelector('.mic-button');
+            if (button) button.value = 'Start Dictation';
+        };
+
+        recognition.onend = () => {
+            if (isRecording) {
+                recognition.start();
+            }
+        };
+
+        recognition.start();
+        isRecording = true;
+        return [fullTranscript, 'Stop Dictation'];
+    }
+}
+"""
+
+# Build Gradio interface
+with gr.Blocks(css=custom_css, title="Pen Pal AI - Letter Exchange", theme=gr.themes.Soft()) as demo:
+    # Header image
+    gr.Image("demo-header.png", show_label=False, show_download_button=False, container=False)
+
+    gr.Markdown("""
+    Welcome to a different kind of AI conversation. Write thoughtful, long-form letters and receive detailed responses.
+
+    **How it works:**
+    1. Set your OpenAI API key below (if not already configured)
+    2. Write your letter in the text area
+    3. Click "Send Letter" or use dictation
+    4. Receive a reply from your AI pen pal
+    5. Download any letter as markdown
+
+    This is asynchronous correspondence - take your time, be thoughtful, and enjoy the exchange!
+    """)
+
+    # API Key Configuration
+    with gr.Accordion("API Key Configuration (BYOK)", open=False):
+        gr.Markdown("""
+        This app requires an OpenAI API key. You can get one at [platform.openai.com](https://platform.openai.com/api-keys).
+
+        **For Hugging Face Spaces:** Set your key as a secret named `OPENAI_API_KEY` in your Space settings.
+
+        **For local use:** You can also set it here temporarily (not saved between sessions).
+        """)
+
+        with gr.Row():
+            api_key_input = gr.Textbox(
+                label="OpenAI API Key",
+                placeholder="sk-...",
+                type="password",
+                scale=3
+            )
+            set_key_btn = gr.Button("Set API Key", size="sm", scale=1)
+
+        api_key_status = gr.Markdown("")
+
+    # Hidden state for thread history
+    thread_state = gr.State([])
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            compose_section_title = gr.Markdown("## Compose Your Letter")
+
+            user_input = gr.Textbox(
+                label="Your Letter",
+                placeholder="Dear AI Pen Pal,\n\nI've been thinking about...",
+                lines=15,
+                elem_classes=["letter-box"]
+            )
+
+            with gr.Row():
+                mic_btn = gr.Button("Start Dictation", size="sm", elem_classes=["mic-button"])
+
+            with gr.Row():
+                send_btn = gr.Button("Send Letter", variant="primary", size="lg")
+                new_conv_btn = gr.Button("New Conversation", size="lg")
+
+            gr.Markdown("---")
+
+            gr.Markdown("### Your Last Letter")
+            user_letter_display = gr.Markdown(
+                value="*Your letter will appear here after sending*",
+                elem_classes=["letter-display"]
+            )
+            download_user = gr.DownloadButton(
+                label="Download Your Letter",
+                size="sm"
+            )
+
+        with gr.Column(scale=1):
+            gr.Markdown("## AI Reply")
+
+            ai_response = gr.Markdown(
+                value="*Waiting for your letter...*",
+                elem_classes=["letter-display"]
+            )
+
+            download_ai = gr.DownloadButton(
+                label="Download AI Reply",
+                size="sm"
+            )
+
+    gr.Markdown("---")
+
+    gr.Markdown("## Letter Thread")
+    thread_display = gr.Markdown(
+        value="*No letters yet. Start writing!*",
+        elem_id="thread-history"
+    )
+
+    # Event handlers
+    set_key_btn.click(
+        fn=set_api_key,
+        inputs=[api_key_input],
+        outputs=[api_key_status]
+    )
+
+    send_btn.click(
+        fn=send_letter,
+        inputs=[user_input, thread_state],
+        outputs=[user_input, ai_response, thread_state, thread_display, user_letter_display, send_btn, user_input, compose_section_title]
+    )
+
+    new_conv_btn.click(
+        fn=new_conversation,
+        inputs=[],
+        outputs=[user_input, ai_response, thread_state, thread_display, user_letter_display, send_btn, user_input, compose_section_title]
+    )
+
+    # Speech-to-text handler
+    mic_btn.click(
+        fn=None,
+        inputs=[user_input],
+        outputs=[user_input, mic_btn],
+        js=speech_to_text_js.replace("function toggleSpeechRecognition", "function(currentText) { return toggleSpeechRecognition")
+    )
+
+    # Download handlers
+    user_letter_display.change(
+        fn=lambda x: gr.DownloadButton(
+            label="Download Your Letter",
+            value=x if x and x != "*Your letter will appear here after sending*" else None,
+            visible=bool(x and x != "*Your letter will appear here after sending*")
+        ),
+        inputs=[user_letter_display],
+        outputs=[download_user]
+    )
+
+    ai_response.change(
+        fn=lambda x: gr.DownloadButton(
+            label="Download AI Reply",
+            value=x if x and x != "*Waiting for your letter...*" else None,
+            visible=bool(x and x != "*Waiting for your letter...*")
+        ),
+        inputs=[ai_response],
+        outputs=[download_ai]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,3 @@
+gradio==5.49.1
+openai==2.6.0
+python-dotenv==1.1.1