Update app.py

app.py

@@ -1,471 +1,361 @@
-from flask import Flask, request, jsonify
+from flask import Flask, render_template, request, jsonify, session, Response
+import os
 import requests
-import random
-import string
-import time
+from datetime import datetime
+import secrets
+import re
+import html
 import json
+import unicodedata
+
+from ai_forward import AIForwarder
 
 app = Flask(__name__)
 
-# Global variables to store workspace and bot IDs
-GLOBAL_WORKSPACE_ID = None
-GLOBAL_BOT_ID = None
-
-
-# Authorization value used in requests (should be updated with a valid Authorization),
-TOKEN = "Bearer bp_pat_vTuxol25N0ymBpYaWqtWpFfGPKt260IfT784"
-# -------------------------------------------------------------------
-# Helper functions for random bot/workspace names
-# -------------------------------------------------------------------
-def generate_random_name(length=5):
-    """Generate a random name for workspace or bot"""
-    return ''.join(random.choices(string.ascii_letters, k=length))
-
-# -------------------------------------------------------------------
-# Functions to create/delete workspaces and bots
-# -------------------------------------------------------------------
-def create_workspace():
-    """Create a new workspace and return its ID"""
-    ws_url = "https://api.botpress.cloud/v1/admin/workspaces"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
-    payload = {"name": generate_random_name()}
+app.secret_key = os.environ.get("SECRET_KEY", secrets.token_hex(32))
 
-    try:
-        response = requests.post(ws_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            workspace_id = response_json.get('id')
-            print(f"Successfully created workspace: {workspace_id}")
-            return workspace_id
-        else:
-            print(f"Workspace creation failed with: {response.status_code}, {response.text}")
-            return None
-    except Exception as e:
-        print(f"Error creating workspace: {str(e)}")
-        return None
-
-
-def create_bot(workspace_id):
-    """Create a new bot in the specified workspace and return its ID"""
-    if not workspace_id:
-        print("Cannot create bot: No workspace ID provided")
-        return None
-
-    bot_url = "https://api.botpress.cloud/v1/admin/bots"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN,
-        "Content-Type": "application/json"
-    }
-    payload = {"name": generate_random_name()}
+app.config.update(
+    SESSION_COOKIE_HTTPONLY=True,
+    SESSION_COOKIE_SAMESITE="Lax",
+    SESSION_COOKIE_SECURE=False,  # set True behind HTTPS
+    PERMANENT_SESSION_LIFETIME=60 * 60 * 6,
+)
 
-    try:
-        response = requests.post(bot_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            bot_id = response_json.get("bot", {}).get("id")
-            if not bot_id:
-                print("Bot ID not found in the response.")
-                return None
-
-            print(f"Successfully created bot: {bot_id} in workspace: {workspace_id}")
-
-            # Install integration for the new bot
-            integration_success = install_bot_integration(bot_id, workspace_id)
-            if integration_success:
-                print(f"Successfully installed integration for bot {bot_id}")
-                return bot_id
-            else:
-                print(f"Failed to install integration for bot {bot_id}")
-                return bot_id  # Still return the bot ID even if integration fails
-        else:
-            print(f"Bot creation failed with: {response.status_code}, {response.text}")
-            return None
-    except Exception as e:
-        print(f"Error creating bot: {str(e)}")
-        return None
-
-
-def install_bot_integration(bot_id, workspace_id):
-    """Install required integration for the bot to function properly"""
-    if not bot_id or not workspace_id:
-        print("Cannot install integration: Missing bot ID or workspace ID")
-        return False
-
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN,
-        "Content-Type": "application/json",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id
-    }
-    # Integration payload
-    payload = {
-        "integrations": {
-            "intver_01KCHBZMZEM2017N9C0ND1STA5": {
-                "enabled": True
-            }
+# -------------------------
+# In-memory chat store
+# -------------------------
+# Key: session["sid"]  Value: list of messages
+# Each message: {"role": "...", "content": "...", "ts": "...", "sheet": "..."}
+CHAT_STORE: dict[str, list[dict]] = {}
+
+
+# -------------------------
+# Helpers: name + bissan detection
+# -------------------------
+def normalize_ar_name(s: str) -> str:
+    """
+    Normalize Arabic/Latin name for matching:
+    - strip spaces
+    - lowercase
+    - remove Arabic diacritics (tashkeel)
+    - normalize unicode
+    """
+    if not s:
+        return ""
+    s = s.strip()
+    s = unicodedata.normalize("NFKC", s)
+    s = s.lower()
+
+    # remove Arabic diacritics
+    # (harakat range + some marks)
+    s = re.sub(r"[\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06ED]", "", s)
+
+    # collapse spaces
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+
+def is_bissan_name(name: str) -> bool:
+    n = normalize_ar_name(name)
+    # Accept: "بيسان" or "بِيسان" (diacritics removed) or "bissan"
+    return n in {"بيسان", "bissan"}
+
+
+def get_user_profile():
+    """
+    Returns a dict describing how frontend should display the user:
+    - display_name: what to show in UI
+    - avatar_type: "default" or "bissan"
+    - avatar_bg: hint for UI
+    - emoji: default emoji for non-bissan
+    """
+    name = session.get("user_name") or "أنت"
+    if is_bissan_name(name):
+        return {
+            "display_name": name,
+            "is_bissan": True,
+            "avatar_type": "flower",
+            "avatar_bg": "pink",
+            "emoji": None,
         }
+    return {
+        "display_name": name,
+        "is_bissan": False,
+        "avatar_type": "emoji",
+        "avatar_bg": "blue",
+        "emoji": "USER",  # you said "USER EMOJEI" (implement in UI)
     }
 
-    try:
-        response = requests.put(url, headers=headers, json=payload)
-        if response.status_code == 200:
-            print(f"Successfully installed integration for bot {bot_id}")
-            return True
-        else:
-            print(f"Failed to install integration: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error installing integration: {str(e)}")
-        return False
 
+# -------------------------
+# AI App
+# -------------------------
+class AIStudyApp:
+    def __init__(self, api_url="https://dooratre-xx-gpt-52.hf.space/chat", data_folder="data"):
+        self.api_url = api_url
+        self.data_folder = data_folder
+        self.forwarder = AIForwarder(api_url)
 
-def try_delete_bot(bot_id, workspace_id):
-    """Attempt to delete a bot from the specified workspace but continue if it fails"""
-    if not bot_id or not workspace_id:
-        print("Cannot delete bot: Missing bot ID or workspace ID")
-        return False
+    def load_txt_file(self, filename):
+        filepath = os.path.join(self.data_folder, filename)
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                return f.read()
+        except FileNotFoundError:
+            print(f"Warning: {filename} not found")
+            return ""
+
+    def build_system_prompt(self, sheet_number: str, is_bissan: bool):
+        """
+        Normal users: system.txt + {sheet}.txt
+        Bissan user: bissan.txt + {sheet}.txt   (NO system.txt)
+        """
+        base_file = "bissan.txt" if is_bissan else "system.txt"
+        system_content = self.load_txt_file(base_file)
+        sheet_content = self.load_txt_file(f"{sheet_number}.txt")
+        return system_content + "\n\n" + sheet_content
+
+    def send_to_main_ai(self, user_message, system_prompt, chat_history):
+        full_chat_history = [{"role": "system", "content": system_prompt}]
+        full_chat_history.extend(chat_history)
+        full_chat_history.append({"role": "user", "content": user_message})
+
+        payload = {
+            "user_input": user_message,
+            "chat_history": full_chat_history,
+            "temperature": 0.9,
+            "top_p": 0.95,
+        }
 
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN
-    }
+        try:
+            response = requests.post(
+                self.api_url,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=45,
+            )
+            response.raise_for_status()
+            result = response.json()
+            return result.get("assistant_response", "")
+        except Exception as e:
+            print(f"Error calling main AI: {e}")
+            return None
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted bot: {bot_id}")
-            return True
-        else:
-            print(f"Failed to delete bot: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting bot: {str(e)}")
-        return False
+    def normalize_text(self, text: str) -> str:
+        if not text:
+            return ""
+        text = re.sub(r"[\u200B-\u200F\u202A-\u202E\u2066-\u2069]", "", text)
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        text = "\n".join([ln.rstrip() for ln in text.split("\n")]).strip()
+        return text
 
+    def format_code_blocks(self, text: str) -> str:
+        pattern = r"```(\w+)?\n(.*?)```"
 
-def try_delete_workspace(workspace_id):
-    """Attempt to delete a workspace but continue if it fails"""
-    if not workspace_id:
-        print("Cannot delete workspace: No workspace ID provided")
-        return False
+        def replace_code_block(match):
+            language = match.group(1) if match.group(1) else "code"
+            code_content = match.group(2)
+            return f"<code_{language}>\n{code_content}\n</code_{language}>"
 
-    url = f"https://api.botpress.cloud/v1/admin/workspaces/{workspace_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
+        return re.sub(pattern, replace_code_block, text, flags=re.DOTALL)
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted workspace: {workspace_id}")
-            return True
-        else:
-            print(f"Failed to delete workspace: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting workspace: {str(e)}")
-        return False
+    def unescape_html_inside_mcq(self, text: str) -> str:
+        if not text:
+            return ""
+        mcq_pattern = r"(<mcq>.*?</mcq>)"
 
+        def _fix_block(match):
+            block = match.group(1)
+            return html.unescape(block)
 
-# -------------------------------------------------------------------
-# Main function that calls the Botpress API endpoint
-# -------------------------------------------------------------------
-def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperature=0.9, top_p=0.95, max_tokens=None):
-    """
-    Sends the user input and chat history to the Botpress API endpoint,
-    returns the assistant's response and (possibly updated) bot/workspace IDs.
-    """
-    # Prepare the headers
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-bot-id": bot_id,
-        "Content-Type": "application/json",
-        "Authorization": TOKEN
-    }
+        return re.sub(mcq_pattern, _fix_block, text, flags=re.DOTALL | re.IGNORECASE)
 
-    # Process chat history into the format expected by the API
-    messages = []
-    system_prompt = ""
-
-    for msg in chat_history:
-        if msg["role"] == "system":
-            system_prompt = msg["content"]
-        elif msg["role"] in ["user", "assistant"]:
-            # Pass multipart messages directly without modifying their structure
-            if "type" in msg and msg["type"] == "multipart" and "content" in msg:
-                messages.append(msg)  # Keep the original multipart structure
-            # Handle regular text messages
-            else:
-                messages.append({
-                    "role": msg["role"],
-                    "content": msg["content"]
-                })
-
-    # Add the latest user input if not already in chat history
-    if user_input and isinstance(user_input, str) and (not messages or messages[-1]["role"] != "user" or messages[-1]["content"] != user_input):
-        messages.append({
-            "role": "user",
-            "content": user_input
-        })
-
-    # Prepare the payload for the API
-    payload = {
-        "type": "openai:generateContent",
-        "input": {
-            "model": {
-                "id": "gpt-5.2-2025-12-11"
-            },
-            "systemPrompt": system_prompt,
-            "messages": messages,
-            "temperature": temperature,
-            "debug": False,
-        }
-    }
+    def process_message(self, user_message, chat_history, is_bissan: bool):
+        temp_history = chat_history + [{"role": "user", "content": user_message}]
+        forward_result = self.forwarder.process_chat_history(temp_history)
+        sheet_number = forward_result.get("sheet_number", "1")
 
-    # Add maxTokens to the payload if provided
-    if max_tokens is not None:
-        payload["input"]["maxTokens"] = max_tokens
+        system_prompt = self.build_system_prompt(sheet_number, is_bissan=is_bissan)
+        ai_response = self.send_to_main_ai(user_message, system_prompt, chat_history)
 
-    botpress_url = "https://api.botpress.cloud/v1/chat/actions"
-    max_retries = 3
-    timeout = 120  # Increased timeout for long messages
+        if ai_response is None:
+            return {"response": None, "sheet_number": sheet_number}
 
-    # For debugging
-    print("Payload being sent to Botpress:")
-    print(json.dumps(payload, indent=2))
+        ai_response = self.normalize_text(ai_response)
+        ai_response = self.unescape_html_inside_mcq(ai_response)
 
-    # Attempt to send the request
-    for attempt in range(max_retries):
-        try:
-            print(f"Attempt {attempt+1}: Sending request to Botpress API with bot_id={bot_id}, workspace_id={workspace_id}")
-            response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
-
-            # If successful (200)
-            if response.status_code == 200:
-                data = response.json()
-                assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                print(f"Successfully received response from Botpress API")
-                return assistant_content, bot_id, workspace_id
-
-            # Check for authentication or permission errors (401, 403)
-            elif response.status_code in [401, 403]:
-                error_message = "Authentication error"
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('message', 'Authentication error')
-                except:
-                    pass
-
-                print(f"Authentication error detected: {error_message}")
-
-                # We need to create new resources immediately
-                print("Creating new workspace and bot...")
-                new_workspace_id = create_workspace()
-                if not new_workspace_id:
-                    print("Failed to create a new workspace")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new resources. Please try again later.", bot_id, workspace_id
-
-                new_bot_id = create_bot(new_workspace_id)
-                if not new_bot_id:
-                    print("Failed to create a new bot")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new bot. Please try again later.", new_workspace_id, workspace_id
-
-                print(f"Created new workspace: {new_workspace_id} and bot: {new_bot_id}")
-
-                # Try again with new IDs
-                headers["x-bot-id"] = new_bot_id
-                try:
-                    print(f"Retrying with new bot_id={new_bot_id}")
-                    retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
-
-                    if retry_response.status_code == 200:
-                        data = retry_response.json()
-                        assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                        print(f"Successfully received response with new IDs")
-
-                        # Try to clean up old resources in the background, but don't wait for result
-                        if bot_id and workspace_id:
-                            print(f"Attempting to clean up old resources in the background")
-                            try_delete_bot(bot_id, workspace_id)
-                            try_delete_workspace(workspace_id)
-
-                        return assistant_content, new_bot_id, new_workspace_id
-                    else:
-                        print(f"Failed with new IDs: {retry_response.status_code}")
-                        if attempt < max_retries - 1:
-                            time.sleep(2)
-                            continue
-                        else:
-                            return f"Unable to get a response even with new credentials.", new_bot_id, new_workspace_id
-
-                except Exception as e:
-                    print(f"Error with new IDs: {str(e)}")
-                    if attempt < max_retries - 1:
-                        time.sleep(2)
-                        continue
-                    else:
-                        return f"Error with new credentials: {str(e)}", new_bot_id, new_workspace_id
-
-            # Handle network errors or timeouts (just retry)
-            elif response.status_code in [404, 408, 502, 503, 504]:
-                print(f"Received error {response.status_code}. Retrying...")
-                time.sleep(3)  # Wait before retrying
-                continue
-
-            # Any other error status code
-            else:
-                print(f"Received unexpected error: {response.status_code}, {response.text}")
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return f"Unable to get a response from the assistant (Error {response.status_code}).", bot_id, workspace_id
-
-        except requests.exceptions.Timeout:
-            print(f"Request timed out. Retrying...")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return "The assistant is taking too long to respond. Please try again with a shorter message.", bot_id, workspace_id
+        formatted_response = self.format_code_blocks(ai_response)
+        return {"response": formatted_response, "sheet_number": sheet_number}
 
-        except Exception as e:
-            print(f"Error during request: {str(e)}")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return f"Unable to get a response from the assistant: {str(e)}", bot_id, workspace_id
-
-    # Should not reach here due to the handling in the loop
-    return "Unable to get a response from the assistant.", bot_id, workspace_id
-
-
-# -------------------------------------------------------------------
-# Flask Endpoint
-# -------------------------------------------------------------------
-@app.route("/chat", methods=["POST"])
-def chat_endpoint():
+
+ai_app = AIStudyApp()
+
+
+# -------------------------
+# Session init + name from URL
+# -------------------------
+@app.before_request
+def ensure_session():
+    if "sid" not in session:
+        session["sid"] = secrets.token_hex(12)
+
+    sid = session["sid"]
+    if sid not in CHAT_STORE:
+        CHAT_STORE[sid] = []
+
+    # Capture name from URL like: /?name=Ahmed
+    # You said "manual gonna put the name ... edit the url"
+    qname = request.args.get("name", type=str)
+    if qname is not None:
+        qname = qname.strip()
+        if qname:
+            session["user_name"] = qname
+
+
+# -------------------------
+# Routes
+# -------------------------
+@app.route("/")
+def index():
+    # Keep your existing template if you want.
+    # Name is now set via URL query (?name=...)
+    return render_template("index.html")
+
+
+@app.route("/session_info", methods=["GET"])
+def session_info():
     """
-    Expects JSON with:
-    {
-      "user_input": "string", // Can be null if multipart message is in chat_history
-      "chat_history": [
-         {"role": "system", "content": "..."},
-         {"role": "user",   "content": "..."},
-         // Or for images:
-         {"role": "user", "type": "multipart", "content": [
-            {"type": "image", "url": "https://example.com/image.jpg"},
-            {"type": "text", "text": "What's in this image?"}
-         ]},
-         ...
-      ],
-      "temperature": 0.9,  // Optional, defaults to 0.9
-      "top_p": 0.95,       // Optional, defaults to 0.95
-      "max_tokens": 1000   // Optional, defaults to null (no limit)
-    }
-    Returns JSON with:
-    {
-      "assistant_response": "string"
-    }
+    Frontend calls this to know:
+    - display name to show instead of "أنت"
+    - avatar style (default blue USER emoji vs bissan flower pink)
     """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Parse JSON from request
-    data = request.get_json(force=True)
-    user_input = data.get("user_input", "")
-    chat_history = data.get("chat_history", [])
+    return jsonify(
+        {
+            "sid": session.get("sid"),
+            "user": get_user_profile(),
+        }
+    )
 
-    # Get temperature, top_p, and max_tokens from request, or use defaults
-    temperature = data.get("temperature", 0.9)
-    top_p = data.get("top_p", 0.95)
-    max_tokens = data.get("max_tokens", None)
 
-    # Validate temperature and top_p values
+@app.route("/send_message", methods=["POST"])
+def send_message():
     try:
-        temperature = float(temperature)
-        if not 0 <= temperature <= 2:
-            temperature = 0.9
-            print(f"Invalid temperature value. Using default: {temperature}")
-    except (ValueError, TypeError):
-        temperature = 0.9
-        print(f"Invalid temperature format. Using default: {temperature}")
+        data = request.get_json(force=True)
+        user_message = (data.get("message") or "").strip()
+        if not user_message:
+            return jsonify({"success": False, "error": "الرسالة فارغة"}), 400
+
+        sid = session["sid"]
+        profile = get_user_profile()
+        is_bissan = profile["is_bissan"]
+
+        # Build chat_history for AI from stored messages (role/content only)
+        stored = CHAT_STORE.get(sid, [])
+        chat_history = [{"role": m["role"], "content": m["content"]} for m in stored]
+
+        result = ai_app.process_message(user_message, chat_history, is_bissan=is_bissan)
+
+        if result["response"]:
+            ts = datetime.now().strftime("%H:%M")
+
+            # Save user message
+            CHAT_STORE[sid].append(
+                {
+                    "role": "user",
+                    "content": user_message,
+                    "ts": ts,
+                    "sheet": result["sheet_number"],
+                    "user_name": profile["display_name"],
+                }
+            )
+
+            # Save assistant message
+            CHAT_STORE[sid].append(
+                {
+                    "role": "assistant",
+                    "content": result["response"],
+                    "ts": ts,
+                    "sheet": result["sheet_number"],
+                }
+            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "response": result["response"],
+                    "sheet_number": result["sheet_number"],
+                    "timestamp": ts,
+                    "user": profile,  # so frontend can update UI if needed
+                }
+            )
+
+        return jsonify({"success": False, "error": "فشل الحصول على رد من الذكاء الاصطناعي"}), 500
 
-    try:
-        top_p = float(top_p)
-        if not 0 <= top_p <= 1:
-            top_p = 0.95
-            print(f"Invalid top_p value. Using default: {top_p}")
-    except (ValueError, TypeError):
-        top_p = 0.95
-        print(f"Invalid top_p format. Using default: {top_p}")
-
-    # Validate max_tokens if provided
-    if max_tokens is not None:
-        try:
-            max_tokens = int(max_tokens)
-            if max_tokens <= 0:
-                print("Invalid max_tokens value (must be positive). Not using max_tokens.")
-                max_tokens = None
-        except (ValueError, TypeError):
-            print("Invalid max_tokens format. Not using max_tokens.")
-            max_tokens = None
-
-    # If we don't yet have a workspace or bot, create them
-    if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-        print("No existing IDs found. Creating new workspace and bot...")
-        GLOBAL_WORKSPACE_ID = create_workspace()
-        if GLOBAL_WORKSPACE_ID:
-            GLOBAL_BOT_ID = create_bot(GLOBAL_WORKSPACE_ID)
-
-        # If creation failed
-        if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-            return jsonify({"assistant_response": "I'm currently unavailable. Please try again later."}), 500
-
-    # Call our function that interacts with Botpress API
-    print(f"Sending chat request with existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
-    print(f"Using temperature={temperature}, top_p={top_p}, max_tokens={max_tokens}")
-
-    assistant_response, updated_bot_id, updated_workspace_id = chat_with_assistant(
-        user_input,
-        chat_history,
-        GLOBAL_BOT_ID,
-        GLOBAL_WORKSPACE_ID,
-        temperature,
-        top_p,
-        max_tokens
+    except Exception as e:
+        print(f"Error in send_message: {e}")
+        return jsonify({"success": False, "error": "حدث خطأ غير متوقع"}), 500
+
+
+@app.route("/clear_history", methods=["POST"])
+def clear_history():
+    sid = session["sid"]
+    CHAT_STORE[sid] = []
+    return jsonify({"success": True, "message": "تم مسح المحادثة"})
+
+
+@app.route("/get_history", methods=["GET"])
+def get_history():
+    sid = session["sid"]
+    return jsonify({"history": CHAT_STORE.get(sid, [])})
+
+
+# -------------------------
+# Bissan routes (view + download)
+# -------------------------
+@app.route("/bissan", methods=["GET"])
+def bissan_history():
+    """
+    Returns the current session chat as JSON.
+    You said: "/bissan to open the array with html code"
+    لكن الآن: no HTML, so JSON only.
+    Your frontend can render it.
+    """
+    sid = session["sid"]
+    profile = get_user_profile()
+    return jsonify(
+        {
+            "sid": sid,
+            "user": profile,
+            "history": CHAT_STORE.get(sid, []),
+        }
     )
 
-    # Update global IDs if they changed
-    if updated_bot_id != GLOBAL_BOT_ID or updated_workspace_id != GLOBAL_WORKSPACE_ID:
-        print(f"Updating global IDs: bot_id={updated_bot_id}, workspace_id={updated_workspace_id}")
-        GLOBAL_BOT_ID = updated_bot_id
-        GLOBAL_WORKSPACE_ID = updated_workspace_id
 
-    return jsonify({"assistant_response": assistant_response})
+@app.route("/bissan/download", methods=["GET"])
+def bissan_download():
+    """
+    Download chat as JSON file (UTF-8 Arabic safe).
+    """
+    sid = session["sid"]
+    profile = get_user_profile()
 
+    payload = {
+        "sid": sid,
+        "exported_at": datetime.utcnow().isoformat() + "Z",
+        "user": profile,
+        "history": CHAT_STORE.get(sid, []),
+    }
+
+    data = json.dumps(payload, ensure_ascii=False, indent=2)
+    filename = f"chat_{sid}.json"
+
+    return Response(
+        data,
+        mimetype="application/json; charset=utf-8",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
 
-# -------------------------------------------------------------------
-# Run the Flask app
-# -------------------------------------------------------------------
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True)
+    app.run(debug=True, host="0.0.0.0", port=7860)