Fix Gradio schema error: Use v3.40.1 and simplified interface

app.py

@@ -1,114 +1,115 @@
 import gradio as gr
 import os
 import sys
-import asyncio
 
 # Add backend to path for imports
 backend_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backend')
 sys.path.insert(0, backend_path)
 
 from backend.models.character_manager import CharacterManager
+import asyncio
 
-class RoleplayChatApp:
-    def __init__(self):
-        """Initialize the Roleplay Chat App"""
-        self.character_manager = None
-        
-    def initialize_models(self):
-        """Initialize the character manager synchronously"""
-        try:
-            print("🔄 Initializing character manager...")
-            self.character_manager = CharacterManager()
-            
-            # Use sync initialization
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            loop.run_until_complete(self.character_manager.initialize())
-            loop.close()
-            
-            print("✅ Models loaded successfully!")
-            return "✅ Models loaded successfully!"
-        except Exception as e:
-            print(f"❌ Failed to load models: {str(e)}")
-            return f"❌ Failed to load models: {str(e)}"
+# Global character manager
+character_manager = None
+
+def initialize_models():
+    """Initialize the character manager"""
+    global character_manager
+    if character_manager is None:
+        print("🔄 Initializing character manager...")
+        character_manager = CharacterManager()
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(character_manager.initialize())
+        loop.close()
+        print("✅ Models loaded successfully!")
+
+def chat_with_character(message, character_id, history):
+    """Handle chat with character"""
+    if not message or not message.strip():
+        return history
     
-    def chat_fn(self, message, character_id, history):
-        """Handle chat functionality"""
-        if not message.strip():
-            return history, ""
-        
-        if not self.character_manager:
-            self.initialize_models()
-        
-        try:
-            # Convert history for context
-            conversation_history = []
+    # Initialize if needed
+    if character_manager is None:
+        initialize_models()
+    
+    try:
+        # Convert history for context
+        conversation_history = []
+        if history:
             for user_msg, bot_msg in history[-3:]:
-                conversation_history.append({"role": "user", "content": user_msg})
+                if user_msg:
+                    conversation_history.append({"role": "user", "content": user_msg})
                 if bot_msg:
                     conversation_history.append({"role": "assistant", "content": bot_msg})
-            
-            # Generate response
-            response = self.character_manager.generate_response(
-                character_id=character_id,
-                user_message=message,
-                conversation_history=conversation_history
-            )
-            
-            # Update history
-            history.append((message, response))
-            return history, ""
-            
-        except Exception as e:
-            error_msg = f"❌ Error: {str(e)}"
-            history.append((message, error_msg))
-            return history, ""
+        
+        # Generate response
+        response = character_manager.generate_response(
+            character_id=character_id,
+            user_message=message,
+            conversation_history=conversation_history
+        )
+        
+        # Update history
+        if history is None:
+            history = []
+        history.append((message, response))
+        return history
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        if history is None:
+            history = []
+        history.append((message, error_msg))
+        return history
 
-def create_interface():
-    """Create a simple Gradio interface"""
-    app = RoleplayChatApp()
+# Create simple interface with gr.Interface (most compatible)
+with gr.Blocks(title="🎭 Roleplay Chat Box") as demo:
+    gr.HTML("<h1 style='text-align: center'>🎭 Roleplay Chat Box</h1>")
+    gr.HTML("<p style='text-align: center'>Chat with AI characters!</p>")
     
-    # Simple function-based interface
-    def chat_with_character(message, character, history):
-        return app.chat_fn(message, character, history)
-    
-    def clear_chat():
-        return []
-    
-    # Create simple interface
-    with gr.Blocks() as demo:
-        gr.Markdown("# 🎭 Roleplay Chat Box")
-        gr.Markdown("Chat with AI characters!")
-        
-        # Character selector
-        character_selector = gr.Radio(
-            choices=[
-                "moses", 
-                "samsung_employee", 
-                "jinx"
-            ],
+    with gr.Row():
+        character_dropdown = gr.Dropdown(
+            choices=["moses", "samsung_employee", "jinx"],
             value="moses",
             label="Choose Character"
         )
-        
-        # Chat interface
-        chatbot = gr.Chatbot()
-        msg = gr.Textbox(label="Your Message", placeholder="Type here...")
-        clear = gr.Button("Clear Chat")
-        
-        # Setup interactions
-        msg.submit(
-            chat_with_character, 
-            [msg, character_selector, chatbot], 
-            [chatbot, msg]
+    
+    chatbot = gr.Chatbot(label="Chat")
+    
+    with gr.Row():
+        msg = gr.Textbox(
+            label="Your Message",
+            placeholder="Type your message here...",
+            lines=2
         )
-        
-        clear.click(clear_chat, outputs=chatbot)
     
-    return demo
+    with gr.Row():
+        submit = gr.Button("Send", variant="primary")
+        clear = gr.Button("Clear")
+    
+    # Event handlers
+    submit.click(
+        fn=chat_with_character,
+        inputs=[msg, character_dropdown, chatbot],
+        outputs=chatbot
+    ).then(
+        lambda: "",
+        outputs=msg
+    )
+    
+    msg.submit(
+        fn=chat_with_character,
+        inputs=[msg, character_dropdown, chatbot],
+        outputs=chatbot
+    ).then(
+        lambda: "",
+        outputs=msg
+    )
+    
+    clear.click(lambda: None, outputs=chatbot)
 
 if __name__ == "__main__":
-    demo = create_interface()
     demo.launch(
         share=True,
         server_name="0.0.0.0",

requirements.txt

@@ -7,8 +7,8 @@ datasets>=2.14.0
 huggingface-hub>=0.19.0
 safetensors>=0.4.0
 
-# Gradio for Hugging Face Spaces - pinned to avoid schema errors
-gradio==3.50.2
+# Gradio for Hugging Face Spaces - using ultra-stable version
+gradio==3.40.1
 
 # Backend API
 fastapi>=0.104.0