fixed stt and added whisper and elevenlabs stt + updated

app.py

@@ -3,17 +3,15 @@ app.py — FastAPI entrypoint: WebRTC-first + WebSocket fallback
 
 FIXES APPLIED:
   FIX-SESSION (Issue 1): The voice WS handler now reads user_id from the
-    first 'init' JSON message before processing any audio. The variable is
-    no longer a random UUID per connection — it is the stable USER_ID sent
-    by the browser from localStorage. This means every reconnect, even after
-    a page reload, hits the same LangGraph thread and restores conversation
-    history.
+    first 'init' JSON message before processing any audio. The browser now
+    generates a fresh USER_ID on every page load, so each reload becomes a
+    brand-new user and gets a fresh LangGraph thread / DB row.
 
     Implementation:
       • user_id is initialised to None inside ws_voice.
       • The handler waits for any early text messages before processing binary.
       • On 'init' message, user_id is set and init_ack returned.
-      • All subsequent audio/LLM calls use that stable user_id.
+      • All subsequent audio/LLM calls use that session user_id.
       • If no 'init' is received within 3 s, a random fallback is used
         (prevents hang for non-browser clients).
 
@@ -194,6 +192,11 @@ async def _safe_bytes(ws: WebSocket, data: bytes) -> bool:
         return False
 
 
+async def _register_user(user_id: str) -> None:
+    if user_id:
+        await ai.ensure_user_thread(user_id)
+
+
 # ══════════════════════════════════════════════════════════════════════════════
 #  WEBSOCKET — CHAT (text only, streaming tokens)
 # ══════════════════════════════════════════════════════════════════════════════
@@ -223,6 +226,7 @@ async def ws_chat(ws: WebSocket):
                 if claimed:
                     user_id = claimed
                     print(f"[CHAT] Session restored for user_id={user_id!r}")
+                    await _register_user(user_id)
                     await _safe_text(ws, {"type": "init_ack", "user_id": user_id})
                 continue
 
@@ -233,6 +237,7 @@ async def ws_chat(ws: WebSocket):
             # Fall back to user_id in message payload (compatibility)
             if not user_id:
                 user_id = str(data.get("user_id", "default_user"))[:64]
+                await _register_user(user_id)
 
             user_query = data.get("user_query", "").strip()
             if not user_query:
@@ -295,6 +300,7 @@ async def ws_voice(ws: WebSocket):
     else:
         print(f"[VOICE] Session user_id={user_id}")
 
+    await _register_user(user_id)
     await _safe_text(ws, {"type": "init_ack", "user_id": user_id})
 
     stt = STTProcessor()
@@ -387,6 +393,7 @@ async def ws_voice(ws: WebSocket):
                         claimed = str(msg.get("user_id", "")).strip()[:64]
                         if claimed:
                             user_id = claimed
+                            await _register_user(user_id)
                         await _safe_text(ws, {"type": "init_ack", "user_id": user_id})
                     elif t == "ping":
                         await _safe_text(ws, {"type": "pong"})

core/backend.py

@@ -10,6 +10,7 @@ import aiosqlite
 import pytz
 from datetime import datetime, timedelta
 from dotenv import load_dotenv
+import re
 
 from langchain_core.messages import (
     AIMessage, AIMessageChunk, HumanMessage, RemoveMessage,
@@ -54,6 +55,143 @@ def format_bd_number(num: str) -> str:
     return num
 
 
+def _clean_text(text: str) -> str:
+    return re.sub(r"\s+", " ", (text or "").strip())
+
+
+DAY_ALIASES = {
+    "sunday": "Sunday",
+    "monday": "Monday",
+    "tuesday": "Tuesday",
+    "wednesday": "Wednesday",
+    "thursday": "Thursday",
+    "friday": "Friday",
+    "saturday": "Saturday",
+    "রবিবার": "Sunday",
+    "সোমবার": "Monday",
+    "মঙ্গলবার": "Tuesday",
+    "বুধবার": "Wednesday",
+    "বৃহস্পতিবার": "Thursday",
+    "শুক্রবার": "Friday",
+    "শনিবার": "Saturday",
+}
+
+SPECIALTY_ALIASES = {
+    "চক্ষু": ["ophthalmologist", "eye specialist", "eye doctor", "ophthalmology", "eye"],
+    "আই": ["ophthalmologist", "eye specialist", "eye doctor", "ophthalmology", "eye"],
+    "চোখ": ["ophthalmologist", "eye specialist", "eye doctor", "ophthalmology", "eye"],
+    "হৃদরোগ": ["cardiologist", "heart", "cardio", "cardiology"],
+    "কার্ডিও": ["cardiologist", "heart", "cardio", "cardiology"],
+    "মেডিসিন": ["medicine", "internal medicine", "physician", "general medicine"],
+    "নিউরো": ["neurologist", "neurology", "brain"],
+    "স্নায়ু": ["neurologist", "neurology", "brain"],
+    "নাক": ["ent", "otolaryngologist", "ear nose throat"],
+    "কান": ["ent", "otolaryngologist", "ear nose throat"],
+    "গলা": ["ent", "otolaryngologist", "ear nose throat"],
+    "চর্ম": ["dermatologist", "skin", "dermatology"],
+    "স্কিন": ["dermatologist", "skin", "dermatology"],
+    "ডেন্টাল": ["dentist", "dental", "teeth"],
+    "দাঁত": ["dentist", "dental", "teeth"],
+    "গাইনী": ["gynecologist", "gynaecologist", "obgyn", "women"],
+    "মহিলা": ["gynecologist", "gynaecologist", "obgyn", "women"],
+    "শিশু": ["pediatrician", "child", "children"],
+    "পেডিয়াট্রিক": ["pediatrician", "child", "children"],
+    "অর্থো": ["orthopedic", "orthopaedic", "bone"],
+    "হাড়": ["orthopedic", "orthopaedic", "bone"],
+    "বক্ষ": ["chest", "pulmonologist", "respiratory"],
+    "শ্বাস": ["pulmonologist", "respiratory", "chest"],
+    "কিডনি": ["nephrologist", "kidney", "renal"],
+    "গ্যাস্ট্রো": ["gastroenterologist", "stomach", "digestive"],
+    "পেট": ["gastroenterologist", "stomach", "digestive"],
+}
+
+
+def _normalize_day(term: str) -> str:
+    raw = _clean_text(term)
+    if not raw:
+        return ""
+    lower = raw.lower()
+    return DAY_ALIASES.get(lower, DAY_ALIASES.get(raw, raw))
+
+
+def _expand_search_terms(text: str) -> list[str]:
+    """
+    Expand Bangla/Banglish doctor-search text into English-friendly terms.
+    """
+    raw = _clean_text(text)
+    if not raw:
+        return []
+
+    terms: set[str] = {raw.lower()}
+    raw_lower = raw.lower()
+
+    for bangla_key, aliases in SPECIALTY_ALIASES.items():
+        if bangla_key in raw or bangla_key.lower() in raw_lower:
+            terms.update(a.lower() for a in aliases)
+
+    if raw_lower in DAY_ALIASES:
+        terms.add(DAY_ALIASES[raw_lower].lower())
+
+    # Keep the individual tokens too, because users may mix Bangla and English.
+    for token in re.split(r"[,\s/|]+", raw_lower):
+        token = token.strip()
+        if token:
+            terms.add(token)
+
+    return sorted(terms)
+
+
+def _parse_visit_date(text: str) -> Optional[str]:
+    """
+    Parse a user-facing date into YYYY-MM-DD in Bangladesh time.
+    Accepts ISO, English relative dates, and many natural-language variants.
+    """
+    text = _clean_text(text)
+    if not text:
+        return None
+
+    if re.fullmatch(r"\d{4}-\d{2}-\d{2}", text):
+        return text
+
+    tz = pytz.timezone("Asia/Dhaka")
+    now = datetime.now(tz)
+
+    lower = text.lower()
+    if text in {"আজ", "today"}:
+        return now.strftime("%Y-%m-%d")
+    if text in {"আগামীকাল", "tomorrow"}:
+        return (now + timedelta(days=1)).strftime("%Y-%m-%d")
+    if text in {"পরশু", "day after tomorrow"}:
+        return (now + timedelta(days=2)).strftime("%Y-%m-%d")
+
+    day_name = _normalize_day(text)
+    if day_name in DAY_ALIASES.values():
+        target_idx = [
+            "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
+        ].index(day_name)
+        current_idx = now.weekday()
+        delta = (target_idx - current_idx) % 7
+        if delta == 0:
+            delta = 7
+        return (now + timedelta(days=delta)).strftime("%Y-%m-%d")
+
+    try:
+        found = search_dates(
+            text,
+            settings={
+                "PREFER_DATES_FROM": "future",
+                "TIMEZONE": "Asia/Dhaka",
+                "RETURN_AS_TIMEZONE_AWARE": False,
+                "RELATIVE_BASE": now.replace(tzinfo=None),
+            },
+        )
+        if found:
+            return found[0][1].strftime("%Y-%m-%d")
+    except Exception:
+        pass
+    return None
+
+
 def send_sms(to_number: str, message: str) -> None:
     client = Client(os.getenv("TWILIO_ACCOUNT_SID"), os.getenv("TWILIO_AUTH_TOKEN"))
     client.messages.create(
@@ -124,6 +262,7 @@ async def get_categories_by_day(visiting_day: str = "") -> str:
 
     # Optional filter
     if visiting_day:
+        visiting_day = _normalize_day(visiting_day)
         query += " AND LOWER(visiting_days) LIKE ?"
         params.append(f"%{visiting_day.lower()}%")
 
@@ -174,6 +313,7 @@ async def get_doctors_by_day(visiting_day: str = "") -> str:
 
     # Optional filter
     if visiting_day:
+        visiting_day = _normalize_day(visiting_day)
         query += " AND LOWER(visiting_days) LIKE ?"
         params.append(f"%{visiting_day.lower()}%")
 
@@ -198,6 +338,63 @@ async def get_doctors_by_day(visiting_day: str = "") -> str:
         "data": doctors
     }, ensure_ascii=False)
 
+@tool
+async def find_doctors(query: str = "", visiting_day: str = "") -> str:
+    """
+    Flexible doctor search for Bangla, Banglish, or English queries.
+
+    Use this for questions like:
+    - "চক্ষু ডাক্তার"
+    - "আজ কোন cardiologist আছে?"
+    - "মঙ্গলবার available pediatric doctor"
+    """
+    db_path = get_db_path()
+    query_text = _clean_text(query)
+    day_text = _normalize_day(visiting_day)
+    terms = _expand_search_terms(query_text)
+
+    sql = "SELECT * FROM doctors WHERE 1=1"
+    params: list[str] = []
+    conditions: list[str] = []
+
+    if day_text:
+        conditions.append("LOWER(visiting_days) LIKE ?")
+        params.append(f"%{day_text.lower()}%")
+
+    if terms:
+        term_clauses = []
+        for term in terms:
+            term_clauses.append("(LOWER(doctor_name) LIKE ? OR LOWER(category) LIKE ? OR LOWER(visiting_days) LIKE ?)")
+            params.extend([f"%{term}%", f"%{term}%", f"%{term}%"])
+        conditions.append("(" + " OR ".join(term_clauses) + ")")
+
+    if conditions:
+        sql += " AND " + " AND ".join(conditions)
+
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(sql, params)
+        rows = await cursor.fetchall()
+
+    if not rows:
+        return json.dumps({
+            "success": False,
+            "message": "No doctors found.",
+            "query": query_text,
+            "visiting_day": day_text or "ALL",
+            "data": [],
+        }, ensure_ascii=False)
+
+    doctors = [dict(row) for row in rows]
+    return json.dumps({
+        "success": True,
+        "count": len(doctors),
+        "query": query_text,
+        "visiting_day": day_text or "ALL",
+        "data": doctors,
+    }, ensure_ascii=False)
+
+
 @tool
 async def search_doctor(
     name: str = "",
@@ -209,19 +406,31 @@ async def search_doctor(
     Any combination of filters is supported (OR logic across fields).
     """
     db_path    = get_db_path()
+    name       = _clean_text(name)
+    category   = _clean_text(category)
+    visiting_days = _clean_text(visiting_days)
+    name_terms = _expand_search_terms(name)
+    category_terms = _expand_search_terms(category)
+    day_text   = _normalize_day(visiting_days) if visiting_days else ""
     query      = "SELECT * FROM doctors WHERE 1=1"
     params: list = []
     conditions: list[str] = []
 
-    if name:
-        conditions.append("LOWER(doctor_name) LIKE ?")
-        params.append(f"%{name.lower()}%")
-    if category:
-        conditions.append("LOWER(category) LIKE ?")
-        params.append(f"%{category.lower()}%")
-    if visiting_days:
+    if name_terms:
+        name_clauses = []
+        for term in name_terms:
+            name_clauses.append("LOWER(doctor_name) LIKE ?")
+            params.append(f"%{term}%")
+        conditions.append("(" + " OR ".join(name_clauses) + ")")
+    if category_terms:
+        category_clauses = []
+        for term in category_terms:
+            category_clauses.append("LOWER(category) LIKE ?")
+            params.append(f"%{term}%")
+        conditions.append("(" + " OR ".join(category_clauses) + ")")
+    if day_text:
         conditions.append("LOWER(visiting_days) LIKE ?")
-        params.append(f"%{visiting_days.lower()}%")
+        params.append(f"%{day_text.lower()}%")
 
     if conditions:
         query += " AND (" + " OR ".join(conditions) + ")"
@@ -232,9 +441,9 @@ async def search_doctor(
         rows   = await cursor.fetchall()
 
     if not rows:
-        return json.dumps({"success": False, "message": "No doctors found.", "data": []})
+        return json.dumps({"success": False, "message": "No doctors found.", "data": []}, ensure_ascii=False)
 
-    return json.dumps({"success": True, "count": len(rows), "data": [dict(r) for r in rows]})
+    return json.dumps({"success": True, "count": len(rows), "data": [dict(r) for r in rows]}, ensure_ascii=False)
 
 
 @tool
@@ -262,33 +471,71 @@ async def search_appointment_by_phone(patient_num: str) -> str:
 
 @tool
 async def book_appointment(
-    doctor_id: int,
-    patient_name: str,
-    patient_age: str,
-    patient_num: str,
-    visiting_date: str,
-    patient_mail: str
+    doctor_id: int = 0,
+    doctor_name: str = "",
+    category: str = "",
+    patient_name: str = "",
+    patient_age: str = "",
+    patient_num: str = "",
+    visiting_date: str = "",
+    patient_mail: str = ""
 ) -> str:
     """
     Book a doctor appointment and save it to the patients table.
     Args:
-        doctor_id:     Doctor's ID from search_doctor results.
+        doctor_id:     Doctor's ID from search_doctor results (preferred).
+        doctor_name:   Doctor name if doctor_id is not available.
+        category:      Optional doctor category if doctor_id is not available.
         patient_name:  Full name of the patient.
         patient_age:   Age of the patient (e.g. "32").
         patient_num:   Contact phone number of the patient.
-        visiting_date: Date of visit in YYYY-MM-DD format (e.g. 2025-06-15).
+        visiting_date: Date of visit in YYYY-MM-DD format or natural text.
         patient_mail:  Mail address for confirmation mail.
     """
     db_path     = get_db_path()
     patient_num = format_bd_number(patient_num)
+    patient_name = _clean_text(patient_name)
+    patient_age  = _clean_text(patient_age)
+    doctor_name = _clean_text(doctor_name)
+    category    = _clean_text(category)
+    visiting_date = _clean_text(visiting_date)
+    parsed_date = _parse_visit_date(visiting_date)
+    if parsed_date:
+        visiting_date = parsed_date
+
+    if not patient_name or not patient_age or not patient_num or not visiting_date or not patient_mail:
+        return (
+            "Missing booking details. Need patient name, age, phone number, "
+            "visit date, and email."
+        )
 
     async with aiosqlite.connect(db_path) as db:
         db.row_factory = aiosqlite.Row
 
-        cursor = await db.execute("SELECT * FROM doctors WHERE id = ?", (doctor_id,))
-        doctor = await cursor.fetchone()
+        doctor = None
+        if doctor_id:
+            cursor = await db.execute("SELECT * FROM doctors WHERE id = ?", (doctor_id,))
+            doctor = await cursor.fetchone()
+
+        if doctor is None and doctor_name:
+            cursor = await db.execute(
+                "SELECT * FROM doctors WHERE LOWER(doctor_name) = LOWER(?)",
+                (doctor_name,),
+            )
+            doctor = await cursor.fetchone()
+
+        if doctor is None and category:
+            cursor = await db.execute(
+                "SELECT * FROM doctors WHERE LOWER(category) LIKE ? ORDER BY id LIMIT 1",
+                (f"%{category.lower()}%",),
+            )
+            doctor = await cursor.fetchone()
+
         if not doctor:
-            return f"No doctor found with ID {doctor_id}. Please search for a doctor first."
+            return (
+                "No doctor found. Please search first and provide either "
+                "doctor_id, doctor_name, or category."
+            )
 
         doctor_data     = dict(doctor)
         doctor_name     = doctor_data.get("doctor_name", "Unknown")
@@ -347,14 +594,21 @@ async def book_appointment(
 
 
 @tool
-async def delete_appointment(patient_num: str, doctor_name: str) -> str:
-    """Delete an appointment using the patient's phone number and doctor name."""
+async def delete_appointment(patient_num: str, doctor_name: str = "", doctor_id: int = 0) -> str:
+    """Delete an appointment using the patient's phone number and doctor name or ID."""
     db_path     = get_db_path()
     patient_num = format_bd_number(patient_num)
+    doctor_name = _clean_text(doctor_name)
 
     async with aiosqlite.connect(db_path) as db:
         db.row_factory = aiosqlite.Row
 
+        if not doctor_name and doctor_id:
+            cursor = await db.execute("SELECT doctor_name FROM doctors WHERE id = ?", (doctor_id,))
+            row = await cursor.fetchone()
+            if row:
+                doctor_name = row["doctor_name"]
+
         cursor = await db.execute(
             """SELECT * FROM patients
                WHERE patient_num = ? AND LOWER(doctor_name) = LOWER(?)""",
@@ -373,42 +627,54 @@ async def delete_appointment(patient_num: str, doctor_name: str) -> str:
     return json.dumps({
         "success": True,
         "message": f"Appointment with Dr. {doctor_name} deleted successfully.",
-    })
+    }, ensure_ascii=False)
 
 # ═══════════════════════════════════════════════════════════════════════════════
 #  SYSTEM PROMPT
 # ═══════════════════════════════════════════════════���═══════════════════════════
 BASE_SYSTEM = """
-You are a Doctor Appointment Assistant AI.
-Your job is to help users manage medical appointments.
-CAPABILITIES:
-- Book doctor appointments
-- Reschedule appointments
-- Cancel appointments
-- Collect patient details
-STRICT RULES:
+You are DAA, a warm Bangla-first medical appointment concierge.
+Your job is to help people find doctors, check availability, and manage appointments.
+
+CORE BEHAVIOR:
+- Speak naturally and politely like a human assistant.
+- Default to Bangla when the user speaks Bangla or Banglish.
+- Keep replies short, helpful, and one step at a time.
+- If the database fields are English, translate the user's Bangla intent into English before calling tools.
+- Never answer doctor availability or booking questions from memory when a tool can verify it.
+
+STRICT SAFETY:
 - You are NOT a doctor.
-- NEVER diagnose diseases.
-- NEVER recommend medicines or treatments.
+- Never diagnose diseases.
+- Never recommend medicines or treatments.
+
 APPOINTMENT FLOW:
-1. Detect intent (book / cancel / reschedule / inquiry)
-2. Collect details
-3. Confirm all details before final booking
-STYLE:
-- Be short, clear, structured
-- Focus on completing booking
+1. Understand the user's intent.
+2. Use tools to find the right doctor or appointment record.
+3. Ask only for missing details.
+4. Confirm important details before booking or deleting.
+
+TOOL RULES:
+- Use `find_doctors` first for doctor search, specialty search, and availability search.
+- Use `get_doctors_by_day` or `get_categories_by_day` when the user asks about a day directly.
+- Use `book_appointment` only after identifying the doctor and required patient details.
+- Never invent `doctor_id`. Get it from tool results or resolve by doctor_name/category.
+- If the user gives a Bangla date like "আগামীকাল" or "পরশু", convert it to a real date before booking.
+
 LANGUAGE RULE:
-- Detect user language from latest message.
-- If English → reply English.
-- If Bangla → reply Bangla (বাংলা).
-- If Banglish → reply Bangla (বাংলা).
-- Never mix languages unless user mixes first.
-DOCTOR ID RULE:
-- Never generate or guess doctor_id.
-- doctor_id must only come from search_doctor tool output.
-TOOLS:
-- Use backend tools if needed
-- Always confirm before final action
+- Respond in the user’s language.
+- If the user uses Bangla, reply in clear Bangla.
+- If the user uses Banglish, reply in Bangla unless they clearly prefer English.
+- Always generate numbers in english
+
+DATA RULE:
+- Doctor names, categories, and days in the database are English.
+- Bangla terms such as চক্ষু/কার্ডিও/শিশু/চর্ম must be translated to English search terms before tool calls.
+
+RESPONSE STYLE:
+- Be concise.
+- Be reassuring.
+- Ask one clear question when more information is needed.
 """
 
 SUMMARY_SYSTEM = (
@@ -443,6 +709,7 @@ class AIBackend:
             self.llm = ChatOllama(model="gemma4:e4b", streaming=True, temperature=0.01)
 
         self.tools          = [
+            find_doctors,
             search_doctor,
             book_appointment,
             get_bd_time,
@@ -614,23 +881,33 @@ class AIBackend:
             threads.add(cp.config["configurable"]["thread_id"])
         return list(threads)
 
-    # ── Public entry point ─────────────────────────────────────────────────────
-    async def main(self, user_id: str, user_query: str) -> AsyncGenerator[str, None]:
-        """Return an async generator of AI text tokens."""
+    async def ensure_user_thread(self, user_id: str) -> str:
+        """Create a DB-backed thread for a user if it does not already exist."""
+        user_id = _clean_text(user_id)[:64]
+        if not user_id:
+            raise ValueError("user_id is required")
+
         async with self.conn.execute(
-            "SELECT threadId FROM userid_threadid WHERE userId = ?", (user_id,)
+            "SELECT threadId FROM userid_threadid WHERE userId = ?",
+            (user_id,),
         ) as cursor:
             row = await cursor.fetchone()
 
-        if row is None:
-            thread_id = user_id + self.generate_thread_id()
-            await self.conn.execute(
-                "INSERT INTO userid_threadid (userId, threadId) VALUES (?, ?)",
-                (user_id, thread_id),
-            )
-            await self.conn.commit()
-        else:
-            thread_id = row[0]
+        if row is not None:
+            return row[0]
+
+        thread_id = user_id + self.generate_thread_id()
+        await self.conn.execute(
+            "INSERT INTO userid_threadid (userId, threadId) VALUES (?, ?)",
+            (user_id, thread_id),
+        )
+        await self.conn.commit()
+        return thread_id
+
+    # ── Public entry point ─────────────────────────────────────���───────────────
+    async def main(self, user_id: str, user_query: str) -> AsyncGenerator[str, None]:
+        """Return an async generator of AI text tokens."""
+        thread_id = await self.ensure_user_thread(user_id)
 
         initial_state = {"messages": [HumanMessage(content=user_query)]}
         config = {

frontend/script.js

@@ -36,18 +36,18 @@ const mTts = document.getElementById('m-tts');
 const mTotal = document.getElementById('m-total');
 const sysStat = document.getElementById('sys-status');
 
-// ─── Persistent user identity ─────────────────────────────────────────────────
+// ─── Ephemeral user identity ──────────────────────────────────────────────────
+// New page load = new user. Reloading the app generates a fresh ID.
 const USER_ID = (() => {
-  let id = localStorage.getItem('daa_uid');
-  if (!id) {
-    id =
-      'u_' +
-      Date.now().toString(36) +
-      '_' +
-      Math.random().toString(36).slice(2, 6);
-    localStorage.setItem('daa_uid', id);
+  if (window.crypto && typeof window.crypto.randomUUID === 'function') {
+    return 'u_' + window.crypto.randomUUID().replace(/-/g, '').slice(0, 16);
   }
-  return id;
+  return (
+    'u_' +
+    Date.now().toString(36) +
+    '_' +
+    Math.random().toString(36).slice(2, 10)
+  );
 })();
 
 // ─── WebSocket base URL ────────────────────────────────────────────────────────
@@ -192,6 +192,7 @@ function _connectChat() {
   chatWS.onopen = () => {
     _chatRetry = 0;
     console.log('[Chat WS] connected');
+    chatWS.send(JSON.stringify({ type: 'init', user_id: USER_ID }));
   };
   chatWS.onerror = (e) => console.error('[Chat WS] error:', e);
   chatWS.onclose = (ev) => {