Update app.py

app.py

@@ -149,11 +149,31 @@ class CBTChatbot:
         self.identified_distortions: list[tuple[str, float]] = []
         self.memory_size = max(2, int(memory_size))
 
-    def _history_to_context(self, history: list[list[str]]) -> list[dict]:
-        """Convert Chatbot history [[user, assistant], ...] to agent context[{user,assistant}]"""
+    def _history_to_context(self, history) -> list[dict]:
+        """Convert Chatbot history to agent context.
+
+        Supports both legacy [[user, assistant], ...] and new Gradio
+        messages format [{role, content}, ...]. Returns a list of
+        {user, assistant} dicts capped to memory_size.
+        """
         ctx: list[dict] = []
-        for turn in history or []:
-            if isinstance(turn, list | tuple) and len(turn) == 2:
+        if not history:
+            return ctx
+        # New messages format
+        if isinstance(history, list) and history and isinstance(history[0], dict):
+            pending_user = None
+            for msg in history:
+                role = str(msg.get("role", ""))
+                content = str(msg.get("content", ""))
+                if role == "user":
+                    pending_user = content
+                elif role == "assistant" and pending_user is not None:
+                    ctx.append({"user": pending_user, "assistant": content})
+                    pending_user = None
+            return ctx[-self.memory_size :]
+        # Legacy tuple format
+        for turn in history:
+            if isinstance(turn, (list, tuple)) and len(turn) == 2:
                 ctx.append({"user": turn[0] or "", "assistant": turn[1] or ""})
         return ctx[-self.memory_size :]
 
@@ -683,12 +703,26 @@ def create_app(language='en'):
                         )
                         return
 
-                    # Start streaming the assistant reply
+                    # Start streaming the assistant reply (messages format)
                     history = history or []
-                    history.append([message, ""])  # placeholder for assistant
-                    # Enforce memory cap while streaming
-                    if len(history) > chatbot.memory_size:
-                        history = history[-chatbot.memory_size :]
+                    # Append user message then assistant placeholder
+                    try:
+                        history.append({"role": "user", "content": message})
+                    except Exception:
+                        history = list(history) + [{"role": "user", "content": message}]
+                    history.append({"role": "assistant", "content": ""})
+                    # Optional prune to last N pairs to keep UI light
+                    try:
+                        pairs = chatbot._history_to_context(history[:-1])
+                        pruned: list[dict] = []
+                        for p in pairs:
+                            pruned.append({"role": "user", "content": p.get("user", "")})
+                            pruned.append({"role": "assistant", "content": p.get("assistant", "")})
+                        pruned.append({"role": "user", "content": message})
+                        pruned.append({"role": "assistant", "content": ""})
+                        history = pruned
+                    except Exception:
+                        pass
 
                     # Choose response source: true token streaming via HF Inference
                     try:
@@ -724,7 +758,13 @@ def create_app(language='en'):
                         if not chunk:
                             continue
                         acc += str(chunk)
-                        history[-1][1] = acc
+                        if isinstance(history[-1], dict):
+                            history[-1]["content"] = acc
+                        else:
+                            try:
+                                history[-1][1] = acc
+                            except Exception:
+                                pass
                         # yield streaming frame
                         yield (
                             history,
@@ -1013,4 +1053,4 @@ def create_app(language='en'):
 # Launch the app
 if __name__ == "__main__":
     app = create_app(language='en')
-    app.launch(share=False, show_error=True, show_api=False)
+    app.launch(share=True, show_error=True, show_api=False)