Update app.py

app.py

@@ -45,7 +45,6 @@ llm = ChatGroq(
 )
 
 def clean_notes_with_bloatectomy(text: str, style: str = "remov") -> str:
-    """Helper function to clean up text using the bloatectomy library."""
     try:
         b = bloatectomy(text, style=style, output="html")
         tokens = getattr(b, "tokens", None)
@@ -56,18 +55,18 @@ def clean_notes_with_bloatectomy(text: str, style: str = "remov") -> str:
         logger.exception("Bloatectomy cleaning failed; returning original text")
         return text
 
-# --- Agent prompt instructions ---
-# Important change: the assistant should NOT insist on PID at the start of conversation.
-# It should only ask for patient ID when the user asks for something that requires accessing previous medical records.
-# Also, avoid asking for additional identity details (name/DOB) purely for "verification" — accept PID as sufficient for record access in this flow.
 PATIENT_ASSISTANT_PROMPT = """
-You are a patient assistant helping to analyze medical records and reports. You should be helpful for general medical questions even when no patient ID (PID) is provided.
+You are a helpful medical assistant acting as a doctor. You respond naturally to greetings and general medical questions without asking for patient ID unless the user requests information about prior medical records
 
 Behavior rules (follow these strictly):
 - Do NOT ask for the patient ID at the start of every conversation. Only request the PID when the user's question explicitly requires accessing prior medical records (for example: "show my previous lab report", "what does my thyroid test from last month say", "what was my doctor's note for PID 12345", etc.).
 - When you do ask for a PID, be concise and ask only for the PID (e.g., "Please provide the patient ID (PID) to retrieve previous records."). Do not request name/DOB/other verification unless the user explicitly asks for an extra verification step.
 - If the user supplies a PID in their message (patterns like "pid 5678", "p5678", "patient id: 5678"), accept and use it — do not ask again.
-- Avoid repeating unnecessary clarifying questions. If the user has already given the PID, proceed to use it. If you previously asked for the PID and the user didn't provide it, ask once more succinctly and then offer to help with general guidance without records.
+- Never ask for the PID if it is already known. If the user provides a different PID later, update it and proceed accordingly.
+- Avoid repeating unnecessary clarifying questions. If you previously asked for the PID and the user didn't provide it, ask once more succinctly and then offer to help with general guidance without records.
+- When analyzing medical reports, trust the patient ID from the folder or query context as the source of truth.
+- **If the report text mentions a different patient ID or name, do not refuse to answer but mention the discrepancy politely and proceed to answer based on the available data.**
+- **Always protect patient privacy and avoid sharing information from reports not matching the current PID unless explicitly requested and with a clear disclaimer.**
 
 STRICT OUTPUT FORMAT (JSON ONLY):
 Return a single JSON object with the following keys:
@@ -82,9 +81,8 @@ Rules:
 - Do not make up information that is not present in the provided medical reports or conversation history.
 """
 
-# --- Helper utilities ---
 PID_PATTERN = re.compile(r"(?:\bpid\b|\bpatient\s*id\b|\bp\b)\s*[:#\-]?\s*(p?\d+)", re.IGNORECASE)
-DIGIT_PATTERN = re.compile(r"\b(p?\d{3,})\b")  # fallback: any 3+ digit cluster
+DIGIT_PATTERN = re.compile(r"\b(p?\d{3,})\b")
 
 RECORD_KEYWORDS = [
     "report", "lab", "result", "results", "previous", "history", "record", "records",
@@ -92,58 +90,39 @@ RECORD_KEYWORDS = [
     "prescription", "doctor", "referral", "visit", "consultation",
 ]
 
-
 def extract_pid_from_text(text: str) -> str | None:
-    """Try to extract PID from a free-form text string.
-    Accepts patterns like: 'pid 5678', 'p5678', 'patient id: 5678', or a bare number if clearly intended as an id.
-    """
     if not text:
         return None
     m = PID_PATTERN.search(text)
     if m:
         return m.group(1).lstrip('pP')
-    # fallback: look for explicit mention like 'pid p5678' with different casing
-    # final fallback: any 3+ digit cluster but only if message also contains a record keyword
     if any(k in text.lower() for k in RECORD_KEYWORDS):
         m2 = DIGIT_PATTERN.search(text)
         if m2:
             return m2.group(1).lstrip('pP')
     return None
 
-
 def needs_pid_for_query(text: str) -> bool:
-    """Decide whether the user's message requires looking up prior records (thus needs a PID).
-    Simple heuristic: if message contains any keyword from RECORD_KEYWORDS or explicit phrases asking for previous tests/records.
-    """
     if not text:
         return False
     lower = text.lower()
-    # direct phrases that clearly require historical records
     phrases = ["previous report", "previous lab", "my report", "my records", "past report", "last report", "previous test", "previous results"]
     if any(p in lower for p in phrases):
         return True
-    # if message contains any record-related keyword, treat as needing PID
     if any(k in lower for k in RECORD_KEYWORDS):
         return True
     return False
 
-# --- JSON extraction helper (unchanged) ---
 def extract_json_from_llm_response(raw_response: str) -> dict:
-    """Safely extracts a JSON object from a string that might contain extra text or markdown."""
     default = {
         "assistant_reply": "I'm sorry — I couldn't understand that. Could you please rephrase?",
         "patientDetails": {},
         "conversationSummary": "",
     }
-
     if not raw_response or not isinstance(raw_response, str):
         return default
-
-    # Find the JSON object, ignoring any markdown code fences
     m = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
     json_string = m.group(1).strip() if m else raw_response
-
-    # Find the first opening brace and the last closing brace
     first = json_string.find('{')
     last = json_string.rfind('}')
     if first == -1 or last == -1 or first >= last:
@@ -152,18 +131,13 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
         except Exception:
             logger.warning("Could not locate JSON braces in LLM output. Falling back to default.")
             return default
-
     candidate = json_string[first:last+1]
-    # Remove trailing commas that might cause parsing issues
     candidate = re.sub(r',\s*(?=[}\]])', '', candidate)
-
     try:
         parsed = json.loads(candidate)
     except Exception as e:
         logger.warning("Failed to parse JSON from LLM output: %s", e)
         return default
-
-    # Basic validation of the parsed JSON
     if isinstance(parsed, dict) and "assistant_reply" in parsed and isinstance(parsed["assistant_reply"], str) and parsed["assistant_reply"].strip():
         parsed.setdefault("patientDetails", {})
         parsed.setdefault("conversationSummary", "")
@@ -172,27 +146,47 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
         logger.warning("Parsed JSON missing 'assistant_reply' or invalid format. Returning default.")
         return default
 
+def extract_details_from_user_message(user_message: str) -> dict:
+    """
+    Use the LLM to extract patient details (name, contact, city, problem) from the user's last message.
+    Returns a dict with any found fields.
+    """
+    extraction_prompt = f"""
+Extract any patient details from the following user message. Return a JSON object with keys name, contact, city, problem.
+If a field is not present, omit it.
+
+User message:
+\"\"\"{user_message}\"\"\"
+"""
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant that extracts patient details from user messages."},
+        {"role": "user", "content": extraction_prompt}
+    ]
+    try:
+        response = llm.invoke(messages)
+        content = response.content if hasattr(response, "content") else str(response)
+        extracted = extract_json_from_llm_response(content)
+        return extracted.get("patientDetails", extracted)  # support both keys
+    except Exception as e:
+        logger.warning(f"Detail extraction failed: {e}")
+        return {}
+
 # --- Flask routes ---
 @app.route("/", methods=["GET"])
 def serve_frontend():
-    """Serves the frontend HTML file."""
     try:
-        return app.send_static_file("frontend.html")
+        return app.send_static_file("front1.html")
     except Exception:
         return "<h3>frontend.html not found in static/ — please add your frontend.html there.</h3>", 404
 
 @app.route("/upload_report", methods=["POST"])
 def upload_report():
-    """Handles the upload of a new PDF report for a specific patient."""
     if 'report' not in request.files:
         return jsonify({"error": "No file part in the request"}), 400
-
     file = request.files['report']
     patient_id = request.form.get("patient_id")
-
     if file.filename == '' or not patient_id:
         return jsonify({"error": "No selected file or patient ID"}), 400
-
     if file:
         filename = secure_filename(file.filename)
         patient_folder = REPORTS_ROOT / f"{patient_id}"
@@ -203,41 +197,57 @@ def upload_report():
 
 @app.route("/chat", methods=["POST"])
 def chat():
-    """Handles the chat conversation with the assistant."""
     data = request.get_json(force=True)
     if not isinstance(data, dict):
         return jsonify({"error": "invalid request body"}), 400
 
     chat_history = data.get("chat_history") or []
     patient_state = data.get("patient_state") or {}
-    patient_id = patient_state.get("patientDetails", {}).get("pid")
+    patient_details = patient_state.get("patientDetails", {})
+    patient_id = patient_details.get("pid")
 
-    # --- Prepare the state for the LLM ---
     state = patient_state.copy()
     state.setdefault("asked_for_pid", False)
     state.setdefault("conversationSummary", state.get("conversationSummary", ""))
     state["lastUserMessage"] = ""
     if chat_history:
-        # Find the last user message
         for msg in reversed(chat_history):
             if msg.get("role") == "user" and msg.get("content"):
                 state["lastUserMessage"] = msg["content"]
                 break
 
-    # Try to infer PID from the last message (user might include it inline)
     inferred_pid = extract_pid_from_text(state.get("lastUserMessage", "") or "")
-    if not patient_id and inferred_pid:
+    patient_id_str = str(patient_id) if patient_id is not None else ""
+    if (not patient_id_str or patient_id_str.strip() == "") and inferred_pid:
         logger.info("Inferred PID from user message: %s", inferred_pid)
         state.setdefault("patientDetails", {})["pid"] = inferred_pid
         patient_id = inferred_pid
 
     combined_text_parts = []
 
-    # Decide whether this query actually needs patient records
     wants_records = needs_pid_for_query(state.get("lastUserMessage", "") or "")
 
-    # If a PID is known, load the patient reports.
-    if patient_id:
+    if wants_records and (not patient_id or patient_id_str.strip() == ""):
+        if not state.get("asked_for_pid", False):
+            assistant_reply = "Please provide the patient ID (PID) to retrieve previous records."
+            state["asked_for_pid"] = True
+            response_payload = {
+                "assistant_reply": assistant_reply,
+                "updated_state": state,
+            }
+            return jsonify(response_payload)
+        else:
+            assistant_reply = (
+                "I still need your Patient ID (PID) to access your records. "
+                "If you prefer, I can help with general medical questions instead."
+            )
+            response_payload = {
+                "assistant_reply": assistant_reply,
+                "updated_state": state,
+            }
+            return jsonify(response_payload)
+
+    if patient_id and patient_id_str.strip() != "":
         patient_folder = REPORTS_ROOT / f"{patient_id}"
         if patient_folder.exists() and patient_folder.is_dir():
             for fname in sorted(os.listdir(patient_folder)):
@@ -260,26 +270,17 @@ def chat():
                     if cleaned:
                         combined_text_parts.append(cleaned)
 
-    # Update the conversation summary with the parsed documents
-    base_summary = state.get("conversationSummary", "") or ""
-    docs_summary = "\n\n".join(combined_text_parts)
-    if docs_summary:
-        state["conversationSummary"] = (base_summary + "\n\n" + docs_summary).strip()
-    else:
-        state["conversationSummary"] = base_summary
+        base_summary = state.get("conversationSummary", "") or ""
+        docs_summary = "\n\n".join(combined_text_parts)
+        if docs_summary:
+            state["conversationSummary"] = (base_summary + "\n\n" + docs_summary).strip()
+        else:
+            state["conversationSummary"] = base_summary
 
-    # Build the user prompt for the LLM. We explicitly tell the LLM whether a PID is available and whether the user's message requires records.
-    if patient_id:
+    if patient_id and patient_id_str.strip() != "":
         action_hint = f"Use the patient ID {patient_id} to retrieve and summarize any relevant reports."
     else:
-        if wants_records and not state.get("asked_for_pid", False):
-            action_hint = "The user is asking for information that requires prior medical records. Ask succinctly for the Patient ID (PID) if needed."
-            # mark that we asked for PID so we don't repeatedly ask
-            state["asked_for_pid"] = True
-        elif wants_records and state.get("asked_for_pid", False):
-            action_hint = "The user previously was asked for a PID but has not supplied one. Ask once more concisely for the PID; otherwise offer to help with general guidance without accessing records."
-        else:
-            action_hint = "No PID provided and the user's request does not need prior records. Provide helpful, general medical guidance and offer to retrieve records if the user later supplies a PID."
+        action_hint = "No PID provided and the user's request does not need prior records. Provide helpful, general medical guidance and offer to retrieve records if the user later supplies a PID."
 
     user_prompt = f"""
 Current patientDetails: {json.dumps(state.get("patientDetails", {}))}
@@ -318,12 +319,45 @@ Return ONLY valid JSON with keys: assistant_reply, patientDetails, conversationS
     state.setdefault("patientDetails", {}).update(updated_state.get("patientDetails", {}))
     state["conversationSummary"] = updated_state.get("conversationSummary", state.get("conversationSummary", ""))
 
+    # --- New: Extract details from last user message to update patientDetails ---
+    REQUIRED_DETAILS = ["name", "contact", "city", "problem"]
+    booking_intent_keywords = ["book appointment", "schedule appointment", "make appointment", "appointment"]
+
+    last_msg_lower = state.get("lastUserMessage", "").lower()
+    conversation_summary_lower = state.get("conversationSummary", "").lower()
+
+    wants_to_book = any(kw in last_msg_lower for kw in booking_intent_keywords) or \
+                    any(kw in conversation_summary_lower for kw in booking_intent_keywords)
+
+    if wants_to_book:
+        # Extract details from last user message
+        extracted_details = extract_details_from_user_message(state.get("lastUserMessage", ""))
+        patient_details = state.setdefault("patientDetails", {})
+        # Update patientDetails with any newly extracted info
+        for key in REQUIRED_DETAILS:
+            if key in extracted_details and extracted_details[key]:
+                patient_details[key] = extracted_details[key]
+
+        missing_fields = [field for field in REQUIRED_DETAILS if not patient_details.get(field)]
+        if missing_fields:
+            missing_field = missing_fields[0]
+            field_prompts = {
+                "name": "Could you please provide your full name?",
+                "contact": "May I have your contact number?",
+                "city": "What city are you located in?",
+                "problem": "Please briefly describe your medical problem or reason for the appointment.",
+            }
+            assistant_reply = field_prompts.get(missing_field, f"Please provide your {missing_field}.")
+            response_payload = {
+                "assistant_reply": assistant_reply,
+                "updated_state": state,
+            }
+            return jsonify(response_payload)
+
     assistant_reply = updated_state.get("assistant_reply")
     if not assistant_reply or not isinstance(assistant_reply, str) or not assistant_reply.strip():
-        # Fallback to a polite message if the LLM response is invalid or empty
         assistant_reply = "I'm here to help — could you tell me more about your symptoms or provide a Patient ID (PID) if you want me to fetch past reports?"
 
-    # Return the new assistant reply and the updated state so the frontend can persist it.
     response_payload = {
         "assistant_reply": assistant_reply,
         "updated_state": state,
@@ -333,23 +367,13 @@ Return ONLY valid JSON with keys: assistant_reply, patientDetails, conversationS
 
 @app.route("/upload_reports", methods=["POST"])
 def upload_reports():
-    """
-    Upload one or more files for a patient.
-
-    Expects multipart/form-data with:
-      - patient_id (form field)
-      - files (one or multiple files; use the same field name 'files' for each file)
-    """
     try:
-        # patient id can be in form or args (for convenience)
         patient_id = request.form.get("patient_id") or request.args.get("patient_id")
         if not patient_id:
             return jsonify({"error": "patient_id form field required"}), 400
 
-        # get uploaded files (support both files and files[] naming)
         uploaded_files = request.files.getlist("files")
         if not uploaded_files:
-            # fallback: single file under name 'file'
             single = request.files.get("file")
             if single:
                 uploaded_files = [single]
@@ -357,7 +381,6 @@ def upload_reports():
         if not uploaded_files:
             return jsonify({"error": "no files uploaded (use form field 'files')"}), 400
 
-        # create patient folder under REPORTS_ROOT/<patient_id>
         patient_folder = REPORTS_ROOT / str(patient_id)
         patient_folder.mkdir(parents=True, exist_ok=True)
 
@@ -371,17 +394,14 @@ def upload_reports():
                 skipped.append({"filename": orig_name, "reason": "invalid filename"})
                 continue
 
-            # extension check
             ext = filename.rsplit(".", 1)[1].lower() if "." in filename else ""
             if ext not in ALLOWED_EXTENSIONS:
                 skipped.append({"filename": filename, "reason": f"extension '{ext}' not allowed"})
                 continue
 
-            # avoid overwriting: if collision, add numeric suffix
             dest = patient_folder / filename
             if dest.exists():
                 base, dot, extension = filename.rpartition(".")
-                # if no base (e.g. ".bashrc") fallback
                 base = base or filename
                 i = 1
                 while True: