refine handling of unknown questions by improving user follow-up prompts and notification logic

implementation/chat.py

@@ -119,9 +119,9 @@ Keep replies concise.
 
 UNKNOWN_SYSTEM_PROMPT = """
 You are acting as Kharisma Rizki Wijanarko (Rizki)'s assistant.
-If you cannot answer confidently, say you don't know then ask the user to provide name and email so rizki can follow up directly.
-Then, use record_unknown_question to record the user's question and send the notification to rizki.
-Send the notification only if the user provided their user details.
+If you cannot answer confidently, say you don't know.
+Then ask the user to share their name and email so Rizki can follow up directly.
+Do not claim you already notified Rizki until the user provides their details.
 Keep replies concise.
 """
 
@@ -286,13 +286,47 @@ def record_unknown_question(question: str, user_details: str | None = None) -> s
     if user_details:
         entry["user_details"] = user_details
     _append_to_json(UNKNOWN_QUESTIONS_PATH, entry)
-    # For unknown questions we want a Telegram ping so Rizki can follow up.
-    # If we don't have user details, still send the question.
-    details_line = f"User Details: {user_details}" if user_details else "User Details: (not provided)"
-    send_telegram_notification(f"New Unknown Question: {question}\n{details_line}")
+    if user_details:
+        send_telegram_notification(f"New Unknown Question: {question}\nUser Details: {user_details}")
     return "Question recorded successfully."
 
 
+def _looks_like_unknown_followup_request(history: list[dict]) -> bool:
+    """
+    Detect whether the assistant previously asked for name+email due to an unknown question.
+    We keep this heuristic intentionally simple and robust to minor prompt changes.
+    """
+    last_assistant = next((m for m in reversed(history) if m.get("role") == "assistant"), None)
+    if not last_assistant:
+        return False
+    text = str(last_assistant.get("content", "")).lower()
+    return (
+        ("i don't know" in text or "i do not know" in text)
+        and ("name" in text)
+        and ("email" in text)
+        and ("follow up" in text or "follow-up" in text or "follow up directly" in text)
+    )
+
+
+def _find_previous_user_question_before_followup(history: list[dict]) -> str | None:
+    """
+    When the assistant asks for name/email after an unknown question, the unknown question is
+    typically the latest user message before that assistant response.
+    """
+    assistant_idx = None
+    for i in range(len(history) - 1, -1, -1):
+        if history[i].get("role") == "assistant":
+            assistant_idx = i
+            break
+    if assistant_idx is None:
+        return None
+    for j in range(assistant_idx - 1, -1, -1):
+        if history[j].get("role") == "user":
+            q = str(history[j].get("content", "")).strip()
+            return q or None
+    return None
+
+
 def _extract_name_email(history: list[dict]) -> tuple[str | None, str | None]:
     """
     Best-effort extraction of user's name/email from conversation text.
@@ -503,6 +537,31 @@ def answer_question(question: str, history: list[dict] = []) -> tuple[str, list[
     Handles multi-turn tool calls in a loop until the model produces a final text response.
     """
     t0 = time.time()
+
+    # If we previously couldn't answer and asked for name/email, treat the next user message
+    # as the follow-up details and send Telegram once we have an email.
+    if _looks_like_unknown_followup_request(history):
+        prev_unknown_q = _find_previous_user_question_before_followup(history)
+        name, email = _extract_name_email(history + [{"role": "user", "content": question}])
+        if not email:
+            return (
+                "Thanks — could you share your email address as well? (And your name, if you haven’t already.)",
+                [],
+            )
+
+        details_lines = []
+        if name:
+            details_lines.append(f"Name: {name}")
+        details_lines.append(f"Email: {email}")
+        if question.strip():
+            details_lines.append(f"Follow-up: {question.strip()}")
+
+        record_unknown_question(prev_unknown_q or "(unknown question not found in history)", user_details="\n".join(details_lines))
+        return (
+            "Thanks — I’ve shared your details with Rizki so he can follow up.",
+            [],
+        )
+
     action = route_action(question, history)
     logger.info(f"[ROUTER] action={action!r}")
 
@@ -523,18 +582,7 @@ def answer_question(question: str, history: list[dict] = []) -> tuple[str, list[
         return answer, []
 
     if action == "unknown":
-        name, email = _extract_name_email(history + [{"role": "user", "content": question}])
-        user_details_parts = []
-        if name:
-            user_details_parts.append(f"Name: {name}")
-        if email:
-            user_details_parts.append(f"Email: {email}")
-        user_details = "\n".join(user_details_parts) if user_details_parts else None
-
-        # Deterministic: always record + notify so Rizki can follow up.
-        record_unknown_question(question, user_details=user_details)
-
-        # Respond to the user (no need for tools here).
+        # Respond to the user (ask for name + email so Rizki can follow up).
         response = completion(
             model=MODEL,
             messages=[{"role": "system", "content": UNKNOWN_SYSTEM_PROMPT}] + history + [