Update main.py

main.py

@@ -10,48 +10,37 @@ from typing import Any, Optional
 import numpy as np
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 
-# Optional but recommended for similarity search.
-# If sentence-transformers is unavailable, the app still works with a fallback.
 try:
     from sentence_transformers import SentenceTransformer
 except Exception:  # pragma: no cover
     SentenceTransformer = None  # type: ignore
 
-try:
-    from sklearn.metrics.pairwise import cosine_similarity
-except Exception:  # pragma: no cover
-    cosine_similarity = None  # type: ignore
-
 
 APP_TITLE = "Human Intelligence"
 DATA_DIR = Path(os.environ.get("DATA_DIR", "/data"))
-THREADS_DIR = DATA_DIR / "threads"
-INDEX_FILE = DATA_DIR / "index.json"
+CONVERSATIONS_FILE = DATA_DIR / "conversations.json"
 EMBED_FILE = DATA_DIR / "embeddings.json"
 TEMPLATES_DIR = Path("/app/templates")
-SIMILARITY_THRESHOLD = float(os.environ.get("SIMILARITY_THRESHOLD", "0.82"))
+
+SIMILARITY_THRESHOLD = float(os.environ.get("SIMILARITY_THRESHOLD", "0.78"))
+EMBED_MODEL_NAME = os.environ.get(
+    "EMBED_MODEL_NAME",
+    "sentence-transformers/paraphrase-MiniLM-L3-v2",
+)
 
 DATA_DIR.mkdir(parents=True, exist_ok=True)
-THREADS_DIR.mkdir(parents=True, exist_ok=True)
 TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
 
 app = FastAPI(title=APP_TITLE)
 templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
 
-# Serve any public assets you may add later.
-app.mount("/data", StaticFiles(directory=str(DATA_DIR)), name="data")
-
 _embed_model = None
 
 
-# ---------------------------------------------------------------------
-# Utilities
-# ---------------------------------------------------------------------
 def now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
 
 
 def read_json(path: Path, default: Any):
@@ -65,39 +54,38 @@ def read_json(path: Path, default: Any):
 
 def write_json(path: Path, data: Any) -> None:
     tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2, default=str), encoding="utf-8")
+    tmp.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2, default=str),
+        encoding="utf-8",
+    )
     tmp.replace(path)
 
 
-def get_username(request: Request, payload: dict | None = None) -> str:
-    """
-    Priority:
-      1) X-User header
-      2) JSON payload username
-      3) guest
-    This keeps the app simple and deployment-friendly.
-    """
-    header_name = request.headers.get("x-user", "").strip()
-    if header_name:
-        return header_name
+def get_client_id(request: Request, payload: dict | None = None) -> str:
+    header_value = request.headers.get("x-client-id", "").strip()
+    if header_value:
+        return header_value
 
     if payload:
-        p_name = str(payload.get("username", "")).strip()
-        if p_name:
-            return p_name
+        payload_value = str(payload.get("client_id", "")).strip()
+        if payload_value:
+            return payload_value
+
+    return "anon"
+
 
-    return "Guest"
+def anon_label(client_id: str) -> str:
+    if not client_id or client_id == "anon":
+        return "Anonymous"
+    return "Anonymous"
 
 
-# ---------------------------------------------------------------------
-# Embeddings / similarity
-# ---------------------------------------------------------------------
 def load_embed_model():
     global _embed_model
     if _embed_model is None:
         if SentenceTransformer is None:
             return None
-        _embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+        _embed_model = SentenceTransformer(EMBED_MODEL_NAME)
     return _embed_model
 
 
@@ -105,282 +93,419 @@ def embed_text(text: str) -> list[float]:
     model = load_embed_model()
     if model is None:
         return []
-
     vec = model.encode(text, normalize_embeddings=True)
-    return vec.tolist()
+    if hasattr(vec, "tolist"):
+        return vec.tolist()
+    return list(vec)
 
 
-def load_embed_index() -> dict:
-    return read_json(EMBED_FILE, {})
+def load_embed_index() -> dict[str, dict[str, Any]]:
+    data = read_json(EMBED_FILE, {})
+    return data if isinstance(data, dict) else {}
 
 
-def save_embed_index(idx: dict) -> None:
+def save_embed_index(idx: dict[str, dict[str, Any]]) -> None:
     write_json(EMBED_FILE, idx)
 
 
-def find_similar_thread(question: str) -> Optional[tuple[str, float]]:
-    idx = load_embed_index()
-    if not idx:
-        return None
+def load_conversations() -> list[dict[str, Any]]:
+    data = read_json(CONVERSATIONS_FILE, [])
+    if isinstance(data, dict) and "conversations" in data:
+        data = data["conversations"]
+    return data if isinstance(data, list) else []
+
+
+def save_conversations(conversations: list[dict[str, Any]]) -> None:
+    write_json(CONVERSATIONS_FILE, conversations)
+
+
+def normalize_version(version: dict[str, Any]) -> dict[str, Any]:
+    v = dict(version or {})
+    v.setdefault("id", uuid.uuid4().hex)
+    v.setdefault("text", "")
+    v.setdefault("author", "Anonymous")
+    v.setdefault("created_at", now_iso())
+    v.setdefault("votes", 0)
+    v.setdefault("votes_by_client", {})
+    if not isinstance(v["votes_by_client"], dict):
+        v["votes_by_client"] = {}
+    v["votes"] = int(v.get("votes", 0))
+    return v
+
+
+def normalize_answer(answer: dict[str, Any]) -> dict[str, Any]:
+    a = dict(answer or {})
+    a.setdefault("id", uuid.uuid4().hex)
+    a.setdefault("versions", [])
+    a.setdefault("active_version", "")
+    a.setdefault("created_at", now_iso())
+    a.setdefault("updated_at", a["created_at"])
+
+    versions = [
+        normalize_version(v)
+        for v in a.get("versions", [])
+        if isinstance(v, dict)
+    ]
+    a["versions"] = versions
+
+    if versions:
+        version_ids = {v["id"] for v in versions}
+        if a["active_version"] not in version_ids:
+            a["active_version"] = max(
+                versions,
+                key=lambda v: (int(v.get("votes", 0)), str(v.get("created_at", ""))),
+            )["id"]
+
+    return a
+
+
+def normalize_conversation(conversation: dict[str, Any]) -> dict[str, Any]:
+    c = dict(conversation or {})
+    c.setdefault("id", uuid.uuid4().hex)
+    c.setdefault("question", "")
+    c.setdefault("author", "Anonymous")
+    c.setdefault("created_at", now_iso())
+    c.setdefault("updated_at", c["created_at"])
+    c.setdefault("turns", [])
+    c.setdefault("answers", [])
+
+    turns: list[dict[str, Any]] = []
+    for turn in c.get("turns", []):
+        if not isinstance(turn, dict):
+            continue
+        t = dict(turn)
+        t.setdefault("id", uuid.uuid4().hex)
+        t.setdefault("role", "user")
+        t.setdefault("text", "")
+        t.setdefault("author", "Anonymous")
+        t.setdefault("ts", now_iso())
+        turns.append(t)
+    c["turns"] = turns
+
+    c["answers"] = [
+        normalize_answer(a)
+        for a in c.get("answers", [])
+        if isinstance(a, dict)
+    ]
+
+    if not c["turns"] and c["question"]:
+        c["turns"].append(
+            {
+                "id": uuid.uuid4().hex,
+                "role": "user",
+                "text": c["question"],
+                "author": c.get("author", "Anonymous"),
+                "ts": c["created_at"],
+            }
+        )
 
-    if cosine_similarity is None:
-        return None
+    return c
 
-    q_vec = embed_text(question)
-    if not q_vec:
-        return None
 
-    ids = list(idx.keys())
-    vecs = np.array([idx[tid]["vector"] for tid in ids], dtype=float)
-
-    if vecs.size == 0:
+def load_conversation(conversation_id: str) -> Optional[dict[str, Any]]:
+    if not conversation_id:
         return None
-
-    sims = cosine_similarity(np.array(q_vec, dtype=float).reshape(1, -1), vecs)[0]
-    best_i = int(np.argmax(sims))
-    score = float(sims[best_i])
-
-    if score >= SIMILARITY_THRESHOLD:
-        return ids[best_i], score
+    for conv in load_conversations():
+        if str(conv.get("id")) == conversation_id:
+            return normalize_conversation(conv)
     return None
 
 
-# ---------------------------------------------------------------------
-# Storage
-# ---------------------------------------------------------------------
-def load_index() -> list[dict]:
-    return read_json(INDEX_FILE, [])
-
+def save_conversation(conversation: dict[str, Any]) -> dict[str, Any]:
+    conversation = normalize_conversation(conversation)
+    conversation["updated_at"] = now_iso()
 
-def save_index(idx: list[dict]) -> None:
-    write_json(INDEX_FILE, idx)
-
-
-def thread_path(tid: str) -> Path:
-    return THREADS_DIR / f"{tid}.json"
+    conversations = [normalize_conversation(c) for c in load_conversations()]
+    replaced = False
+    for i, existing in enumerate(conversations):
+        if str(existing.get("id")) == str(conversation["id"]):
+            conversations[i] = conversation
+            replaced = True
+            break
+    if not replaced:
+        conversations.insert(0, conversation)
 
+    save_conversations(conversations)
+    return conversation
 
-def load_thread(tid: str) -> Optional[dict]:
-    return read_json(thread_path(tid), None)
 
+def ensure_embedding(conversation: dict[str, Any]) -> None:
+    question = str(conversation.get("question", "")).strip()
+    if not question:
+        return
 
-def save_thread(thread: dict) -> None:
-    write_json(thread_path(thread["id"]), thread)
+    vec = embed_text(question)
+    if not vec:
+        return
 
+    idx = load_embed_index()
+    idx[str(conversation["id"])] = {
+        "question": question,
+        "vector": vec,
+    }
+    save_embed_index(idx)
 
-def ensure_thread_schema(thread: dict) -> dict:
-    thread.setdefault("id", uuid.uuid4().hex)
-    thread.setdefault("question", "")
-    thread.setdefault("author", "Guest")
-    thread.setdefault("created_at", now_iso())
-    thread.setdefault("messages", [])
-    return thread
 
+def find_similar_conversation(question: str) -> Optional[dict[str, Any]]:
+    idx = load_embed_index()
+    if not idx or SentenceTransformer is None:
+        return None
 
-# ---------------------------------------------------------------------
-# Content safety
-# ---------------------------------------------------------------------
-_toxic_pipe = None
+    q_vec = np.array(embed_text(question), dtype=float)
+    if q_vec.size == 0:
+        return None
 
-def load_safety_pipe():
-    global _toxic_pipe
-    if _toxic_pipe is None:
-        try:
-            from transformers import pipeline
-            _toxic_pipe = pipeline(
-                "text-classification",
-                model="unitary/toxic-bert",
-                device=-1,
-                top_k=None,
-            )
-        except Exception:
-            _toxic_pipe = False
-    return _toxic_pipe
+    ids = list(idx.keys())
+    try:
+        vecs = np.array([idx[cid]["vector"] for cid in ids], dtype=float)
+    except Exception:
+        return None
 
+    if vecs.size == 0 or vecs.ndim != 2:
+        return None
+    if vecs.shape[1] != q_vec.shape[0]:
+        return None
 
-def is_safe(text: str) -> tuple[bool, str]:
-    if not text or not text.strip():
-        return False, "empty"
+    sims = vecs @ q_vec
+    best_i = int(np.argmax(sims))
+    score = float(sims[best_i])
 
-    pipe = load_safety_pipe()
-    if pipe is False:
-        return True, "ok"
+    if score < SIMILARITY_THRESHOLD:
+        return None
 
-    try:
-        results = pipe(text[:512])[0]
-        for r in results:
-            label = str(r.get("label", "")).lower()
-            score = float(r.get("score", 0.0))
-            if label != "non-toxic" and score > 0.70:
-                return False, label or "unsafe"
-        return True, "ok"
-    except Exception:
-        return True, "ok"
+    conv = load_conversation(ids[best_i])
+    if conv is None:
+        return None
 
+    return {
+        "conversation": conv,
+        "score": score,
+    }
 
-# ---------------------------------------------------------------------
-# Core operations
-# ---------------------------------------------------------------------
-def create_thread(question: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(question)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
 
-    tid = uuid.uuid4().hex
-    thread = {
-        "id": tid,
+def create_conversation(question: str, author: str = "Anonymous") -> dict[str, Any]:
+    question = question.strip()
+    now = now_iso()
+    conversation = {
+        "id": uuid.uuid4().hex,
         "question": question,
         "author": author,
-        "created_at": now_iso(),
-        "messages": [],
+        "created_at": now,
+        "updated_at": now,
+        "turns": [
+            {
+                "id": uuid.uuid4().hex,
+                "role": "user",
+                "text": question,
+                "author": author,
+                "ts": now,
+            }
+        ],
+        "answers": [],
     }
-    save_thread(thread)
+    conversation = save_conversation(conversation)
+    ensure_embedding(conversation)
+    return conversation
 
-    idx = load_index()
-    idx.insert(
-        0,
-        {
-            "id": tid,
-            "title": question[:120],
-            "created_at": thread["created_at"],
-            "author": author,
-            "reply_count": 0,
-        },
+
+def active_version(answer: dict[str, Any]) -> Optional[dict[str, Any]]:
+    versions = answer.get("versions", [])
+    if not versions:
+        return None
+
+    active_id = answer.get("active_version")
+    for version in versions:
+        if version.get("id") == active_id:
+            return version
+
+    return max(
+        versions,
+        key=lambda v: (int(v.get("votes", 0)), str(v.get("created_at", ""))),
     )
-    save_index(idx)
 
-    emb_idx = load_embed_index()
-    vec = embed_text(question)
-    if vec:
-        emb_idx[tid] = {"question": question, "vector": vec}
-        save_embed_index(emb_idx)
 
-    return thread, "ok"
+def answer_score(answer: dict[str, Any]) -> tuple[int, str]:
+    av = active_version(answer)
+    if av is None:
+        return 0, str(answer.get("created_at", ""))
+    return int(av.get("votes", 0)), str(answer.get("created_at", ""))
 
 
-def add_answer(tid: str, text: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(text)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
+def best_answer_payload(conversation: dict[str, Any]) -> Optional[dict[str, Any]]:
+    answers = conversation.get("answers", [])
+    if not answers:
+        return None
 
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
+    best = max(answers, key=answer_score)
+    av = active_version(best)
+    if av is None:
+        return None
 
-    version = {
-        "id": uuid.uuid4().hex,
-        "text": text,
-        "author": author,
-        "created_at": now_iso(),
-        "votes": 0,
-        "voters": [],
-    }
-    message = {
-        "id": uuid.uuid4().hex,
-        "versions": [version],
-        "active_version": version["id"],
-        "created_at": version["created_at"],
+    return {
+        "answer_id": best["id"],
+        "version_id": av["id"],
+        "text": av["text"],
+        "votes": int(av.get("votes", 0)),
+        "author": av.get("author", "Anonymous"),
+        "created_at": av.get("created_at", ""),
     }
-    thread["messages"].append(message)
-    save_thread(thread)
 
-    idx = load_index()
-    for entry in idx:
-        if entry["id"] == tid:
-            entry["reply_count"] = len(thread["messages"])
-            break
-    save_index(idx)
 
-    return thread, "ok"
+def add_answer(
+    conversation_id: str,
+    text: str,
+    author: str = "Anonymous",
+    question_if_new: str | None = None,
+) -> tuple[Optional[dict[str, Any]], str]:
+    text = text.strip()
+    if not text:
+        return None, "empty answer"
+
+    conversation = load_conversation(conversation_id)
+    if conversation is None:
+        if not question_if_new:
+            return None, "conversation not found"
+        conversation = create_conversation(question_if_new, author)
+
+    now = now_iso()
+    version = normalize_version(
+        {
+            "text": text,
+            "author": author,
+            "created_at": now,
+            "votes": 0,
+            "votes_by_client": {},
+        }
+    )
+    answer = normalize_answer(
+        {
+            "id": uuid.uuid4().hex,
+            "versions": [version],
+            "active_version": version["id"],
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
 
+    conversation["answers"].append(answer)
+    conversation["turns"].append(
+        {
+            "id": uuid.uuid4().hex,
+            "role": "assistant",
+            "text": text,
+            "author": author,
+            "answer_id": answer["id"],
+            "version_id": version["id"],
+            "ts": now,
+        }
+    )
 
-def propose_version(tid: str, msg_id: str, text: str, author: str) -> tuple[Optional[dict], str]:
-    ok, reason = is_safe(text)
-    if not ok:
-        return None, f"Blocked: content flagged as {reason}."
+    save_conversation(conversation)
+    return conversation, "ok"
 
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
 
-    for msg in thread["messages"]:
-        if msg["id"] == msg_id:
-            version = {
-                "id": uuid.uuid4().hex,
+def propose_version(
+    conversation_id: str,
+    answer_id: str,
+    text: str,
+    author: str = "Anonymous",
+) -> tuple[Optional[dict[str, Any]], str]:
+    text = text.strip()
+    if not text:
+        return None, "empty proposal"
+
+    conversation = load_conversation(conversation_id)
+    if conversation is None:
+        return None, "conversation not found"
+
+    for answer in conversation["answers"]:
+        if str(answer.get("id")) != answer_id:
+            continue
+
+        now = now_iso()
+        version = normalize_version(
+            {
                 "text": text,
                 "author": author,
-                "created_at": now_iso(),
+                "created_at": now,
                 "votes": 0,
-                "voters": [],
+                "votes_by_client": {},
             }
-            msg["versions"].append(version)
-            save_thread(thread)
-            return thread, "ok"
+        )
+        answer["versions"].append(version)
+        answer["updated_at"] = now
+        save_conversation(conversation)
+        return conversation, "ok"
+
+    return None, "answer not found"
+
+
+def vote_version(
+    conversation_id: str,
+    answer_id: str,
+    version_id: str,
+    client_id: str,
+    delta: int,
+) -> tuple[Optional[dict[str, Any]], str]:
+    conversation = load_conversation(conversation_id)
+    if conversation is None:
+        return None, "conversation not found"
 
-    return None, "Message not found."
+    delta = 1 if int(delta) >= 0 else -1
 
+    for answer in conversation["answers"]:
+        if str(answer.get("id")) != answer_id:
+            continue
 
-def vote_version(tid: str, msg_id: str, version_id: str, username: str) -> tuple[Optional[dict], str]:
-    thread = load_thread(tid)
-    if thread is None:
-        return None, "Thread not found."
+        for version in answer.get("versions", []):
+            if str(version.get("id")) != version_id:
+                continue
 
-    for msg in thread["messages"]:
-        if msg["id"] == msg_id:
-            for v in msg["versions"]:
-                if v["id"] == version_id:
-                    if username in v["voters"]:
-                        return thread, "already_voted"
-                    v["votes"] += 1
-                    v["voters"].append(username)
-                    break
+            votes_by_client = version.setdefault("votes_by_client", {})
+            if not isinstance(votes_by_client, dict):
+                votes_by_client = {}
+                version["votes_by_client"] = votes_by_client
 
-            msg["active_version"] = max(msg["versions"], key=lambda x: x["votes"])["id"]
-            save_thread(thread)
-            return thread, "ok"
+            current = int(votes_by_client.get(client_id, 0))
+            if current == delta:
+                return conversation, "already_voted"
 
-    return None, "Message not found."
+            votes_by_client[client_id] = delta
+            version["votes"] = int(sum(int(v) for v in votes_by_client.values()))
 
+            if answer.get("versions"):
+                answer["active_version"] = max(
+                    answer["versions"],
+                    key=lambda v: (int(v.get("votes", 0)), str(v.get("created_at", ""))),
+                )["id"]
 
-def get_active_version(msg: dict) -> dict:
-    vid = msg.get("active_version")
-    for v in msg.get("versions", []):
-        if v.get("id") == vid:
-            return v
-    return msg.get("versions", [{}])[0]
+            conversation["updated_at"] = now_iso()
+            save_conversation(conversation)
+            return conversation, "ok"
+
+    return None, "version not found"
 
 
-# ---------------------------------------------------------------------
-# API
-# ---------------------------------------------------------------------
 @app.get("/", response_class=HTMLResponse)
 def home(request: Request):
+    init = {
+        "ok": True,
+        "client_id": get_client_id(request),
+        "conversation": None,
+    }
     return templates.TemplateResponse(
         "index.html",
         {
             "request": request,
             "app_title": APP_TITLE,
-            "init_json": json.dumps(
-                {
-                    "ok": True,
-                    "username": get_username(request),
-                    "threads": load_index(),
-                },
-                ensure_ascii=False,
-            ),
+            "init_json": json.dumps(init, ensure_ascii=False),
         },
     )
 
 
-@app.get("/api/init")
-def api_init(request: Request):
-    return JSONResponse(
-        {
-            "ok": True,
-            "username": get_username(request),
-            "threads": load_index(),
-        }
-    )
+@app.get("/health")
+def health():
+    return {"ok": True}
 
 
 @app.post("/api")
@@ -391,82 +516,120 @@ async def api(request: Request):
         return JSONResponse({"ok": False, "error": "bad payload"})
 
     action = str(payload.get("action", ""))
-    username = get_username(request, payload)
+    client_id = get_client_id(request, payload)
+    author = anon_label(client_id)
 
     if action == "init":
-        return JSONResponse({"ok": True, "username": username, "threads": load_index()})
-
-    if action == "list_threads":
-        return JSONResponse({"ok": True, "threads": load_index()})
+        conversation_id = str(payload.get("conversation_id", "")).strip()
+        conversation = load_conversation(conversation_id) if conversation_id else None
+        return JSONResponse(
+            {
+                "ok": True,
+                "client_id": client_id,
+                "conversation": conversation,
+            }
+        )
 
-    if action == "get_thread":
-        tid = str(payload.get("thread_id", ""))
-        thread = load_thread(tid)
-        if thread is None:
+    if action == "get_conversation":
+        conversation_id = str(payload.get("conversation_id", "")).strip()
+        conversation = load_conversation(conversation_id)
+        if conversation is None:
             return JSONResponse({"ok": False, "error": "not found"})
-        return JSONResponse({"ok": True, "thread": thread})
+        return JSONResponse({"ok": True, "conversation": conversation})
 
-    if action == "new_thread":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
+    if action == "ask":
         question = str(payload.get("question", "")).strip()
         if not question:
             return JSONResponse({"ok": False, "error": "empty question"})
-        sim = find_similar_thread(question)
-        thread, msg = create_thread(question, username)
-        if thread is None:
-            return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread, "similar": sim is not None})
 
-    if action == "add_answer":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
+        match = find_similar_conversation(question)
+        if match and match.get("conversation"):
+            conversation = match["conversation"]
+            best = best_answer_payload(conversation)
+            assistant_text = (
+                best["text"]
+                if best is not None
+                else "No answer yet. You can write one."
+            )
+            return JSONResponse(
+                {
+                    "ok": True,
+                    "matched": True,
+                    "similarity": match["score"],
+                    "conversation": conversation,
+                    "assistant_text": assistant_text,
+                    "best_answer": best,
+                }
+            )
+
+        conversation = create_conversation(question, author)
+        return JSONResponse(
+            {
+                "ok": True,
+                "matched": False,
+                "conversation": conversation,
+                "assistant_text": "No answer yet. You can write one.",
+                "best_answer": None,
+            }
+        )
+
+    if action == "answer":
+        conversation_id = str(payload.get("conversation_id", "")).strip()
         text = str(payload.get("text", "")).strip()
-        if not text:
-            return JSONResponse({"ok": False, "error": "empty answer"})
-        thread, msg = add_answer(tid, text, username)
-        if thread is None:
+        question = str(payload.get("question", "")).strip() or None
+
+        conversation, msg = add_answer(
+            conversation_id=conversation_id,
+            text=text,
+            author=author,
+            question_if_new=question,
+        )
+        if conversation is None:
             return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread})
+
+        return JSONResponse({"ok": True, "conversation": conversation})
 
     if action == "propose":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
-        msg_id = str(payload.get("msg_id", ""))
+        conversation_id = str(payload.get("conversation_id", "")).strip()
+        answer_id = str(payload.get("answer_id", "")).strip()
         text = str(payload.get("text", "")).strip()
-        if not text:
-            return JSONResponse({"ok": False, "error": "empty proposal"})
-        thread, msg = propose_version(tid, msg_id, text, username)
-        if thread is None:
+
+        conversation, msg = propose_version(
+            conversation_id=conversation_id,
+            answer_id=answer_id,
+            text=text,
+            author=author,
+        )
+        if conversation is None:
             return JSONResponse({"ok": False, "error": msg})
-        return JSONResponse({"ok": True, "thread": thread})
+
+        return JSONResponse({"ok": True, "conversation": conversation})
 
     if action == "vote":
-        if not username or username == "Guest":
-            return JSONResponse({"ok": False, "error": "not signed in"})
-        tid = str(payload.get("thread_id", ""))
-        msg_id = str(payload.get("msg_id", ""))
-        version_id = str(payload.get("version_id", ""))
-        thread, msg = vote_version(tid, msg_id, version_id, username)
-        if thread is None:
+        conversation_id = str(payload.get("conversation_id", "")).strip()
+        answer_id = str(payload.get("answer_id", "")).strip()
+        version_id = str(payload.get("version_id", "")).strip()
+        delta = int(payload.get("delta", 1))
+
+        conversation, msg = vote_version(
+            conversation_id=conversation_id,
+            answer_id=answer_id,
+            version_id=version_id,
+            client_id=client_id,
+            delta=delta,
+        )
+        if conversation is None:
             return JSONResponse({"ok": False, "error": msg})
+
         if msg == "already_voted":
             return JSONResponse({"ok": False, "error": "already voted"})
-        return JSONResponse({"ok": True, "thread": thread})
-
-    return JSONResponse({"ok": False, "error": f"unknown action: {action}"})
 
+        return JSONResponse({"ok": True, "conversation": conversation})
 
-# ---------------------------------------------------------------------
-# Optional healthcheck
-# ---------------------------------------------------------------------
-@app.get("/health")
-def health():
-    return {"ok": True}
+    return JSONResponse({"ok": False, "error": f"unknown action: {action}"})
 
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)
+
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)