Update app.py

app.py

@@ -73,7 +73,6 @@ def get_examples_for_genre(genre):
 def get_enhanced_system_prompt(genre=None):
     """Generate a detailed system prompt with optional genre specification"""
     selected_genre = genre or "fantasy"
-    
     system_message = f"""You are an interactive storyteller creating an immersive {selected_genre} choose-your-own-adventure story.
 For each response:
 1. Provide vivid sensory descriptions of the scene, environment, and characters
@@ -87,90 +86,70 @@ Format your three options as:
 - Option 2: [Complete sentence describing a possible action]
 - Option 3: [Complete sentence describing a possible action]
 Keep responses engaging but concise (200-300 words maximum). If the user's input doesn't clearly indicate a choice, interpret their intent and move the story forward in the most logical direction."""
-    
     return system_message
 
 def create_story_summary(chat_history):
     """Create a concise summary of the story so far if the history gets too long"""
-    if len(chat_history) <= 2:  # Not enough history to summarize
+    if len(chat_history) <= 2:
         return None
     
-    # Extract just the content for summarization
     story_text = ""
     for user_msg, bot_msg in chat_history:
         story_text += f"User: {user_msg}\nStory: {bot_msg}\n\n"
     
-    # Add a summary instruction
     summary_instruction = {
         "role": "system",
         "content": "The conversation history is getting long. Please create a brief summary of the key plot points and character development so far to help maintain context without exceeding token limits."
     }
-    
     return summary_instruction
 
 def respond(message, chat_history, genre=None, use_full_memory=True):
     """Generate a response based on the current message and conversation history"""
-    # Use a more detailed system prompt
     system_message = get_enhanced_system_prompt(genre)
-    
-    # Format history correctly for the API
+
     formatted_history = []
     for user_msg, bot_msg in chat_history:
         formatted_history.append({"role": "user", "content": user_msg})
         formatted_history.append({"role": "assistant", "content": bot_msg})
     
-    # Create proper API messages
     api_messages = [{"role": "system", "content": system_message}]
     
-    # Token management strategy
-    # Option 1: Use full history but potentially hit token limits
     if use_full_memory and formatted_history:
-        # If there's a lot of history, we might need a summary
-        if len(formatted_history) > 20:  # Arbitrary threshold, adjust as needed
+        if len(formatted_history) > 20:  # Arbitrary threshold
             summary_instruction = create_story_summary(chat_history[:len(chat_history)-5])
             if summary_instruction:
                 api_messages.append(summary_instruction)
-            
-            # Add only the most recent exchanges after the summary
             for msg in formatted_history[-10:]:
                 api_messages.append(msg)
         else:
-            # Add all history if it's not too long
             for msg in formatted_history:
                 api_messages.append(msg)
-    # Option 2: Limited history - fallback if full memory is disabled
     else:
-        # Set a larger memory length but still have a limit
-        memory_length = 10  # Increased from 5
+        memory_length = 10
         if formatted_history:
             for msg in formatted_history[-memory_length*2:]:
                 api_messages.append(msg)
     
-    # Add current message
     api_messages.append({"role": "user", "content": message})
     
-    # Special handling for story initialization
     if not chat_history or message.lower() in ["start", "begin", "begin my adventure"]:
-        # Add a specific instruction for starting a new story
         api_messages.append({
             "role": "system", 
-            "content": f"Begin a new {genre or 'fantasy'} adventure with an intriguing opening scene. Introduce the protagonist without assuming too much about them, allowing the user to shape the character."
+            "content": f"Begin a new {genre or 'fantasy'} adventure with an intriguing opening scene. Introduce the protagonist without assuming too much about them."
         })
     
-    # Generate and stream response
     bot_message = ""
     try:
-        for response in client.chat_completion(
+        for response_chunk in client.chat_completion(
             api_messages,
             max_tokens=512,
             stream=True,
             temperature=0.7,
             top_p=0.95,
         ):
-            delta = response.choices[0].delta.content
+            delta = response_chunk.choices[0].delta.content
             if delta:
                 bot_message += delta
-                # Create a new list for the updated chat history
                 new_history = chat_history.copy()
                 new_history.append((message, bot_message))
                 yield new_history
@@ -197,11 +176,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     
     with gr.Row():
         with gr.Column(scale=3):
+            # Chat window + user input
             chatbot = gr.Chatbot(
                 height=500,
                 bubble_full_width=False,
                 show_copy_button=True,
                 avatar_images=(None, "🧙"),
+                type="messages"  # Use OpenAI-style messages
             )
             msg = gr.Textbox(
                 placeholder="Describe what you want to do next in the story...",
@@ -222,62 +203,64 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 value="fantasy"
             )
             
-            # Add a memory toggle option
             full_memory = gr.Checkbox(
                 label="Full Story Memory",
                 value=True,
-                info="When enabled, the AI will try to remember the entire story"
+                info="When enabled, the AI tries to remember the entire story. If disabled, only the last few exchanges are used."
             )
             
-            # Create story starter buttons that automatically submit
             gr.Markdown("## Story Starters")
-            story_starters = []
             
-            def create_example_click_handler(example_text):
-                def example_click():
-                    return example_text
-                return example_click
+            # -- Create four placeholder buttons for story starters --
+            starter_btn1 = gr.Button("Starter 1")
+            starter_btn2 = gr.Button("Starter 2")
+            starter_btn3 = gr.Button("Starter 3")
+            starter_btn4 = gr.Button("Starter 4")
+            starter_buttons = [starter_btn1, starter_btn2, starter_btn3, starter_btn4]
             
-            # Create a start button
-            start_btn = gr.Button("Begin my adventure", variant="secondary")
-            start_btn.click(
-                fn=create_example_click_handler("Begin my adventure"),
-                outputs=[msg],
-                queue=False
-            ).then(
-                fn=respond,
-                inputs=[msg, chatbot, genre, full_memory],
-                outputs=[chatbot]
-            )
+            # Function to update the labels of the 4 starter buttons
+            def update_starter_buttons(selected_genre):
+                # Grab up to 4 examples from the chosen genre
+                examples = get_examples_for_genre(selected_genre)
+                # If there are fewer than 4, fill the rest with placeholders or hide them
+                button_updates = []
+                for i in range(4):
+                    if i < len(examples):
+                        button_updates.append(gr.Button.update(value=examples[i], visible=True))
+                    else:
+                        button_updates.append(gr.Button.update(value="(no starter)", visible=False))
+                return button_updates
+            
+            # Function that populates the msg with the chosen starter text, then calls respond
+            def pick_starter(starter_text, chat_history, selected_genre, memory_flag):
+                # The function returns the text to put in msg
+                # but we also chain the respond function via .then
+                return starter_text
             
-            # Create example buttons for the current genre
-            example_buttons = []
-            for i, example in enumerate(get_examples_for_genre("fantasy")):
-                btn = gr.Button(example, elem_id=f"example_{i}")
-                btn.click(
-                    fn=create_example_click_handler(example),
+            # Hook each starter button:
+            #  1) Put the chosen text into 'msg'
+            #  2) Then call 'respond' to update the chatbot
+            for starter_button in starter_buttons:
+                starter_button.click(
+                    fn=pick_starter,
+                    inputs=[starter_button, chatbot, genre, full_memory],
                     outputs=[msg],
                     queue=False
                 ).then(
                     fn=respond,
                     inputs=[msg, chatbot, genre, full_memory],
-                    outputs=[chatbot]
+                    outputs=[chatbot],
+                    queue=False
                 )
-                example_buttons.append(btn)
-    
-    # Function to update example buttons when genre changes
-    def update_example_buttons(genre):
-        examples = get_examples_for_genre(genre)
-        return [gr.Button.update(value=example) for example in examples[:4]]  # Limit to 4 examples
-    
-    # Connect genre dropdown to update example buttons
-    genre.change(
-        fn=update_example_buttons,
-        inputs=[genre],
-        outputs=example_buttons
-    )
+            
+            # Connect the genre dropdown to update these 4 starter buttons
+            genre.change(
+                fn=update_starter_buttons,
+                inputs=[genre],
+                outputs=starter_buttons
+            )
     
-    # Set up event handlers for the chatbot
+    # -- Chat submission + button events --
     msg.submit(respond, [msg, chatbot, genre, full_memory], [chatbot])
     submit.click(respond, [msg, chatbot, genre, full_memory], [chatbot])
     
@@ -285,13 +268,20 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     clear.click(lambda: [], None, chatbot, queue=False)
     clear.click(lambda: "", None, msg, queue=False)
     
-    # Add a download story button
+    # -- "Download My Story" row --
     with gr.Row():
-        save_btn = gr.Button("Save Story as Markdown", variant="secondary")
+        save_btn = gr.Button("Download My Story", variant="secondary")
         story_output = gr.Markdown(visible=False)
     
+    # "Download My Story" logic
     save_btn.click(save_story, inputs=[chatbot], outputs=[story_output])
-    save_btn.click(lambda: True, None, story_output, js="() => {document.getElementById('story_output').scrollIntoView();}", queue=False)
+    save_btn.click(
+        fn=lambda: True,
+        inputs=None,
+        outputs=story_output,
+        js="() => {document.getElementById('story_output').scrollIntoView();}",
+        queue=False
+    )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)