Update app.py

app.py

@@ -10,7 +10,7 @@ client = InferenceClient("HuggingFaceH4/zephyr-7b-beta", token=hf_token)
 
 # Story genres with genre-specific example prompts
 GENRE_EXAMPLES = {
-    "fairy_tale": [
+    "fairy tale": [
         "I follow the shimmer of fairy dust into a hidden forest"
         "I meet a talking rabbit who claims to know a secret about the king’s lost crown"
         "A tiny dragon appears at my window, asking for help to find its mother"
@@ -136,11 +136,11 @@ def respond(
     chat_history: List[Tuple[str, str]], 
     genre: Optional[str] = None,
     use_full_memory: bool = True
-) -> List[Dict[str, str]]:  # Changed return type
+) -> Tuple[str, List[Tuple[str, str]]]:
     """Generate a response based on the current message and conversation history."""
     if not message.strip():
-        return [{"role": "assistant", "content": "Please provide a message"}]
-
+        return "", chat_history
+    
     try:
         # Format messages for API
         api_messages = [{"role": "system", "content": get_enhanced_system_prompt(genre)}]
@@ -164,12 +164,18 @@ def respond(
             top_p=TOP_P
         )
         
-        # Return properly formatted message
+        # Get response content
         bot_message = response.choices[0].message.content
-        return [{"role": "assistant", "content": str(bot_message)}]
+        
+        # Update chat history with new exchange
+        updated_history = chat_history + [(message, bot_message)]
+        
+        # Return updated components
+        return "", updated_history
                         
     except Exception as e:
-        return [{"role": "assistant", "content": f"Story magic temporarily interrupted. Please try again. (Error: {str(e)})"}]
+        error_msg = f"Story magic temporarily interrupted. Please try again. (Error: {str(e)})"
+        return "", chat_history + [(message, error_msg)]
 
 def save_story(chat_history):
     """Convert chat history to markdown for download"""
@@ -237,50 +243,47 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             starter_btn4 = gr.Button("Starter 4")
             starter_buttons = [starter_btn1, starter_btn2, starter_btn3, starter_btn4]
 
-            # 1) We'll return a list of 4 dicts, each dict updating 'value' & 'visible'
+            # Simplified update function
             def update_starter_buttons(selected_genre):
-                """Update starter buttons with examples for the selected genre."""
                 examples = get_examples_for_genre(selected_genre)
                 results = []
                 for i in range(4):
                     if i < len(examples):
-                        # Return just the string value instead of a dict
                         results.append(examples[i])
                     else:
-                        results.append("")  # Empty string for hidden buttons
-                return tuple(results)  # Return tuple of strings
+                        results.append("")
+                return tuple(results)
 
-            # 2) Initialize them with "fantasy" so they don't stay "Starter X" on page load
-            # We'll just call the function and store the results in a variable, then apply them in a .load() event
-            initial_button_data = update_starter_buttons("fantasy")  # returns 4 dicts
-
-            # 3) We'll define a "pick_starter" function that sets msg to the chosen text
-            def pick_starter(starter_text, chat_history, selected_genre, memory_flag):
-                # Putting 'starter_text' into the msg
-                return starter_text
+            # New direct handler for starter clicks
+            def use_starter(starter_text, history, selected_genre, memory_flag):
+                """Handle starter button clicks with proper message formatting"""
+                if not starter_text:
+                    return "", history
+                
+                try:
+                    # Use the respond function for consistent handling
+                    _, updated_history = respond(
+                        message=starter_text,
+                        chat_history=history,
+                        genre=selected_genre,
+                        use_full_memory=memory_flag
+                    )
+                    return "", updated_history
+                                
+                except Exception as e:
+                    error_msg = f"Story magic temporarily interrupted. Please try again. (Error: {str(e)})"
+                    return "", history + [(starter_text, error_msg)]
 
-            # 4) Connect each starter button:
+            # Simplified button connections
             for starter_button in starter_buttons:
                 starter_button.click(
-                    # Format initial message correctly as ChatMessage
-                    fn=lambda x: [{"role": "user", "content": str(x)}],
-                    inputs=[starter_button],
-                    outputs=[chatbot],
-                    queue=False
-                ).success(
-                    # Then process with properly formatted message
-                    fn=lambda x, h, g, m: respond(
-                        message=x["content"],  # Extract content from ChatMessage
-                        chat_history=h if h else [],
-                        genre=g,
-                        use_full_memory=m
-                    ),
+                    fn=use_starter,
                     inputs=[starter_button, chatbot, genre, full_memory],
-                    outputs=chatbot,
+                    outputs=[msg, chatbot],  # Now returning both message and chat history
                     queue=True
                 )
 
-            # 5) Dynamically update the 4 buttons if the user changes the genre
+            # Update buttons when genre changes
             genre.change(
                 fn=update_starter_buttons,
                 inputs=[genre],
@@ -288,8 +291,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             )
 
     # Handler for user input
-    msg.submit(respond, [msg, chatbot, genre, full_memory], [chatbot])
-    submit.click(respond, [msg, chatbot, genre, full_memory], [chatbot])
+    msg.submit(
+        fn=respond,
+        inputs=[msg, chatbot, genre, full_memory],
+        outputs=[msg, chatbot]  # Now returning both message and chat history
+    )
+    submit.click(
+        fn=respond,
+        inputs=[msg, chatbot, genre, full_memory],
+        outputs=[msg, chatbot]  # Now returning both message and chat history
+    )
     
     # Clear the chatbot for a new adventure
     clear.click(lambda: [], None, chatbot, queue=False)
@@ -309,12 +320,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         queue=False
     )
 
-    # 6) Finally, run a "load" event to apply initial_button_data to the 4 button outputs on page load
-    def load_initial_buttons():
-        # Just return our precomputed tuple of 4 dicts
-        return initial_button_data
-
-    demo.load(fn=load_initial_buttons, outputs=starter_buttons, queue=False)
+    # Initialize buttons with default fantasy genre examples
+    initial_examples = get_examples_for_genre("fantasy")
+    initial_button_data = tuple(
+        initial_examples[i] if i < len(initial_examples) else ""
+        for i in range(4)
+    )
+    
+    # Update button text on page load
+    demo.load(
+        fn=lambda: initial_button_data,
+        outputs=starter_buttons,
+        queue=False
+    )
 
 # Run the app
 if __name__ == "__main__":