Update app.py

app.py

@@ -10,11 +10,11 @@ client = InferenceClient("HuggingFaceH4/zephyr-7b-beta", token=hf_token)
 
 # Story genres with genre-specific example prompts
 GENRE_EXAMPLES = {
-    "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"
-        "I step into a clearing where the trees whisper ancient riddles"
+    "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",
+        "I step into a clearing where the trees whisper ancient riddles",
         "A friendly witch invites me into her cozy cottage, offering a warm cup of tea"
     ],
     "fantasy": [
@@ -73,7 +73,7 @@ GENRE_EXAMPLES = {
     ]
 }
 
-# 2. Add constants at the top for magic numbers
+# Constants
 MAX_HISTORY_LENGTH = 20
 MEMORY_WINDOW = 5  # Reduced from 10 to limit context
 MAX_TOKENS = 1024  # Reduced from 2048 for faster responses
@@ -110,33 +110,12 @@ IMPORTANT:
 Keep the story cohesive by referencing previous events and choices."""
     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:
-        return None
-    
-    story_text = ""
-    for user_msg, bot_msg in chat_history:
-        story_text += f"User: {user_msg}\nStory: {bot_msg}\n\n"
-    
-    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 format_history_for_gradio(history_tuples):
-    """Convert chat history to Gradio's message format."""
-    return [(str(user_msg), str(bot_msg)) for user_msg, bot_msg in history_tuples]
-
-# 1. Add type hints for better code maintainability
-# 4. Add input validation
 def respond(
     message: str, 
     chat_history: List[Tuple[str, str]], 
     genre: Optional[str] = None,
     use_full_memory: bool = True
-) -> List[Tuple[str, str]]:  # Changed return type to match Gradio's chatbot format
+) -> List[Tuple[str, str]]:
     """Generate a response based on the current message and conversation history."""
     if not message.strip():
         return chat_history
@@ -148,17 +127,18 @@ def respond(
         # Add chat history in correct format
         if chat_history and use_full_memory:
             for user_msg, bot_msg in chat_history[-MEMORY_WINDOW:]:
-                api_messages.extend([
-                    {"role": "user", "content": str(user_msg)},
-                    {"role": "assistant", "content": str(bot_msg)}
-                ])
+                # Only add completed exchanges (where both user and bot messages exist)
+                if user_msg and bot_msg:
+                    api_messages.append({"role": "user", "content": str(user_msg)})
+                    api_messages.append({"role": "assistant", "content": str(bot_msg)})
         
         # Add current message
         api_messages.append({"role": "user", "content": str(message)})
 
         # Make API call with properly formatted messages
         response = client.chat_completion(
-            messages=api_messages,  # Use formatted messages
+            model="HuggingFaceH4/zephyr-7b-beta",  # Explicitly specify model
+            messages=api_messages,
             max_tokens=MAX_TOKENS,
             temperature=TEMPERATURE,
             top_p=TOP_P
@@ -186,6 +166,7 @@ def save_story(chat_history):
     
     return story_text
 
+# Define the Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🔮 Interactive Story Time")
     with gr.Row():
@@ -196,16 +177,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Column(scale=3):
             # Chat window + user input
             chatbot = gr.Chatbot(
-                height=500,  # Increased height
-                bubble_full_width=True,  # Allow bubbles to use full width
+                height=500,
+                bubble_full_width=True,
                 show_copy_button=True,
                 avatar_images=(None, "🧙"),
                 type="messages",
                 container=True,
                 scale=1,
-                min_width=800,  # Ensure minimum width
-                value=[],  # Initialize with empty list
-                render=True
+                min_width=800,
+                value=[]
             )
             msg = gr.Textbox(
                 placeholder="Describe what you want to do next in the story...",
@@ -240,32 +220,24 @@ 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'
             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
+            # Initialize with default genre
+            initial_button_data = update_starter_buttons("fantasy")
 
-            # 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
-
-            # 4) Connect each starter button:
+            # Connect each starter button
             for starter_button in starter_buttons:
+                # First, update chatbot with starter message
                 starter_button.click(
-                    # Initial click creates empty chat history with starter message
                     fn=lambda x: [(str(x), "")],
                     inputs=[starter_button],
                     outputs=[chatbot],
@@ -274,16 +246,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     # Then process the message with respond function
                     fn=respond,
                     inputs=[
-                        starter_button,  # The starter text
-                        chatbot,         # Current chat history
-                        genre,          # Selected genre
-                        full_memory     # Memory flag
+                        starter_button,
+                        chatbot,
+                        genre,
+                        full_memory
                     ],
                     outputs=chatbot,
                     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],
@@ -312,13 +284,13 @@ 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)
+    # Load initial button data
+    demo.load(
+        fn=lambda: initial_button_data,
+        outputs=starter_buttons,
+        queue=False
+    )
 
 # Run the app
 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)