Update app.py

app.py

@@ -1,4 +1,4 @@
-"""Gradio App for Veda Programming Assistant - Gradio 6.2.0"""
+"""Gradio App for Veda Programming Assistant - Gradio 6.x compatible"""
 
 import gradio as gr
 import tensorflow as tf
@@ -12,45 +12,107 @@ from train import VedaTrainer
 from config import MODEL_DIR
 
 
+# --------- Globals ----------
 model = None
 tokenizer = None
-conversation_history = []
+conversation_history = []  # used for building prompt context for the model
 current_conv_id = -1
 
 
+# --------- Helpers (IMPORTANT FIX) ----------
+def extract_text(message):
+    """
+    Convert Gradio multimodal / messages objects -> plain string.
+    Handles:
+    - str
+    - dict: {"text": "..."} or {"content": "..."}
+    - list of parts: [{"type":"text","text":"..."}]
+    """
+    if message is None:
+        return ""
+    if isinstance(message, str):
+        return message
+
+    if isinstance(message, dict):
+        if "text" in message:
+            return str(message.get("text", ""))
+        if "content" in message:
+            return extract_text(message["content"])
+        return ""
+
+    if isinstance(message, list):
+        parts = []
+        for part in message:
+            if isinstance(part, dict):
+                if part.get("type") == "text":
+                    parts.append(str(part.get("text", "")))
+            elif isinstance(part, str):
+                parts.append(part)
+        return "".join(parts).strip()
+
+    return str(message)
+
+
+def ensure_messages_history(history):
+    """
+    Ensure Chatbot history is ALWAYS messages format:
+    [{"role":"user","content":"..."}, {"role":"assistant","content":"..."}]
+
+    Also converts old tuple format [(user, bot), ...] -> messages.
+    """
+    if history is None:
+        return []
+
+    # Already messages format
+    if len(history) > 0 and isinstance(history[0], dict) and "role" in history[0] and "content" in history[0]:
+        fixed = []
+        for m in history:
+            fixed.append({"role": m["role"], "content": extract_text(m["content"])})
+        return fixed
+
+    # Tuple/pair format -> messages format
+    fixed = []
+    for pair in history:
+        if isinstance(pair, (list, tuple)) and len(pair) == 2:
+            fixed.append({"role": "user", "content": extract_text(pair[0])})
+            fixed.append({"role": "assistant", "content": extract_text(pair[1])})
+    return fixed
+
+
+# --------- Model init ----------
 def initialize():
-    """Initialize the assistant"""
+    """Initialize the assistant (load if exists, else train once)."""
     global model, tokenizer
-    
+
     print("Initializing Veda Programming Assistant...")
-    
+
     config_path = os.path.join(MODEL_DIR, "config.json")
-    
+
     if os.path.exists(config_path):
         print("Loading existing model...")
-        
-        with open(config_path, 'r') as f:
+
+        with open(config_path, "r") as f:
             config = json.load(f)
-        
+
         tokenizer = VedaTokenizer()
         tokenizer.load(os.path.join(MODEL_DIR, "tokenizer.json"))
-        
+
         model = VedaProgrammingLLM(
-            vocab_size=config['vocab_size'],
-            max_length=config['max_length'],
-            d_model=config['d_model'],
-            num_heads=config['num_heads'],
-            num_layers=config['num_layers'],
-            ff_dim=config['ff_dim']
+            vocab_size=config["vocab_size"],
+            max_length=config["max_length"],
+            d_model=config["d_model"],
+            num_heads=config["num_heads"],
+            num_layers=config["num_layers"],
+            ff_dim=config["ff_dim"],
         )
-        
-        dummy = tf.zeros((1, config['max_length']), dtype=tf.int32)
+
+        dummy = tf.zeros((1, config["max_length"]), dtype=tf.int32)
         model(dummy)
         model.load_weights(os.path.join(MODEL_DIR, "weights.h5"))
-        
+
         print("Model loaded!")
     else:
-        print("Training new model...")
+        print("No saved model found. Training a new model...")
         trainer = VedaTrainer()
         trainer.train(epochs=15)
         model = trainer.model
@@ -59,108 +121,112 @@ def initialize():
 
 
 def clean_response(text: str) -> str:
-    """Clean the response"""
+    """Clean the response text for display."""
     text = text.replace("<CODE>", "\n```python\n")
     text = text.replace("<ENDCODE>", "\n```\n")
-    
+
     for token in ["<PAD>", "<UNK>", "<START>", "<END>", "<USER>", "<ASSISTANT>"]:
         text = text.replace(token, "")
-    
-    lines = text.split('\n')
+
+    lines = text.split("\n")
     cleaned = []
     empty_count = 0
-    
+
     for line in lines:
-        if line.strip() == '':
+        if line.strip() == "":
             empty_count += 1
             if empty_count <= 2:
                 cleaned.append(line)
         else:
             empty_count = 0
             cleaned.append(line)
-    
-    return '\n'.join(cleaned).strip()
+
+    return "\n".join(cleaned).strip()
 
 
 def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
-    """Generate a response"""
-    global current_conv_id
-    
+    """Generate a response from the model."""
+    global current_conv_id, conversation_history
+
     if model is None:
         return "Model is loading, please wait..."
-    
-    if not user_input.strip():
+
+    user_input = extract_text(user_input).strip()
+    if not user_input:
         return "Please type a message!"
-    
+
     try:
+        # Build context from last few turns (stored as plain strings)
         context = ""
         for msg in conversation_history[-3:]:
             context += f"<USER> {msg['user']}\n<ASSISTANT> {msg['assistant']}\n"
-        
+
         prompt = context + f"<USER> {user_input}\n<ASSISTANT>"
-        
+
         tokens = tokenizer.encode(prompt)
-        
+
+        # Truncate to leave room for generation
         if len(tokens) > model.max_length - max_tokens:
             tokens = tokens[-(model.max_length - max_tokens):]
-        
+
         generated = model.generate(
             tokens,
             max_new_tokens=max_tokens,
             temperature=temperature,
             top_k=50,
             top_p=0.9,
-            repetition_penalty=1.2
+            repetition_penalty=1.2,
         )
-        
+
         response = tokenizer.decode(generated)
-        
+
+        # Extract assistant portion only
         if "<ASSISTANT>" in response:
-            parts = response.split("<ASSISTANT>")
-            response = parts[-1].strip()
-        
+            response = response.split("<ASSISTANT>")[-1].strip()
         if "<USER>" in response:
             response = response.split("<USER>")[0].strip()
-        
+
         response = clean_response(response)
-        
+
         if not response:
             response = "I'm not sure how to respond to that. Could you try rephrasing?"
-        
-        conversation_history.append({
-            'user': user_input,
-            'assistant': response
-        })
-        
+
+        # Save for future context
+        conversation_history.append({"user": user_input, "assistant": response})
+
+        # Save in DB
         current_conv_id = db.save_conversation(user_input, response)
-        
+
         return response
-        
+
     except Exception as e:
         import traceback
         traceback.print_exc()
         return f"Error: {str(e)}"
 
 
+# --------- Gradio handlers ----------
 def respond(message, history, temperature, max_tokens):
-    """Chat function using messages format for Gradio 6.x"""
-    if not message or not message.strip():
-        return "", history if history else []
-    
-    bot_message = generate_response(message, temperature, max_tokens)
-    
-    if history is None:
-        history = []
-    
-    # Gradio 6.x requires messages format
-    new_history = list(history)
-    new_history.append({"role": "user", "content": message})
-    new_history.append({"role": "assistant", "content": bot_message})
-    
-    return "", new_history
+    """
+    Chat function for Gradio Chatbot.
+    IMPORTANT: Always return messages-format history.
+    """
+    history = ensure_messages_history(history)
+
+    user_text = extract_text(message).strip()
+    if not user_text:
+        return "", history
+
+    bot_message = generate_response(user_text, temperature, max_tokens)
+
+    history.append({"role": "user", "content": user_text})
+    history.append({"role": "assistant", "content": bot_message})
+
+    return "", history
 
 
 def feedback_good():
+    global current_conv_id
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, 1)
         return "👍 Thanks for the positive feedback!"
@@ -168,6 +234,7 @@ def feedback_good():
 
 
 def feedback_bad():
+    global current_conv_id
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, -1)
         return "👎 Thanks! I'll try to improve."
@@ -181,26 +248,26 @@ def clear_chat():
 
 
 def retrain(epochs):
-    """Retrain with good conversations"""
+    """Retrain with good conversations."""
     global model, tokenizer
-    
+
     good_convs = db.get_good_conversations()
-    
+
     if not good_convs:
         return "No approved conversations yet. Rate some responses as 'Good' first!"
-    
+
     extra_data = ""
     for conv in good_convs:
         extra_data += f"<USER> {conv['user_input']}\n"
         extra_data += f"<ASSISTANT> {conv['assistant_response']}\n\n"
-    
+
     trainer = VedaTrainer()
     history = trainer.train(epochs=int(epochs), extra_data=extra_data)
-    
+
     model = trainer.model
     tokenizer = trainer.tokenizer
-    
-    loss = history.history['loss'][-1]
+
+    loss = history.history["loss"][-1]
     return f"✅ Training complete! Loss: {loss:.4f}, Used {len(good_convs)} conversations"
 
 
@@ -216,81 +283,69 @@ def get_stats():
 """
 
 
-# Initialize model at startup
+# --------- Startup ----------
 print("Starting initialization...")
 initialize()
 print("Initialization complete!")
 
 
-# Create Gradio interface
+# --------- UI ----------
 with gr.Blocks(title="Veda Programming Assistant") as demo:
-    
-    gr.Markdown("""
-    # 🕉️ Veda Programming Assistant
-    
-    I can **chat**, **write code**, **explain concepts**, and **answer questions**!
-    """)
-    
+    gr.Markdown(
+        """
+# 🕉️ Veda Programming Assistant
+
+I can **chat**, **write code**, **explain concepts**, and **answer questions**!
+"""
+    )
+
     with gr.Tabs():
-        
         with gr.TabItem("💬 Chat"):
             chatbot = gr.Chatbot(
                 label="Conversation",
                 height=400,
-                value=[]
+                value=[],
             )
-            
+
             with gr.Row():
                 msg = gr.Textbox(
                     label="Your message",
                     placeholder="Ask me anything about programming...",
                     lines=2,
-                    scale=4
+                    scale=4,
                 )
                 send_btn = gr.Button("Send", variant="primary", scale=1)
-            
+
             with gr.Row():
-                temperature = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.5,
-                    value=0.7,
-                    step=0.1,
-                    label="Creativity"
-                )
-                max_tokens = gr.Slider(
-                    minimum=50,
-                    maximum=400,
-                    value=200,
-                    step=50,
-                    label="Response length"
-                )
-            
+                temperature = gr.Slider(0.1, 1.5, 0.7, step=0.1, label="Creativity")
+                max_tokens = gr.Slider(50, 400, 200, step=50, label="Response length")
+
             with gr.Row():
                 good_btn = gr.Button("👍 Good", variant="secondary")
                 bad_btn = gr.Button("👎 Bad", variant="secondary")
                 clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-            
+
             feedback_msg = gr.Textbox(label="Status", lines=1, interactive=False)
-            
+
             send_btn.click(
                 respond,
                 inputs=[msg, chatbot, temperature, max_tokens],
-                outputs=[msg, chatbot]
+                outputs=[msg, chatbot],
             )
-            
             msg.submit(
                 respond,
                 inputs=[msg, chatbot, temperature, max_tokens],
-                outputs=[msg, chatbot]
+                outputs=[msg, chatbot],
             )
-            
+
             good_btn.click(feedback_good, outputs=feedback_msg)
             bad_btn.click(feedback_bad, outputs=feedback_msg)
             clear_btn.click(clear_chat, outputs=[chatbot, feedback_msg])
-            
+
             gr.Markdown("### 💡 Try these examples:")
             gr.Examples(
                 examples=[
+                    ["2+2=?"],
                     ["Hello! What can you do?"],
                     ["What is Python?"],
                     ["Write a function to calculate factorial"],
@@ -298,34 +353,30 @@ with gr.Blocks(title="Veda Programming Assistant") as demo:
                     ["How do I read a file in Python?"],
                     ["Write a bubble sort algorithm"],
                 ],
-                inputs=msg
+                inputs=msg,
             )
-        
+
         with gr.TabItem("🎓 Training"):
-            gr.Markdown("""
-            ### Improve the Assistant
-            
-            1. Chat with the assistant
-            2. Rate good responses with 👍
-            3. Click "Retrain Model" to learn from good conversations
-            """)
-            
-            train_epochs = gr.Slider(
-                minimum=5,
-                maximum=20,
-                value=10,
-                step=1,
-                label="Training Epochs"
+            gr.Markdown(
+                """
+### Improve the Assistant
+
+1. Chat with the assistant  
+2. Rate good responses with 👍  
+3. Click "Retrain Model" to learn from good conversations  
+"""
             )
+
+            train_epochs = gr.Slider(5, 20, 10, step=1, label="Training Epochs")
             train_btn = gr.Button("🔄 Retrain Model", variant="primary")
             train_output = gr.Markdown()
             train_btn.click(retrain, inputs=[train_epochs], outputs=train_output)
-        
+
         with gr.TabItem("📊 Statistics"):
             stats_out = gr.Markdown()
             refresh_btn = gr.Button("🔄 Refresh Statistics")
             refresh_btn.click(get_stats, outputs=stats_out)
-    
+
     gr.Markdown("---\n**Veda Programming Assistant** - Learning from every conversation!")