Create app.py

app.py

@@ -0,0 +1,1380 @@
+import streamlit as st
+import requests
+import json
+import os
+import pyaudio as pyaudio
+import base64
+from io import BytesIO
+import speech_recognition as sr
+from elevenlabs import play, stream, save
+from elevenlabs.client import ElevenLabs
+from elevenlabs import Voice, VoiceSettings
+from together import Together
+import tempfile
+from audio_recorder_streamlit import audio_recorder
+from PIL import Image
+import random
+import string
+import av
+import time
+import io
+import queue
+from docx import Document
+from fpdf import FPDF
+import pytesseract
+import plotly.express as px
+import pandas as pd
+from pdf2image import convert_from_path
+import PyPDF2
+import docx2txt
+from streamlit_option_menu import option_menu
+import nltk
+from nltk.tokenize import sent_tokenize
+import networkx as nx
+import speech_recognition as sr
+from streamlit_webrtc import webrtc_streamer, WebRtcMode, RTCConfiguration
+import matplotlib.pyplot as plt
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+
+nltk.download('punkt')
+
+from streamlit_agraph import agraph, Node, Edge, Config
+import pandas as pd
+from wordcloud import WordCloud
+import numpy as np
+import threading
+import pydub
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import math
+import wave
+
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph
+from reportlab.lib.styles import getSampleStyleSheet
+
+# API Keys
+XI_API_KEY = "sk_44be09a8808c06fec48cc005a1f0443b1ef30711a06cb23c"
+TOGETHER_API_KEY = "291a366758796aaf86fe851b1b0ce2278ef75c750930e9f5d949e6b38bd208de"
+
+# Initialize clients
+elevenlabs_client = ElevenLabs(api_key=XI_API_KEY)
+together_client = Together(api_key=TOGETHER_API_KEY)
+
+
+# Predefined characters (expanded)
+predefined_characters = {
+    "Naruto Uzumaki": {
+        "description": "Protagonist of the Naruto series. An optimistic and determined ninja with the goal of becoming Hokage.",
+        "voice_id": " rKe56TKNeWFVS5tXg0nO",
+        "image": "https://i.pinimg.com/originals/2e/f7/0d/2ef70d5217b530dfb766a45d9babbb5e.jpg"
+        },
+    "Sherlock Holmes": {
+        "description": "Brilliant detective known for his logical reasoning and observational skills.",
+        "voice_id": "VR6AewLTigWG4xSOukaG",
+        "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSFNrsQ14wE7vKH_46oN-tCF3YwGyjo9fbLMuTpvm3ENf_10JcTHqoIyxkl_EDgpmGnEXs&usqp=CAU"
+    },
+    "Elizabeth Bennet": {
+        "description": "Protagonist of Pride and Prejudice, known for her intelligence and wit.",
+        "voice_id": "EXAVITQu4vr4xnSDxMaL",
+        "image": "https://www.indiependent.co.uk/wp-content/uploads/2015/08/elizabeth-bennet.jpg"
+    }
+}
+
+# Initialize session state
+if "characters" not in st.session_state or not st.session_state.characters:
+    st.session_state.characters = predefined_characters.copy()
+if "current_character" not in st.session_state:
+    st.session_state.current_character = None
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "book_details" not in st.session_state:
+    st.session_state.book_details = {}
+
+# Fiction genres
+fiction_genres = [
+    "Fantasy", "Science Fiction", "Mystery", "Thriller", "Romance", "Historical Fiction",
+    "Horror", "Adventure", "Contemporary Fiction", "Dystopian", "Young Adult"
+]
+
+# Non-fiction genres
+non_fiction_genres = [
+    "Biography", "Autobiography", "Memoir", "Self-help", "History", "Science",
+    "Philosophy", "Psychology", "Business", "Travel", "True Crime"
+]
+
+def create_character(name, description, voice_file, image_file=None):
+    voice = elevenlabs_client.clone(
+        name=name,
+        description=description,
+        files=[voice_file]
+    )
+    
+    image_path = None
+    if image_file:
+        characters_dir = "characters"
+        os.makedirs(characters_dir, exist_ok=True)
+        image_path = os.path.join(characters_dir, f"{name.lower().replace(' ', '_')}.jpg")
+        with Image.open(image_file) as img:
+            img.save(image_path)
+    
+    st.session_state.characters[name] = {
+        "description": description,
+        "voice_id": voice.voice_id,
+        "image": image_path
+    }
+    return voice
+
+def generate_ai_response(character, user_message, language):
+    response = together_client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[
+            {"role": "system", "content": f"You are {character}. {st.session_state.characters[character]['description']} Respond in {language}."},
+            {"role": "user", "content": user_message}
+        ],
+        max_tokens=1024,
+        temperature=0.7,
+        top_p=0.7,
+        top_k=50,
+        repetition_penalty=1,
+        stop=["<|eot_id|>", "<|eom_id|>"]
+    )
+    return response.choices[0].message.content
+
+def text_to_speech(text, voice_id):
+    audio = elevenlabs_client.generate(
+        text=text,
+        voice=Voice(voice_id=voice_id),
+        model="eleven_multilingual_v2"
+    )
+    return audio
+
+def speech_to_text(audio_bytes):
+    recognizer = sr.Recognizer()
+    with sr.AudioFile(BytesIO(audio_bytes)) as source:
+        audio = recognizer.record(source)
+    try:
+        text = recognizer.recognize_google(audio)
+        return text
+    except sr.UnknownValueError:
+        return "Sorry, I couldn't understand the audio."
+    except sr.RequestError:
+        return "Sorry, there was an error processing the audio."
+
+def process_audio(frame):
+    sound = frame.to_ndarray()
+    sound = sound.astype(np.int16)
+    return sound.tobytes()
+
+def split_text(text, chunk_size=5000):
+    """Split the text into chunks of approximately chunk_size characters."""
+    chunks = []
+    current_chunk = []
+    current_size = 0
+    for sentence in nltk.sent_tokenize(text):
+        sentence_size = len(sentence)
+        if current_size + sentence_size > chunk_size and current_chunk:
+            chunks.append(' '.join(current_chunk))
+            current_chunk = []
+            current_size = 0
+        current_chunk.append(sentence)
+        current_size += sentence_size
+    if current_chunk:
+        chunks.append(' '.join(current_chunk))
+    return chunks
+
+def generate_audio_chunk(text, voice_id, headers):
+    """Generate audio for a single chunk of text."""
+    audio_data = {
+        "text": text,
+        "model_id": "eleven_monolingual_v1",
+        "voice_settings": {
+            "stability": 0.5,
+            "similarity_boost": 0.5
+        }
+    }
+    response = requests.post(f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}", json=audio_data, headers=headers)
+    if response.status_code == 200:
+        return response.content
+    else:
+        raise Exception(f"Error generating audio: {response.text}")
+
+def convert_to_audiobook(text, language, voice_id):
+    audio = elevenlabs_client.generate(
+        text=text,
+        voice=Voice(voice_id=voice_id),
+        model="eleven_multilingual_v2"
+    )
+    return audio
+def generate_book_chapter(book_details, chapter_index):
+    chapter = book_details['chapters'][chapter_index]
+    chapter_name = chapter['name']
+
+    if book_details['genre_type'] == 'Fiction':
+        chapter_prompt = f"Write chapter {chapter_index + 1} titled '{chapter_name}' for a {book_details['genre']} book. The book is about: {book_details['description']}. This chapter should include the following scenes: {', '.join(chapter['scenes'])}. Maintain consistency with the overall story and characters."
+        
+        chapter_content = ""
+        for scene_index, scene in enumerate(chapter['scenes']):
+            scene_prompt = f"Write scene {scene_index + 1} for chapter {chapter_index + 1} titled '{chapter_name}'. The scene should include the following details: {scene}"
+            scene_text = together_client.chat.completions.create(
+                model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                messages=[
+                    {"role": "system", "content": f"You are an expert {book_details['genre']} writer."},
+                    {"role": "user", "content": scene_prompt}
+                ],
+                max_tokens=6048,
+                temperature=0.7
+            )
+            chapter_content += f"## Scene {scene_index + 1}\n\n{scene_text.choices[0].message.content}\n\n"
+    else:
+        chapter_prompt = f"Write chapter {chapter_index + 1} titled '{chapter_name}' for a {book_details['genre']} non-fiction book. The book is about: {book_details['description']}. This chapter should cover the following parts: {', '.join(chapter['parts'])}. Ensure the content is informative and well-structured."
+        
+        chapter_content = ""
+        for part_index, part in enumerate(chapter['parts']):
+            part_prompt = f"Write part {part_index + 1} for chapter {chapter_index + 1} titled '{chapter_name}'. The part should cover the following details: {part}"
+            part_text = together_client.chat.completions.create(
+                model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                messages=[
+                    {"role": "system", "content": f"You are an expert {book_details['genre']} writer."},
+                    {"role": "user", "content": part_prompt}
+                ],
+                max_tokens=6048,
+                temperature=0.7
+            )
+            chapter_content += f"## Part {part_index + 1}\n\n{part_text.choices[0].message.content}\n\n"
+    
+    return chapter_content
+def generate_book_introduction(book_details):
+    intro_prompt = f"Write an engaging introduction for a {book_details['genre']} {'fiction' if book_details['genre_type'] == 'Fiction' else 'non-fiction'} book titled '{book_details['title']}' by {book_details['author']}. The book is about: {book_details['description']}."
+    
+    intro_content = together_client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[
+            {"role": "system", "content": "You are an expert book introduction writer."},
+            {"role": "user", "content": intro_prompt}
+        ],
+        max_tokens=1024,
+        temperature=0.7
+    )
+    return intro_content.choices[0].message.content
+
+def generate_table_of_contents(book_details):
+    toc = f"# Table of Contents\n\nIntroduction\n\n"
+    for i, chapter in enumerate(book_details['chapters'], 1):
+        toc += f"{i}. {chapter['name']}\n"
+    return toc
+
+def save_book_formats(content, title):
+    # Save as TXT
+    with open(f"{title}.txt", "w", encoding="utf-8") as f:
+        f.write(content)
+
+    # Save as DOCX
+    doc = Document()
+    doc.add_heading(title, 0)
+    for paragraph in content.split('\n'):
+        doc.add_paragraph(paragraph)
+    doc.save(f"{title}.docx")
+
+    # Save as PDF using reportlab
+    pdf_filename = f"{title}.pdf"
+    doc = SimpleDocTemplate(pdf_filename, pagesize=letter)
+    styles = getSampleStyleSheet()
+    flowables = []
+
+    for paragraph in content.split('\n'):
+        p = Paragraph(paragraph, styles['Normal'])
+        flowables.append(p)
+
+    doc.build(flowables)
+
+def extract_text_from_file(file):
+    file_extension = os.path.splitext(file.name)[1].lower()
+    
+    if file_extension == '.pdf':
+        pdf_reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+    elif file_extension == '.txt':
+        text = file.getvalue().decode('utf-8')
+    elif file_extension in ['.doc', '.docx']:
+        text = docx2txt.process(file)
+    else:
+        raise ValueError("Unsupported file format")
+    
+    return text
+
+# Character Arc Visualizer
+def character_arc_visualizer():
+    st.header("Character Arc Visualizer")
+    st.write("Visualize character development throughout your story.")
+
+    if 'character_arcs' not in st.session_state:
+        st.session_state.character_arcs = {}
+
+    # Input for character arc data
+    character_name = st.text_input("Enter character name")
+    arc_points = st.text_area("Enter arc points (format: Chapter,Development Level)")
+
+    if st.button("Add Character Arc"):
+        if character_name and arc_points:
+            arc_data = [tuple(point.split(',')) for point in arc_points.split('\n') if point.strip()]
+            st.session_state.character_arcs[character_name] = arc_data
+            st.success(f"Arc for {character_name} added successfully!")
+
+    # Visualize character arcs
+    if st.session_state.character_arcs:
+        st.subheader("Character Arcs")
+        fig = go.Figure()
+
+        for character, arc in st.session_state.character_arcs.items():
+            chapters, levels = zip(*arc)
+            fig.add_trace(go.Scatter(x=chapters, y=levels, mode='lines+markers', name=character))
+
+        fig.update_layout(title="Character Development Arcs",
+                          xaxis_title="Story Progression",
+                          yaxis_title="Character Development Level")
+        st.plotly_chart(fig)
+
+# World-Building Assistant
+def world_building_assistant():
+    st.header("World-Building Assistant")
+    st.write("Develop and maintain consistent rules, cultures, and environments for your fictional world with AI assistance.")
+
+    if 'world_elements' not in st.session_state:
+        st.session_state.world_elements = {}
+
+    # Input for world elements
+    element_category = st.selectbox("Element Category", ["Geography", "Culture", "Magic System", "Technology", "History", "Politics"])
+
+    # Custom inputs for each category
+    if element_category == "Geography":
+        element_name = st.text_input("Location Name")
+        climate = st.selectbox("Climate", ["Tropical", "Temperate", "Arctic", "Desert", "Mediterranean"])
+        terrain = st.multiselect("Terrain Features", ["Mountains", "Forests", "Rivers", "Oceans", "Plains", "Islands"])
+        prompt = f"Create a detailed description for a {climate} {', '.join(terrain)} region named {element_name}."
+
+    elif element_category == "Culture":
+        element_name = st.text_input("Culture Name")
+        social_structure = st.selectbox("Social Structure", ["Hierarchical", "Egalitarian", "Clan-based", "Caste System"])
+        values = st.multiselect("Core Values", ["Honor", "Knowledge", "Nature", "Technology", "Spirituality", "Warfare"])
+        prompt = f"Describe the {social_structure} culture of {element_name}, emphasizing their focus on {', '.join(values)}."
+
+    elif element_category == "Magic System":
+        element_name = st.text_input("Magic System Name")
+        source = st.selectbox("Source of Magic", ["Natural Elements", "Divine", "Inner Energy", "Artifacts", "Otherworldly"])
+        limitations = st.multiselect("Limitations", ["Physical toll", "Rare resources", "Specific bloodline", "Years of study", "Unpredictable"])
+        prompt = f"Detail the {source}-based magic system called {element_name}, including its {', '.join(limitations)} as limitations."
+
+    elif element_category == "Technology":
+        element_name = st.text_input("Technology Name")
+        tech_level = st.slider("Technology Level", 1, 10, 5)
+        focus = st.multiselect("Technological Focus", ["Energy", "Transportation", "Communication", "Warfare", "Medicine", "AI"])
+        prompt = f"Describe the level {tech_level} technology {element_name}, focusing on advancements in {', '.join(focus)}."
+
+    elif element_category == "History":
+        element_name = st.text_input("Historical Event/Era Name")
+        time_frame = st.selectbox("Time Frame", ["Ancient", "Medieval", "Renaissance", "Industrial", "Modern", "Futuristic"])
+        event_type = st.selectbox("Event Type", ["War", "Discovery", "Cultural Revolution", "Natural Disaster", "Technological Breakthrough"])
+        prompt = f"Narrate the {time_frame} {event_type} known as {element_name} and its impact on the world."
+
+    elif element_category == "Politics":
+        element_name = st.text_input("Political System/Faction Name")
+        gov_type = st.selectbox("Government Type", ["Monarchy", "Democracy", "Oligarchy", "Theocracy", "Anarchy"])
+        key_issues = st.multiselect("Key Political Issues", ["Resource scarcity", "Technological regulation", "Civil rights", "Environmental concerns", "Foreign relations"])
+        prompt = f"Explain the {gov_type} political system of {element_name}, addressing their stance on {', '.join(key_issues)}."
+
+    if st.button("Generate World Element"):
+        if element_name:
+            with st.spinner("Generating world element..."):
+                response = together_client.chat.completions.create(
+                    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                    messages=[
+                        {"role": "system", "content": "You are an expert world-building assistant for fiction writers."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=5000,
+                    temperature=0.7
+                )
+                element_description = response.choices[0].message.content
+
+            if element_category not in st.session_state.world_elements:
+                st.session_state.world_elements[element_category] = {}
+            st.session_state.world_elements[element_category][element_name] = element_description
+            st.success(f"{element_name} added to {element_category} successfully!")
+
+    # Display world elements
+    if st.session_state.world_elements:
+        st.subheader("Your World")
+        for category, elements in st.session_state.world_elements.items():
+            st.write(f"**{category}**")
+            for name, description in elements.items():
+                with st.expander(name):
+                    st.write(description)
+                    if st.button(f"Regenerate {name}", key=f"regen_{category}_{name}"):
+                        with st.spinner(f"Regenerating {name}..."):
+                            response = together_client.chat.completions.create(
+                                model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                                messages=[
+                                    {"role": "system", "content": "You are an expert world-building assistant for fiction writers."},
+                                    {"role": "user", "content": f"Rewrite and improve the following world element description for {category}: {description}"}
+                                ],
+                                max_tokens=500,
+                                temperature=0.7
+                            )
+                            new_description = response.choices[0].message.content
+                            st.session_state.world_elements[category][name] = new_description
+                            st.experimental_rerun()
+
+    # AI-powered world consistency check
+    if st.button("Check World Consistency"):
+        if st.session_state.world_elements:
+            all_elements = "\n".join([f"{cat}: {name} - {desc}" for cat, elements in st.session_state.world_elements.items() for name, desc in elements.items()])
+            with st.spinner("Analyzing world consistency..."):
+                response = together_client.chat.completions.create(
+                    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                    messages=[
+                        {"role": "system", "content": "You are an expert world-building consultant for fiction writers."},
+                        {"role": "user", "content": f"Analyze the following world elements for consistency and provide suggestions for improvement:\n\n{all_elements}"}
+                    ],
+                    max_tokens=1000,
+                    temperature=0.7
+                )
+                consistency_analysis = response.choices[0].message.content
+            st.subheader("World Consistency Analysis")
+            st.write(consistency_analysis)
+        else:
+            st.warning("Add some world elements before checking consistency.")
+
+    # Export world-building data
+    if st.session_state.world_elements:
+        if st.button("Export World Data"):
+            export_data = {category: {name: desc for name, desc in elements.items()} for category, elements in st.session_state.world_elements.items()}
+            st.download_button(
+                label="Download World Data as JSON",
+                data=json.dumps(export_data, indent=2),
+                file_name="world_building_data.json",
+                mime="application/json"
+            )
+
+def get_audio_data():
+    CHUNK = 1024
+    FORMAT = pyaudio.paInt16
+    CHANNELS = 1
+    RATE = 44100
+    RECORD_SECONDS = 0.1
+
+    p = pyaudio.PyAudio()
+
+    stream = p.open(format=FORMAT,
+                    channels=CHANNELS,
+                    rate=RATE,
+                    input=True,
+                    frames_per_buffer=CHUNK)
+
+    frames = []
+
+    for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+        data = stream.read(CHUNK)
+        frames.append(np.frombuffer(data, dtype=np.int16))
+
+    stream.stop_stream()
+    stream.close()
+    p.terminate()
+
+    return np.concatenate(frames)
+
+def update_audio_chart(chart, audio_data):
+    chart.plotly_chart(go.Figure(data=go.Scatter(y=audio_data, mode='lines')), use_container_width=True)
+
+def create_radar_chart(stats):
+    df = pd.DataFrame(dict(
+        r=list(stats.values()),
+        theta=list(stats.keys())
+    ))
+    fig = px.line_polar(df, r='r', theta='theta', line_close=True)
+    fig.update_traces(fill='toself')
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(visible=True, range=[0, 10])
+        ),
+        showlegend=False
+    )
+    return fig
+
+def main():
+    st.set_page_config(page_title="AUDSOL - AI Automation for Writers", page_icon="📚", layout="wide")
+
+    menu = ["Home", "Create Character", "Chat with Characters", "Generate Book", "Convert to Audiobook", 
+            "Book Outline Generator", "Character Development Workshop", "Writing Prompts Generator", "Character Arc Visualizer", "World-Building Assistant", "Interactive Character Board"]
+    choice = st.sidebar.selectbox("Menu", menu)
+
+    if choice == "Home":
+        st.title("AUDSOL - AI Automation for Writers")
+        st.write("Welcome to AUDSOL, your AI-powered writing assistant!")
+        
+        st.header("Unlock Your Writing Potential with AI")
+        st.write("""
+        AUDSOL is designed to revolutionize your writing process and help you generate thousands of dollars per month through KDP self-publishing. Our AI-powered tools streamline your workflow, boost creativity, and enhance your productivity.
+        """)
+        
+        st.subheader("Key Features:")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("""
+            - **AI Character Creation**: Bring your characters to life with unique voices and personalities.
+            - **Interactive Character Chats**: Develop your characters through dynamic conversations.
+            - **Automated Book Generation**: Create full-length books with AI assistance.
+            - **Audiobook Conversion**: Transform your text into professional audiobooks.
+            """)
+        
+        with col2:
+            st.markdown("""
+            - **Book Outline Generator**: Craft detailed outlines for your next bestseller.
+            - **Character Development Workshop**: Deep dive into character creation and evolution.
+            - **Writing Prompts Generator**: Spark your creativity with AI-generated prompts.
+            - **Multi-format Export**: Save your work in TXT, DOCX, and PDF formats.
+            """)
+        
+        st.header("How AUDSOL Boosts Your KDP Earnings")
+        st.write("""
+        1. **Rapid Content Creation**: Generate high-quality books faster than ever before.
+        2. **Diverse Genre Expertise**: Our AI adapts to any genre, helping you tap into lucrative markets.
+        3. **Consistent Output**: Maintain a steady publishing schedule to build your author brand.
+        4. **Enhanced Quality**: AI-assisted editing and character development improve your storytelling.
+        5. **Audiobook Integration**: Easily create audiobooks to diversify your income streams.
+        """)
+        
+        st.header("Get Started Today!")
+        st.write("""
+        Explore our features using the sidebar menu and start transforming your writing career. With AUDSOL, you're not just writing—you're crafting your path to financial success in the world of self-publishing.
+        """)
+    
+    elif choice == "Create Character":
+        st.header("Create a New Character")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_name = st.text_input("Character Name")
+            new_description = st.text_area("Short Character Description (500 chars)", max_chars=500)
+            new_voice_file = st.file_uploader("Upload Voice Sample (MP3)", type=["mp3"])
+        
+        with col2:
+            new_detailed_description = st.text_area("Detailed Character Description")
+            new_image_file = st.file_uploader("Upload Character Image (Optional)", type=["jpg", "png"])
+        
+        if st.button("Create Character") and new_name and new_description and new_voice_file:
+            with st.spinner("Creating character..."):
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+                    tmp_file.write(new_voice_file.getvalue())
+                    tmp_file_path = tmp_file.name
+                create_character(new_name, new_description, tmp_file_path, new_image_file)
+                os.unlink(tmp_file_path)
+                st.success(f"Character '{new_name}' created successfully!")
+    
+    elif choice == "Chat with Characters":
+        st.header("Chat with Characters")
+    
+        if 'messages' not in st.session_state:
+            st.session_state.messages = []
+    
+        if 'audio_transcription' not in st.session_state:
+            st.session_state.audio_transcription = None
+    
+        if 'voice_input_stage' not in st.session_state:
+            st.session_state.voice_input_stage = 'ready'
+    
+        if 'audio_bytes' not in st.session_state:
+            st.session_state.audio_bytes = None
+    
+        col1, col2 = st.columns([1, 3])
+    
+        with col1:
+            st.subheader("Characters")
+            for character in st.session_state.characters:
+                if st.button(character, key=f"btn_{character}"):
+                    st.session_state.current_character = character
+                    st.session_state.messages = []
+                    st.session_state.audio_transcription = None
+                    st.session_state.voice_input_stage = 'ready'
+                    st.session_state.audio_bytes = None
+    
+        with col2:
+            if 'current_character' in st.session_state and st.session_state.current_character in st.session_state.characters:
+                current_char = st.session_state.characters[st.session_state.current_character]
+                st.subheader(f"Chatting with {st.session_state.current_character}")
+                if "image" in current_char and current_char["image"]:
+                    st.image(current_char["image"], width=200)
+    
+                # Display chat history
+                for message in st.session_state.messages:
+                    with st.chat_message(message["role"]):
+                        st.write(message["content"])
+                        if "audio" in message:
+                            st.audio(message["audio"])
+    
+                language = st.selectbox("Select Language", ["English", "Spanish", "French", "German", "Chinese", "Japanese"])
+                input_method = st.radio("Choose input method:", ("Text", "Voice"))
+    
+                user_input = None
+                if input_method == "Text":
+                    user_input = st.chat_input("Type your message here...")
+                else:
+                    st.write("Voice Input Process:")
+                    
+                    if st.session_state.voice_input_stage == 'ready':
+                        if st.button("Start Recording"):
+                            st.session_state.voice_input_stage = 'recording'
+                            st.experimental_rerun()
+    
+                    elif st.session_state.voice_input_stage == 'recording':
+                        st.write("Recording... Click 'Stop Recording' when finished.")
+                        audio_bytes = audio_recorder(key="voice_recorder", icon_size="2x")
+                        if audio_bytes:
+                            st.session_state.audio_bytes = audio_bytes
+                        if st.button("Stop Recording"):
+                            if st.session_state.audio_bytes:
+                                st.session_state.voice_input_stage = 'transcribing'
+                                st.experimental_rerun()
+                            else:
+                                st.warning("No audio recorded. Please try again.")
+                                st.session_state.voice_input_stage = 'ready'
+    
+                    elif st.session_state.voice_input_stage == 'transcribing':
+                        st.write("Transcribing audio...")
+                        with st.spinner("Processing..."):
+                            if st.session_state.audio_bytes:
+                                with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+                                    tmp_file.write(st.session_state.audio_bytes)
+                                    tmp_file_path = tmp_file.name
+    
+                                recognizer = sr.Recognizer()
+                                with sr.AudioFile(tmp_file_path) as source:
+                                    audio_data = recognizer.record(source)
+    
+                                try:
+                                    transcription = recognizer.recognize_google(audio_data)
+                                    st.session_state.audio_transcription = transcription
+                                    user_input = transcription
+                                except sr.UnknownValueError:
+                                    st.warning("Speech recognition could not understand the audio. Please try again.")
+                                    st.session_state.voice_input_stage = 'ready'
+                                except sr.RequestError as e:
+                                    st.error(f"Could not request results from speech recognition service. Please check your internet connection and try again. Error: {e}")
+                                    st.session_state.voice_input_stage = 'ready'
+    
+                                os.unlink(tmp_file_path)
+                            else:
+                                st.error("No audio data available. Please record your message again.")
+                                st.session_state.voice_input_stage = 'ready'
+    
+                if user_input:
+                    # Add user message to chat history
+                    st.session_state.messages.append({"role": "user", "content": user_input})
+                    
+                    # Display user message
+                    with st.chat_message("user"):
+                        st.write(user_input)
+                    
+                    with st.spinner("Generating response..."):
+                        ai_response = generate_ai_response(st.session_state.current_character, user_input, language)
+                        audio = text_to_speech(ai_response, current_char["voice_id"])
+    
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+                        save(audio, tmp_file.name)
+                        audio_path = tmp_file.name
+    
+                    # Add AI response to chat history
+                    st.session_state.messages.append({
+                        "role": "assistant", 
+                        "content": ai_response, 
+                        "audio": audio_path
+                    })
+    
+                    # Display AI response
+                    with st.chat_message("assistant"):
+                        st.write(ai_response)
+                        st.audio(audio_path)
+    
+                    # Reset for next interaction
+                    st.session_state.audio_transcription = None
+                    st.session_state.audio_bytes = None
+                    st.session_state.voice_input_stage = 'ready'
+                    st.experimental_rerun()
+    
+            else:
+                st.info("Please select a character to start chatting.")
+    
+    elif choice == "Generate Book":
+        st.header("Generate a Book")
+        
+        genre_type = st.radio("Choose genre type:", ("Fiction", "Non-fiction"))
+        
+        if genre_type == "Fiction":
+            genre = st.selectbox("Select Fiction Genre", fiction_genres)
+        else:
+            genre = st.selectbox("Select Non-fiction Genre", non_fiction_genres)
+        
+        title = st.text_input("Book Title")
+        author = st.text_input("Author Name")
+        description = st.text_area("Book Description")
+        
+        num_chapters = st.number_input("Number of Chapters", min_value=1, value=5)
+        
+        chapters = []
+        for i in range(num_chapters):
+            st.subheader(f"Chapter {i+1}")
+            chapter_name = st.text_input(f"Chapter {i+1} Name")
+            if genre_type == "Fiction":
+                num_scenes = st.number_input(f"Number of Scenes in Chapter {i+1}", min_value=1, value=3)
+                scenes = []
+                for j in range(num_scenes):
+                    scene_description = st.text_area(f"Scene {j+1} Description (Chapter {i+1})")
+                    scenes.append(scene_description)
+                chapters.append({"name": chapter_name, "scenes": scenes})
+            else:
+                chapter_description = st.text_area(f"Chapter {i+1} Description")
+                num_parts = st.number_input(f"Number of Parts in Chapter {i+1}", min_value=1, value=3)
+                parts = []
+                for j in range(num_parts):
+                    part_description = st.text_area(f"Part {j+1} Description (Chapter {i+1})")
+                    parts.append(part_description)
+                chapters.append({"name": chapter_name, "description": chapter_description, "parts": parts})
+        
+        if st.button("Generate Book"):
+            book_details = {
+                "genre_type": genre_type,
+                "genre": genre,
+                "title": title,
+                "author": author,
+                "description": description,
+                "chapters": chapters
+            }
+            
+            st.session_state.book_details = book_details
+            st.session_state.generated_book = ""
+            
+            with st.spinner("Generating book introduction..."):
+                introduction = generate_book_introduction(book_details)
+                st.session_state.generated_book += f"# {title}\nBy {author}\n\n{introduction}\n\n"
+            
+            toc = generate_table_of_contents(book_details)
+            st.session_state.generated_book += f"{toc}\n\n"
+            
+            for i, chapter in enumerate(chapters):
+                with st.spinner(f"Generating Chapter {i+1}: {chapter['name']}..."):
+                    chapter_content = generate_book_chapter(book_details, i)
+                    st.session_state.generated_book += f"# Chapter {i+1}: {chapter['name']}\n\n{chapter_content}\n\n"
+                st.success(f"Chapter {i+1} generated successfully!")
+            
+            st.success("Book generated successfully!")
+            st.text_area("Generated Book", st.session_state.generated_book, height=300)
+            
+            save_book_formats(st.session_state.generated_book, title)
+            
+            st.download_button(
+                label="Download as TXT",
+                data=st.session_state.generated_book,
+                file_name=f"{title}.txt",
+                mime="text/plain"
+            )
+            
+            with open(f"{title}.docx", "rb") as docx_file:
+                st.download_button(
+                    label="Download as DOCX",
+                    data=docx_file,
+                    file_name=f"{title}.docx",
+                    mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                )
+            
+            with open(f"{title}.pdf", "rb") as pdf_file:
+                st.download_button(
+                    label="Download as PDF",
+                    data=pdf_file,
+                    file_name=f"{title}.pdf",
+                    mime="application/pdf"
+                )
+
+    elif choice == "Convert to Audiobook":
+        st.header("Convert to Audiobook")
+        st.write("Transform your written work into an engaging audiobook.")
+    
+        col1, col2 = st.columns([2, 1])
+    
+        with col1:
+            upload_type = st.radio("Choose input method:", ("Upload File", "Paste Text"), horizontal=True)
+    
+            if upload_type == "Upload File":
+                uploaded_file = st.file_uploader("Upload your book file", type=['txt', 'pdf', 'doc', 'docx'])
+                if uploaded_file:
+                    with st.spinner("Extracting text from file..."):
+                        text = extract_text_from_file(uploaded_file)
+                    st.success("Text extracted successfully!")
+            else:
+                text = st.text_area("Enter your book text here", height=300, placeholder="Paste your book content here...")
+    
+            if 'text' in locals() and text:
+                st.write("Preview:")
+                st.info(text[:500] + "..." if len(text) > 500 else text)
+    
+        with col2:
+            st.subheader("Audiobook Settings")
+            language = st.selectbox("Language", ["English", "Spanish", "French", "German", "Chinese", "Japanese"])
+    
+            voice_option = st.radio("Voice Option:", ("Predefined", "Clone Your Voice"))
+    
+            if voice_option == "Predefined":
+                available_voices = [
+                    ("21m00Tcm4TlvDq8ikWAM", "Rachel"),
+                    ("2EiwWnXFnvU5JabPnv8n", "Domi"),
+                    ("AZnzlk1XvdvUeBnXmlld", "Bella"),
+                    ("EXAVITQu4vr4xnSDxMaL", "Antoni"),
+                    ("ErXwobaYiN019PkySvjV", "Elli"),
+                    ("MF3mGyEYCl7XYWbV9V6O", "Adam"),
+                    ("TxGEqnHWrfWFTfGW9XjX", "Sam"),
+                    ("VR6AewLTigWG4xSOukaG", "Josh"),
+                    ("pNInz6obpgDQGcFmaJgB", "Arnold"),
+                    ("yoZ06aMxZJJ28mfd3POQ", "Emma"),
+                    ("ZQe5CZNOzWyzPSCn5a3c", "Ava"),
+                    ("jBpfuIE2acCO8z3wKNLl", "Bella"),
+                    ("onwK4e9ZLuTAKqWW03F9", "Dorothy"),
+                    ("g5CIjZEefAph4nQFvHAz", "Josh"),
+                    ("wViXBPUzp2ZZixB1xQuM", "Arnold"),
+                    ("zrHiDhphv9ZnVXBqCLjz", "Charlotte"),
+                    ("t0jbNlBVZ17f02VDIeMI", "Matilda"),
+                    ("piTKgcLEGmPE4e6mEKli", "Matthew"),
+                    ("RErgWrLnpU47n1wBUr3G", "James"),
+                    ("N2lVS1w4EtoT3dr4eOWO", "Joseph"),
+                    ("ODq5zmih8GrVes37Dizd", "Jeremy"),
+                    ("SOYHLrjzK2X1ezoPC6cr", "Michael"),
+                    ("TX3LPaxmHKxFdv7VOQHJ", "Robert"),
+                    ("flq6f7yk4E4fJM5XTYNq", "Olivia"),
+                    ("z9fAnlkpzviPz146aGWa", "Sophia"),
+                    ("3KehXGbKd6Gu5T9fjnVK", "Ethan"),
+                    ("IKne3meq5aSn9XLyUdCD", "Charlie"),
+                    ("LcfcDJNUP1GQjkzn1xUU", "Amelia"),
+                    ("G4i3RVLNXz6PiE5QAgCu", "Lily"),
+                    ("XB0fDUnXU5powFXDhCwa", "Jackson"),
+                    ("xVe4PmtsSGVPkKo5V1gB", "Chloe"),
+                    ("YD5YTsM3TLX99VqWelFo", "Madison"),
+                    ("jsCqWAovK2LkecY7zXl4", "Ryan"),
+                    ("oWAxZDx7w5VEj9dCyTzz", "Luna"),
+                    ("1vXVqeHAitMxEfPe88RV", "Maverick"),
+                    ("2eGXxRfOxHPE1ZPCIzNv", "Zoe"),
+                    ("tL2Ybu6R2XEfqotJ1UWp", "Thomas"),
+                    ("XrExE9yKIg1WjnnlVkGX", "Scarlett"),
+                    ("Yko7PKHZNXotIFUBG7I9", "Daniel"),
+                    ("R2wc5f0yV8dVe4Y24eDC", "Hannah"),
+                    ("qNAGtHKepPLQO6GXVImS", "Liam"),
+                    ("h0ZXKKEOGPMlAb7yFQf0", "Isabella"),
+                    ("Jb5FM5xWS8mhCk0DHjmx", "Grace"),
+                    ("pOnD5fLH3IhEBY5YOHP4", "Noah"),
+                    ("r5U4RGJuA4kh2Umi8P3J", "Oliver"),
+                    ("x8GtTQIVJ5dxmYN4vffj", "Emily"),
+                    ("j9FdgHYQX3nG7qjc9VVG", "Sophie"),
+                    ("C8lN8YDucvTvl6yKiokH", "William"),
+                    ("JM6niiVGNJTotuzPD5kd", "Evelyn"),
+                    ("7JrRqOwEPGAznN7Uf8hU", "Benjamin")
+                ]
+                
+                selected_voice = st.selectbox(
+                    "Select a voice",
+                    options=available_voices,
+                    format_func=lambda x: f"{x[1]} (ID: {x[0]})"
+                )
+                
+                if selected_voice:
+                    voice_id, voice_name = selected_voice
+                    st.write(f"Selected Voice: {voice_name}")
+                    st.write(f"Voice ID: {voice_id}")
+            else:
+                voice_sample = st.file_uploader("Upload your voice sample (MP3)", type=["mp3"])
+                if voice_sample:
+                    with st.spinner("Cloning voice..."):
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+                            tmp_file.write(voice_sample.getvalue())
+                            tmp_file_path = tmp_file.name
+                        
+                        cloned_voice = elevenlabs_client.clone(
+                            name="Custom Voice",
+                            description="Custom cloned voice",
+                            files=[tmp_file_path]
+                        )
+                        # No need to unlink here; we will do it later
+                    voice_id = cloned_voice.voice_id
+                    st.success("Voice cloned successfully!")
+    
+            speed = st.slider("Narration Speed", min_value=0.5, max_value=2.0, value=1.0, step=0.1)
+    
+        if st.button("Convert to Audiobook", type="primary"):
+            if 'text' in locals() and text and 'voice_id' in locals():
+                chunks = split_text(text)
+                total_chunks = len(chunks)
+
+                headers = {
+                    "Accept": "audio/mpeg",
+                    "Content-Type": "application/json",
+                    "xi-api-key": XI_API_KEY
+                }
+
+                all_audio_data = BytesIO()
+
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+
+                for i, chunk in enumerate(chunks, 1):
+                    status_text.text(f"Converting chunk {i}/{total_chunks}...")
+                    try:
+                        audio_content = generate_audio_chunk(chunk, voice_id, headers)
+                        all_audio_data.write(audio_content)
+                        progress_bar.progress(i / total_chunks)
+                    except Exception as e:
+                        st.error(f"Error processing chunk {i}: {str(e)}")
+                        break
+                    
+                if all_audio_data.tell() > 0:
+                    all_audio_data.seek(0)
+                    st.success("Audiobook created successfully!")
+                    st.audio(all_audio_data, format='audio/mp3')
+
+                    st.download_button(
+                        label="Download Complete Audiobook",
+                        data=all_audio_data,
+                        file_name="complete_audiobook.mp3",
+                        mime="audio/mpeg",
+                        key="download_complete_audiobook"
+                    )
+                else:
+                    st.error("Failed to generate the complete audiobook.")
+            else:
+                st.warning("Please provide text and select a voice before converting.")
+
+    # New feature: Book Outline Generator
+    elif choice == "Book Outline Generator":
+        st.header("Detailed Book Outline Generator")
+        st.write("Create a comprehensive, chapter-by-chapter outline for your next bestseller.")
+
+        col1, col2 = st.columns([2, 1])
+
+        with col1:
+            title = st.text_input("Book Title", placeholder="Enter your book title")
+            main_idea = st.text_area("Main Idea or Concept", placeholder="Describe the central theme or concept of your book in detail", height=150)
+            target_audience = st.text_input("Target Audience", placeholder="Who is your book for? Be specific about demographics, interests, etc.")
+            key_themes = st.text_area("Key Themes or Topics", placeholder="List the main themes or topics you want to cover in your book", height=100)
+
+        with col2:
+            genre_type = st.radio("Genre Type:", ("Fiction", "Non-fiction"))
+            if genre_type == "Fiction":
+                genre = st.selectbox("Fiction Genre", fiction_genres)
+                protagonist = st.text_input("Protagonist", placeholder="Describe your main character")
+                setting = st.text_input("Setting", placeholder="Where and when does your story take place?")
+            else:
+                genre = st.selectbox("Non-fiction Genre", non_fiction_genres)
+                expertise_level = st.select_slider("Reader's Expertise Level", options=["Beginner", "Intermediate", "Advanced", "Expert"])
+
+            desired_length = st.number_input("Estimated Word Count", min_value=10000, value=80000, step=5000, help="Approximate length of your book")
+            num_chapters = st.number_input("Number of Chapters", min_value=5, max_value=50, value=15)
+
+        if st.button("Generate Detailed Outline", type="primary"):
+            if title and main_idea and target_audience and genre and key_themes:
+                with st.spinner("Crafting your comprehensive book outline..."):
+                    if genre_type == "Fiction":
+                        outline_prompt = f"""Generate an extremely detailed book outline for a {genre} novel titled '{title}'. 
+                        Main idea: {main_idea}
+                        Target audience: {target_audience}
+                        Key themes: {key_themes}
+                        Protagonist: {protagonist}
+                        Setting: {setting}
+                        Estimated length: {desired_length} words
+                        Number of chapters: {num_chapters}
+
+                        For each chapter, provide:
+                        1. A compelling chapter title
+                        2. A detailed synopsis (200-300 words)
+                        3. Key plot points or events
+                        4. Character development and interactions
+                        5. Setting details and atmosphere
+                        6. Themes explored in the chapter
+                        7. Any foreshadowing or plot twists
+                        8. Estimated word count for the chapter
+
+                        Additionally, include:
+                        - An engaging prologue idea
+                        - A captivating epilogue concept
+                        - Suggestions for potential subplots
+                        - Ideas for symbolic elements or motifs throughout the book
+
+                        Make the outline as comprehensive and detailed as possible, using the maximum available tokens."""
+                    else:
+                        outline_prompt = f"""Generate an extremely detailed book outline for a {genre} non-fiction book titled '{title}'. 
+                        Main idea: {main_idea}
+                        Target audience: {target_audience} (Expertise level: {expertise_level})
+                        Key themes or topics: {key_themes}
+                        Estimated length: {desired_length} words
+                        Number of chapters: {num_chapters}
+
+                        For each chapter, provide:
+                        1. An informative chapter title
+                        2. A detailed chapter summary (200-300 words)
+                        3. Main concepts or arguments presented
+                        4. Supporting evidence, data, or examples to include
+                        5. Potential expert quotes or case studies to research
+                        6. Practical applications or exercises for readers
+                        7. Key takeaways from the chapter
+                        8. Estimated word count for the chapter
+
+                        Additionally, include:
+                        - An attention-grabbing introduction outline
+                        - A powerful conclusion and call-to-action outline
+                        - Ideas for sidebars, infographics, or illustrations
+                        - Suggestions for further reading or resources
+
+                        Make the outline as comprehensive and detailed as possible, using the maximum available tokens."""
+
+                    outline = together_client.chat.completions.create(
+                        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                        messages=[
+                            {"role": "system", "content": "You are a professional book outliner and developmental editor with extensive experience in creating detailed, chapter-by-chapter outlines for bestselling books across various genres."},
+                            {"role": "user", "content": outline_prompt}
+                        ],
+                        max_tokens=30000,  # Increased to maximum allowed
+                        temperature=0.7
+                    )
+
+                    st.session_state.book_outline = outline.choices[0].message.content
+
+                st.success("Comprehensive book outline generated successfully!")
+
+                # Display the outline in a structured and visually appealing way
+                st.subheader("Your Detailed Book Outline")
+                outline_lines = st.session_state.book_outline.split('\n')
+                chapter_count = 0
+                for line in outline_lines:
+                    if line.strip().startswith('Chapter'):
+                        chapter_count += 1
+                        st.markdown(f"<h3 style='color: #1e90ff;'>{line.strip()}</h3>", unsafe_allow_html=True)
+                    elif any(section in line for section in ['Synopsis:', 'Summary:', 'Plot Points:', 'Main Concepts:', 'Character Development:', 'Supporting Evidence:', 'Setting:', 'Practical Applications:', 'Themes:', 'Key Takeaways:', 'Foreshadowing:', 'Estimated Word Count:']):
+                        st.markdown(f"<h4 style='color: #32cd32;'>{line.strip()}</h4>", unsafe_allow_html=True)
+                    else:
+                        st.write(line.strip())
+
+                st.info(f"Total Chapters: {chapter_count}")
+
+                st.download_button(
+                    label="Download Detailed Outline",
+                    data=st.session_state.book_outline,
+                    file_name=f"{title.replace(' ', '_').lower()}_detailed_outline.txt",
+                    mime="text/plain",
+                    key="download_detailed_outline"
+                )
+            else:
+                st.warning("Please fill in all the required fields to generate a detailed outline.")
+
+    # New feature: Character Development Workshop
+    elif choice == "Character Development Workshop":
+        st.header("Character Development Workshop")
+        st.write("Bring your characters to life with our in-depth development tools.")
+
+        col1, col2 = st.columns([1, 1])
+
+        with col1:
+            character_name = st.text_input("Character Name", placeholder="Enter character's name")
+            character_role = st.selectbox("Character Role", ["Protagonist", "Antagonist", "Supporting Character", "Mentor", "Love Interest", "Sidekick"])
+            character_age = st.number_input("Age", min_value=0, max_value=250, value=30)
+            character_occupation = st.text_input("Occupation", placeholder="Character's job or main activity")
+
+        with col2:
+            character_background = st.text_area("Background", placeholder="Brief history or backstory", height=100)
+            character_goals = st.text_area("Goals", placeholder="What does the character want to achieve?", height=80)
+            character_fears = st.text_area("Fears or Weaknesses", placeholder="What holds the character back?", height=80)
+
+        col3, col4 = st.columns([1, 1])
+
+        with col3:
+            physical_attributes = st.text_area("Physical Attributes", placeholder="Describe appearance, mannerisms, etc.", height=100)
+
+        with col4:
+            personality_traits = st.text_area("Personality Traits", placeholder="List key personality characteristics", height=100)
+
+        if st.button("Develop Character", type="primary"):
+            if character_name and character_role and character_background:
+                with st.spinner("Crafting your character profile..."):
+                    character_prompt = f"""
+                    Create a detailed character profile for {character_name}:
+                    - Age: {character_age}
+                    - Occupation: {character_occupation}
+                    - Role: {character_role}
+                    - Background: {character_background}
+                    - Goals: {character_goals}
+                    - Fears/Weaknesses: {character_fears}
+                    - Physical Attributes: {physical_attributes}
+                    - Personality Traits: {personality_traits}
+
+                    Expand on these details to create a rich, multi-dimensional character. Include potential character arc, quirks, and how they might interact with other characters or drive the plot forward.
+                    """
+
+                    character_profile = together_client.chat.completions.create(
+                        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                        messages=[
+                            {"role": "system", "content": "You are a professional character developer for novels and screenplays, skilled in creating complex, believable characters."},
+                            {"role": "user", "content": character_prompt}
+                        ],
+                        max_tokens=6500,
+                        temperature=0.7
+                    )
+
+                    st.session_state.character_profile = character_profile.choices[0].message.content
+
+                st.success("Character profile developed successfully!")
+
+                # Display the character profile in a more structured way
+                st.subheader(f"{character_name}'s Character Profile")
+                profile_lines = st.session_state.character_profile.split('\n')
+                for line in profile_lines:
+                    if ':' in line:
+                        key, value = line.split(':', 1)
+                        st.markdown(f"**{key.strip()}:** {value.strip()}")
+                    else:
+                        st.write(line.strip())
+
+                st.download_button(
+                    label="Download Character Profile",
+                    data=st.session_state.character_profile,
+                    file_name=f"{character_name.replace(' ', '_').lower()}_profile.txt",
+                    mime="text/plain",
+                    key="download_character_profile"
+                )
+            else:
+                st.warning("Please fill in at least the character's name, role, and background to generate a profile.")
+
+    # New feature: Writing Prompts Generator
+    elif choice == "Writing Prompts Generator":
+        st.header("Writing Prompts Generator")
+        st.write("Spark your creativity with custom writing prompts.")
+
+        col1, col2 = st.columns([1, 1])
+
+        with col1:
+            prompt_type = st.selectbox("Prompt Type", ["General", "Sci-Fi", "Fantasy", "Romance", "Mystery", "Historical", "Horror", "Thriller"])
+            prompt_length = st.slider("Prompt Complexity", min_value=1, max_value=5, value=3, help="1: Simple, 5: Elaborate")
+
+        with col2:
+            specific_elements = st.multiselect("Include Specific Elements", ["Character", "Setting", "Conflict", "Theme", "Plot Twist"])
+            writing_style = st.selectbox("Writing Style", ["Any", "Descriptive", "Dialogue-heavy", "Action-packed", "Introspective", "Humorous"])
+
+        mood = st.select_slider("Mood", options=["Dark", "Neutral", "Light"], value="Neutral")
+
+        if st.button("Generate Writing Prompt", type="primary"):
+            with st.spinner("Crafting your writing prompt..."):
+                prompt_request = f"""
+                Generate a {prompt_type.lower()} writing prompt.
+                Complexity: {prompt_length}/5
+                Include these elements: {', '.join(specific_elements)}
+                Writing style: {writing_style}
+                Mood: {mood}
+
+                The prompt should inspire a short story or scene that a writer can immediately start working on.
+                """
+
+                generated_prompt = together_client.chat.completions.create(
+                    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+                    messages=[
+                        {"role": "system", "content": "You are a creative writing prompt generator, skilled in crafting inspiring and thought-provoking prompts for writers."},
+                        {"role": "user", "content": prompt_request}
+                    ],
+                    max_tokens=1024,
+                    temperature=0.9
+                )
+
+                st.session_state.writing_prompt = generated_prompt.choices[0].message.content
+
+            st.success("Writing prompt generated successfully!")
+
+            # Display the writing prompt in an attractive format
+            st.markdown("### Your Writing Prompt")
+            st.info(st.session_state.writing_prompt)
+
+            col3, col4 = st.columns([1, 1])
+            with col3:
+                if st.button("Generate Another Prompt"):
+                    st.experimental_rerun()
+            with col4:
+                st.download_button(
+                    label="Save Prompt",
+                    data=st.session_state.writing_prompt,
+                    file_name="writing_prompt.txt",
+                    mime="text/plain",
+                    key="save_writing_prompt"
+                )
+
+    elif choice == "Interactive Character Board":
+        st.header("Interactive Character Board")
+    
+        # Initialize session state variables
+        if "character_board" not in st.session_state:
+            st.session_state.character_board = []
+        if "custom_stats" not in st.session_state:
+            st.session_state.custom_stats = ["Intelligence", "Strength", "Speed", "Durability", "Energy Projection", "Fighting Skills"]
+
+        # Character creation form
+        st.subheader("Add New Character")
+        with st.form("character_form"):
+            new_name = st.text_input("Character Name")
+            new_description = st.text_area("Character Description", max_chars=1000)
+            new_image = st.file_uploader("Character Image", type=["jpg", "png", "jpeg"])
+
+            st.subheader("Character Stats")
+            stats = {}
+            for stat in st.session_state.custom_stats:
+                stats[stat] = st.slider(f"{stat}", 0, 10, 5)
+
+            background = st.text_area("Character Background")
+            abilities = st.text_area("Special Abilities")
+            weaknesses = st.text_area("Weaknesses")
+            relationships = st.text_area("Relationships")
+            additional_info = st.text_area("Additional Information")
+
+            submit_button = st.form_submit_button("Add Character")
+
+        if submit_button:
+            if new_name and new_description:
+                character_data = {
+                    "name": new_name,
+                    "description": new_description,
+                    "stats": stats,
+                    "background": background,
+                    "abilities": abilities,
+                    "weaknesses": weaknesses,
+                    "relationships": relationships,
+                    "additional_info": additional_info,
+                }
+
+                if new_image:
+                    image = Image.open(new_image)
+                    img_byte_arr = io.BytesIO()
+                    image.save(img_byte_arr, format='PNG')
+                    character_data["image"] = img_byte_arr.getvalue()
+
+                st.session_state.character_board.append(character_data)
+
+                if new_stat and new_stat not in st.session_state.custom_stats:
+                    st.session_state.custom_stats.append(new_stat)
+
+                st.success(f"Character '{new_name}' added successfully!")
+            else:
+                st.warning("Please provide at least a name and description for the character.")
+
+        # Stat management
+        with st.expander("Manage Stats"):
+            st.subheader("Current Stats")
+            for stat in st.session_state.custom_stats:
+                col1, col2 = st.columns([3, 1])
+                col1.write(stat)
+                if col2.button("Remove", key=f"remove_{stat}"):
+                    st.session_state.custom_stats.remove(stat)
+                    st.experimental_rerun()
+
+            new_stat = st.text_input("Add New Stat")
+            if st.button("Add Stat"):
+                if new_stat and new_stat not in st.session_state.custom_stats:
+                    st.session_state.custom_stats.append(new_stat)
+                    st.experimental_rerun()
+                else:
+                    st.warning("Stat already exists or is empty.")
+
+        # Display character cards
+        st.subheader("Character Cards")
+        if st.session_state.character_board:
+            for idx, character in enumerate(st.session_state.character_board):
+                with st.expander(character["name"], expanded=True):
+                    col1, col2 = st.columns([1, 1])
+                    with col1:
+                        if "image" in character:
+                            st.image(character["image"], use_column_width=True)
+                        st.write(f"**Description:** {character['description']}")
+                        st.write(f"**Background:** {character['background']}")
+                        st.write(f"**Special Abilities:** {character['abilities']}")
+                        st.write(f"**Weaknesses:** {character['weaknesses']}")
+                        st.write(f"**Relationships:** {character['relationships']}")
+                        if character["additional_info"]:
+                            st.write(f"**Additional Info:** {character['additional_info']}")
+                    with col2:
+                        st.subheader("Character Stats")
+                        fig = create_radar_chart(character["stats"])
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    if st.button(f"Delete {character['name']}", key=f"delete_{idx}"):
+                        st.session_state.character_board.pop(idx)
+                        st.experimental_rerun()
+        else:
+            st.info("No characters added yet. Use the form above to add characters to the board.")
+
+    elif choice == "Character Arc Visualizer":
+        character_arc_visualizer()
+
+    elif choice == "World-Building Assistant":
+        world_building_assistant()
+
+        # Optional: Add a feature to view saved prompts
+        if st.checkbox("View Saved Prompts"):
+            if "saved_prompts" not in st.session_state:
+                st.session_state.saved_prompts = []
+
+            if st.session_state.writing_prompt and st.button("Add Current Prompt to Saved"):
+                st.session_state.saved_prompts.append(st.session_state.writing_prompt)
+                st.success("Prompt added to saved list!")
+
+            if st.session_state.saved_prompts:
+                for i, prompt in enumerate(st.session_state.saved_prompts):
+                    st.text_area(f"Saved Prompt {i+1}", prompt, height=100, key=f"saved_prompt_{i}")
+            else:
+                st.info("No saved prompts yet. Generate and save some prompts to see them here!")
+
+    # Sidebar for quick access to generated content
+    with st.sidebar:
+        st.header("Quick Access")
+        if "generated_book" in st.session_state:
+            if st.button("View Generated Book"):
+                st.session_state.current_view = "generated_book"
+        if "book_outline" in st.session_state:
+            if st.button("View Book Outline"):
+                st.session_state.current_view = "book_outline"
+        if "character_profile" in st.session_state:
+            if st.button("View Character Profile"):
+                st.session_state.current_view = "character_profile"
+        if "writing_prompt" in st.session_state:
+            if st.button("View Writing Prompt"):
+                st.session_state.current_view = "writing_prompt"
+        if "story_branches" in st.session_state:
+            if st.button("View Interactive Story"):
+                st.session_state.current_view = "interactive_story"
+        if "character_arcs" in st.session_state:
+            if st.button("View Character Arcs"):
+                st.session_state.current_view = "character_arcs"
+        if "world_elements" in st.session_state:
+            if st.button("View World-Building"):
+                st.session_state.current_view = "world_building"
+
+    # Display the selected content in the main area
+    if "current_view" in st.session_state:
+        if st.session_state.current_view == "generated_book":
+            st.header("Generated Book")
+            st.text_area("Book Content", st.session_state.generated_book, height=400)
+        elif st.session_state.current_view == "book_outline":
+            st.header("Book Outline")
+            st.text_area("Outline", st.session_state.book_outline, height=400)
+        elif st.session_state.current_view == "character_profile":
+            st.header("Character Profile")
+            st.text_area("Profile", st.session_state.character_profile, height=400)
+        elif st.session_state.current_view == "writing_prompt":
+            st.header("Writing Prompt")
+            st.text_area("Prompt", st.session_state.writing_prompt, height=200)
+        elif st.session_state.current_view == "character_arcs":
+            character_arc_visualizer()
+        elif st.session_state.current_view == "world_building":
+            world_building_assistant()
+if __name__ == "__main__":
+    main()