Update agent.py

agent.py

@@ -18,7 +18,6 @@ from langgraph.graph import StateGraph, END
 from typing import Optional, List, Dict, Any, TypedDict, Annotated
 
 # --- Environment Variable Loading ---
-# Keys are primarily used here, but checked in app.py for UI feedback
 UMLS_API_KEY = os.environ.get("UMLS_API_KEY")
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 TAVILY_API_KEY = os.environ.get("TAVILY_API_KEY")
@@ -29,59 +28,21 @@ AGENT_TEMPERATURE = 0.1
 MAX_SEARCH_RESULTS = 3
 
 class ClinicalPrompts:
-    # The comprehensive system prompt defining agent behavior
     SYSTEM_PROMPT = """
-    You are SynapseAI, an expert AI clinical assistant engaged in an interactive consultation.
-    Your goal is to support healthcare professionals by analyzing patient data, providing differential diagnoses, suggesting evidence-based management plans, and identifying risks according to current standards of care.
-
-    **Core Directives for this Conversation:**
-    1.  **Analyze Sequentially:** Process information turn-by-turn. Base your responses on the *entire* conversation history.
-    2.  **Seek Clarity:** If the provided information is insufficient or ambiguous for a safe assessment, CLEARLY STATE what specific additional information or clarification is needed. Do NOT guess or make unsafe assumptions.
-    3.  **Structured Assessment (When Ready):** When you have sufficient information and have performed necessary checks (like interactions, guideline searches), provide a comprehensive assessment using the following JSON structure. Output this JSON structure as the primary content of your response when you are providing the full analysis. Do NOT output incomplete JSON. If you need to ask a question or perform a tool call first, do that instead of outputting this structure.
-        ```json
-        {
-          "assessment": "Concise summary of the patient's presentation and key findings based on the conversation.",
-          "differential_diagnosis": [
-            {"diagnosis": "Primary Diagnosis", "likelihood": "High/Medium/Low", "rationale": "Supporting evidence from conversation..."},
-            {"diagnosis": "Alternative Diagnosis 1", "likelihood": "Medium/Low", "rationale": "Supporting/Refuting evidence..."},
-            {"diagnosis": "Alternative Diagnosis 2", "likelihood": "Low", "rationale": "Why it's less likely but considered..."}
-          ],
-          "risk_assessment": {
-            "identified_red_flags": ["List any triggered red flags based on input and analysis"],
-            "immediate_concerns": ["Specific urgent issues requiring attention (e.g., sepsis risk, ACS rule-out)"],
-            "potential_complications": ["Possible future issues based on presentation"]
-          },
-          "recommended_plan": {
-            "investigations": ["List specific lab tests or imaging required. Use 'order_lab_test' tool."],
-            "therapeutics": ["Suggest specific treatments or prescriptions. Use 'prescribe_medication' tool. MUST check interactions first using 'check_drug_interactions'."],
-            "consultations": ["Recommend specialist consultations if needed."],
-            "patient_education": ["Key points for patient communication."]
-          },
-          "rationale_summary": "Justification for assessment/plan. **Crucially, if relevant (e.g., ACS, sepsis, common infections), use 'tavily_search_results' to find and cite current clinical practice guidelines (e.g., 'latest ACC/AHA chest pain guidelines 202X', 'Surviving Sepsis Campaign guidelines') supporting your recommendations.** Include summary of guideline findings here.",
-          "interaction_check_summary": "Summary of findings from 'check_drug_interactions' if performed."
-        }
-        ```
-    4.  **Safety First - Interactions:** BEFORE suggesting a new prescription via `prescribe_medication`, you MUST FIRST use `check_drug_interactions` in a preceding or concurrent tool call. Report the findings from the interaction check. If significant interactions exist, modify the plan or state the contraindication clearly.
-    5.  **Safety First - Red Flags:** Use the `flag_risk` tool IMMEDIATELY if critical red flags requiring urgent action are identified at any point in the conversation.
-    6.  **Tool Use:** Employ tools (`order_lab_test`, `prescribe_medication`, `check_drug_interactions`, `flag_risk`, `tavily_search_results`) logically within the conversational flow. Wait for tool results before proceeding if the result is needed for the next step (e.g., wait for interaction check before confirming prescription in the structured JSON).
-    7.  **Evidence & Guidelines:** Actively use `tavily_search_results` not just for general knowledge, but specifically to query for and incorporate **current clinical practice guidelines** relevant to the patient's presentation (e.g., chest pain, shortness of breath, suspected infection). Summarize findings in the `rationale_summary` when providing the structured output.
-    8.  **Conciseness & Flow:** Be medically accurate and concise. Use standard terminology. Respond naturally in conversation (asking questions, acknowledging info) until ready for the full structured JSON output.
+    You are SynapseAI, an expert AI clinical assistant... [SYSTEM PROMPT OMITTED FOR BREVITY]
     """
 
 # --- API Constants & Helper Functions ---
-UMLS_AUTH_ENDPOINT = "https://utslogin.nlm.nih.gov/cas/v1/api-key"
-RXNORM_API_BASE = "https://rxnav.nlm.nih.gov/REST"
-OPENFDA_API_BASE = "https://api.fda.gov/drug/label.json"
-
+UMLS_AUTH_ENDPOINT = "https://utslogin.nlm.nih.gov/cas/v1/api-key"; RXNORM_API_BASE = "https://rxnav.nlm.nih.gov/REST"; OPENFDA_API_BASE = "https://api.fda.gov/drug/label.json"
 @lru_cache(maxsize=256)
 def get_rxcui(drug_name: str) -> Optional[str]:
-    """Uses RxNorm API to find the RxCUI for a given drug name."""
+    # ... (Keep implementation) ...
     if not drug_name or not isinstance(drug_name, str): return None; drug_name = drug_name.strip();
     if not drug_name: return None; print(f"RxNorm Lookup for: '{drug_name}'");
-    try: # Try direct lookup first
+    try:
         params = {"name": drug_name, "search": 1}; response = requests.get(f"{RXNORM_API_BASE}/rxcui.json", params=params, timeout=10); response.raise_for_status(); data = response.json();
         if data and "idGroup" in data and "rxnormId" in data["idGroup"]: rxcui = data["idGroup"]["rxnormId"][0]; print(f"  Found RxCUI: {rxcui} for '{drug_name}'"); return rxcui
-        else: # Fallback to /drugs search
+        else:
             params = {"name": drug_name}; response = requests.get(f"{RXNORM_API_BASE}/drugs.json", params=params, timeout=10); response.raise_for_status(); data = response.json();
             if data and "drugGroup" in data and "conceptGroup" in data["drugGroup"]:
                 for group in data["drugGroup"]["conceptGroup"]:
@@ -95,7 +56,7 @@ def get_rxcui(drug_name: str) -> Optional[str]:
 
 @lru_cache(maxsize=128)
 def get_openfda_label(rxcui: Optional[str] = None, drug_name: Optional[str] = None) -> Optional[dict]:
-    """Fetches drug label information from OpenFDA using RxCUI or drug name."""
+    # ... (Keep implementation) ...
     if not rxcui and not drug_name: return None; print(f"OpenFDA Label Lookup for: RXCUI={rxcui}, Name={drug_name}"); search_terms = []
     if rxcui: search_terms.append(f'spl_rxnorm_code:"{rxcui}" OR openfda.rxcui:"{rxcui}"')
     if drug_name: search_terms.append(f'(openfda.brand_name:"{drug_name.lower()}" OR openfda.generic_name:"{drug_name.lower()}")')
@@ -109,7 +70,7 @@ def get_openfda_label(rxcui: Optional[str] = None, drug_name: Optional[str] = No
     except Exception as e: print(f"  Unexpected error in get_openfda_label: {e}"); return None
 
 def search_text_list(text_list: Optional[List[str]], search_terms: List[str]) -> List[str]:
-    """ Case-insensitive search for any search_term within a list of text strings. Returns snippets. """
+    # ... (Keep implementation) ...
     found_snippets = [];
     if not text_list or not search_terms: return found_snippets; search_terms_lower = [str(term).lower() for term in search_terms if term];
     for text_item in text_list:
@@ -125,22 +86,14 @@ def search_text_list(text_list: Optional[List[str]], search_terms: List[str]) ->
 
 # --- Clinical Helper Functions ---
 def parse_bp(bp_string: str) -> Optional[tuple[int, int]]:
-    """Parses BP string like '120/80' into (systolic, diastolic) integers."""
-    if not isinstance(bp_string, str): return None
-    match = re.match(r"(\d{1,3})\s*/\s*(\d{1,3})", bp_string.strip())
-    if match: return int(match.group(1)), int(match.group(2))
-    return None
+    # ... (Keep implementation) ...
+    if not isinstance(bp_string, str): return None; match = re.match(r"(\d{1,3})\s*/\s*(\d{1,3})", bp_string.strip());
+    if match: return int(match.group(1)), int(match.group(2)); return None
 
 def check_red_flags(patient_data: dict) -> List[str]:
-    """Checks patient data against predefined red flags."""
-    flags = []
-    if not patient_data: return flags
-    symptoms = patient_data.get("hpi", {}).get("symptoms", [])
-    vitals = patient_data.get("vitals", {})
-    history = patient_data.get("pmh", {}).get("conditions", "")
-    symptoms_lower = [str(s).lower() for s in symptoms if isinstance(s, str)]
-
-    # Symptom Flags
+    # ... (Keep implementation with multi-line ifs) ...
+    flags = [];
+    if not patient_data: return flags; symptoms = patient_data.get("hpi", {}).get("symptoms", []); vitals = patient_data.get("vitals", {}); history = patient_data.get("pmh", {}).get("conditions", ""); symptoms_lower = [str(s).lower() for s in symptoms if isinstance(s, str)];
     if "chest pain" in symptoms_lower: flags.append("Red Flag: Chest Pain reported.")
     if "shortness of breath" in symptoms_lower: flags.append("Red Flag: Shortness of Breath reported.")
     if "severe headache" in symptoms_lower: flags.append("Red Flag: Severe Headache reported.")
@@ -148,40 +101,38 @@ def check_red_flags(patient_data: dict) -> List[str]:
     if "weakness on one side" in symptoms_lower: flags.append("Red Flag: Unilateral Weakness reported (potential stroke).")
     if "hemoptysis" in symptoms_lower: flags.append("Red Flag: Hemoptysis (coughing up blood).")
     if "syncope" in symptoms_lower: flags.append("Red Flag: Syncope (fainting).")
+    if vitals: temp = vitals.get("temp_c"); hr = vitals.get("hr_bpm"); rr = vitals.get("rr_rpm"); spo2 = vitals.get("spo2_percent"); bp_str = vitals.get("bp_mmhg");
+    if temp is not None and temp >= 38.5: flags.append(f"Red Flag: Fever ({temp}°C)."); if hr is not None and hr >= 120: flags.append(f"Red Flag: Tachycardia ({hr} bpm)."); if hr is not None and hr <= 50: flags.append(f"Red Flag: Bradycardia ({hr} bpm)."); if rr is not None and rr >= 24: flags.append(f"Red Flag: Tachypnea ({rr} rpm)."); if spo2 is not None and spo2 <= 92: flags.append(f"Red Flag: Hypoxia ({spo2}%).");
+    if bp_str: bp = parse_bp(bp_str);
+    if bp:
+        if bp[0] >= 180 or bp[1] >= 110: flags.append(f"Red Flag: Hypertensive Urgency/Emergency (BP: {bp_str} mmHg).");
+        if bp[0] <= 90 or bp[1] <= 60: flags.append(f"Red Flag: Hypotension (BP: {bp_str} mmHg).");
+    if history and isinstance(history, str): history_lower = history.lower();
+    if "history of mi" in history_lower and "chest pain" in symptoms_lower: flags.append("Red Flag: History of MI with current Chest Pain.");
+    if "history of dvt/pe" in history_lower and "shortness of breath" in symptoms_lower: flags.append("Red Flag: History of DVT/PE with current Shortness of Breath.");
+    return list(set(flags))
 
-    # Vital Sign Flags
-    if vitals:
-        temp = vitals.get("temp_c"); hr = vitals.get("hr_bpm"); rr = vitals.get("rr_rpm")
-        spo2 = vitals.get("spo2_percent"); bp_str = vitals.get("bp_mmhg")
-        if temp is not None and temp >= 38.5: flags.append(f"Red Flag: Fever ({temp}°C).")
-        if hr is not None and hr >= 120: flags.append(f"Red Flag: Tachycardia ({hr} bpm).")
-        if hr is not None and hr <= 50: flags.append(f"Red Flag: Bradycardia ({hr} bpm).")
-        if rr is not None and rr >= 24: flags.append(f"Red Flag: Tachypnea ({rr} rpm).")
-        if spo2 is not None and spo2 <= 92: flags.append(f"Red Flag: Hypoxia ({spo2}%).")
-        if bp_str:
-            bp = parse_bp(bp_str)
-            if bp:
-                if bp[0] >= 180 or bp[1] >= 110: flags.append(f"Red Flag: Hypertensive Urgency/Emergency (BP: {bp_str} mmHg).")
-                if bp[0] <= 90 or bp[1] <= 60: flags.append(f"Red Flag: Hypotension (BP: {bp_str} mmHg).")
-
-    # History Flags
-    if history and isinstance(history, str):
-        history_lower = history.lower()
-        if "history of mi" in history_lower and "chest pain" in symptoms_lower: flags.append("Red Flag: History of MI with current Chest Pain.")
-        if "history of dvt/pe" in history_lower and "shortness of breath" in symptoms_lower: flags.append("Red Flag: History of DVT/PE with current Shortness of Breath.")
-
-    return list(set(flags)) # Unique flags
-
+# CORRECTED format_patient_data_for_prompt function indentation
 def format_patient_data_for_prompt(data: dict) -> str:
     """Formats the patient dictionary into a readable string for the LLM."""
-    if not data: return "No patient data provided."; prompt_str = "";
-    for key, value in data.items(): section_title = key.replace('_', ' ').title();
-    if isinstance(value, dict) and value: has_content = any(sub_value for sub_value in value.values());
-    if has_content: prompt_str += f"**{section_title}:**\n";
-    for sub_key, sub_value in value.items():
-        if sub_value: prompt_str += f"  - {sub_key.replace('_', ' ').title()}: {sub_value}\n"
-    elif isinstance(value, list) and value: prompt_str += f"**{section_title}:** {', '.join(map(str, value))}\n"
-    elif value and not isinstance(value, dict): prompt_str += f"**{section_title}:** {value}\n";
+    if not data: return "No patient data provided."
+    prompt_str = ""
+    for key, value in data.items():
+        section_title = key.replace('_', ' ').title()
+        # Check if the value is a dictionary and has content
+        if isinstance(value, dict) and value:
+            has_content = any(sub_value for sub_value in value.values())
+            if has_content:
+                prompt_str += f"**{section_title}:**\n"
+                for sub_key, sub_value in value.items():
+                     if sub_value: # Only add if sub-value is truthy
+                        prompt_str += f"  - {sub_key.replace('_', ' ').title()}: {sub_value}\n"
+        # Check if the value is a non-empty list
+        elif isinstance(value, list) and value: # <-- Correct indentation
+             prompt_str += f"**{section_title}:** {', '.join(map(str, value))}\n"
+        # Check if the value is truthy and not a dictionary (handles strings, numbers, etc.)
+        elif value and not isinstance(value, dict): # <-- Correct indentation
+             prompt_str += f"**{section_title}:** {value}\n"
     return prompt_str.strip()
 
 
@@ -199,6 +150,7 @@ def prescribe_medication(medication_name: str, dosage: str, route: str, frequenc
     print(f"Executing prescribe_medication: {medication_name} {dosage}..."); return json.dumps({"status": "success", "message": f"Prescription Prepared: {medication_name} {dosage} {route} {frequency}", "details": f"Duration: {duration}. Reason: {reason}"})
 @tool("check_drug_interactions", args_schema=InteractionCheckInput)
 def check_drug_interactions(potential_prescription: str, current_medications: Optional[List[str]] = None, allergies: Optional[List[str]] = None) -> str:
+    # ... (Keep the FULL implementation of the NEW check_drug_interactions using API helpers) ...
     print(f"\n--- Executing REAL check_drug_interactions ---"); print(f"Checking potential prescription: '{potential_prescription}'"); warnings = []; potential_med_lower = potential_prescription.lower().strip();
     current_meds_list = current_medications or []; allergies_list = allergies or []; current_med_names_lower = [];
     for med in current_meds_list: match = re.match(r"^\s*([a-zA-Z\-]+)", str(med));
@@ -233,28 +185,24 @@ def check_drug_interactions(potential_prescription: str, current_medications: Op
     return json.dumps({"status": status, "message": message, "warnings": final_warnings})
 @tool("flag_risk", args_schema=FlagRiskInput)
 def flag_risk(risk_description: str, urgency: str) -> str:
-    print(f"Executing flag_risk: {risk_description}, Urgency: {urgency}"); # UI part in app.py
-    return json.dumps({"status": "flagged", "message": f"Risk '{risk_description}' flagged with {urgency} urgency."})
+    print(f"Executing flag_risk: {risk_description}, Urgency: {urgency}"); return json.dumps({"status": "flagged", "message": f"Risk '{risk_description}' flagged with {urgency} urgency."})
 search_tool = TavilySearchResults(max_results=MAX_SEARCH_RESULTS, name="tavily_search_results")
 all_tools = [order_lab_test, prescribe_medication, check_drug_interactions, flag_risk, search_tool]
 
 # --- LangGraph State & Nodes ---
 class AgentState(TypedDict): messages: Annotated[list[Any], operator.add]; patient_data: Optional[dict]; summary: Optional[str]; interaction_warnings: Optional[List[str]]
-
-llm = ChatGroq(temperature=AGENT_TEMPERATURE, model=AGENT_MODEL_NAME)
-model_with_tools = llm.bind_tools(all_tools)
-tool_executor = ToolExecutor(all_tools)
-
+llm = ChatGroq(temperature=AGENT_TEMPERATURE, model=AGENT_MODEL_NAME); model_with_tools = llm.bind_tools(all_tools); tool_executor = ToolExecutor(all_tools)
 def agent_node(state: AgentState):
+    # ... (Keep implementation) ...
     print("\n---AGENT NODE---"); current_messages = state['messages'];
     if not current_messages or not isinstance(current_messages[0], SystemMessage): print("Prepending System Prompt."); current_messages = [SystemMessage(content=ClinicalPrompts.SYSTEM_PROMPT)] + current_messages;
     print(f"Invoking LLM with {len(current_messages)} messages.");
     try: response = model_with_tools.invoke(current_messages); print(f"Agent Raw Response Type: {type(response)}");
     if hasattr(response, 'tool_calls') and response.tool_calls: print(f"Agent Response Tool Calls: {response.tool_calls}"); else: print("Agent Response: No tool calls.");
     except Exception as e: print(f"ERROR in agent_node: {e}"); traceback.print_exc(); error_message = AIMessage(content=f"Error: {e}"); return {"messages": [error_message]};
-    return {"messages": [response]} # Only return messages
-
+    return {"messages": [response]}
 def tool_node(state: AgentState):
+    # ... (Keep implementation) ...
     print("\n---TOOL NODE---"); tool_messages = []; last_message = state['messages'][-1]; interaction_warnings_found = [];
     if not isinstance(last_message, AIMessage) or not getattr(last_message, 'tool_calls', None): print("Warning: Tool node called unexpectedly."); return {"messages": [], "interaction_warnings": None};
     tool_calls = last_message.tool_calls; print(f"Tool calls received: {json.dumps(tool_calls, indent=2)}"); prescriptions_requested = {}; interaction_checks_requested = {};
@@ -288,6 +236,7 @@ def tool_node(state: AgentState):
     return {"messages": tool_messages, "interaction_warnings": interaction_warnings_found or None} # Return messages AND warnings
 
 def reflection_node(state: AgentState):
+    # ... (Keep implementation) ...
     print("\n---REFLECTION NODE---")
     interaction_warnings = state.get("interaction_warnings")
     if not interaction_warnings: print("Warning: Reflection node called without warnings."); return {"messages": [], "interaction_warnings": None};
@@ -298,23 +247,22 @@ def reflection_node(state: AgentState):
             if any(tc['id'] in relevant_tool_call_ids for tc in msg.tool_calls): triggering_ai_message = msg; break;
     if not triggering_ai_message: print("Error: Could not find triggering AI message for reflection."); return {"messages": [AIMessage(content="Internal Error: Reflection context missing.")], "interaction_warnings": None};
     original_plan_proposal_context = triggering_ai_message.content;
-    reflection_prompt_text = f"""You are SynapseAI, performing a critical safety review...
-    Previous Context:\n{original_plan_proposal_context}\n---\nInteraction Warnings:\n```json\n{json.dumps(interaction_warnings, indent=2)}\n```\n**CRITICAL REFLECTION STEP:** Analyze warnings, decide if revision is needed, respond ONLY about therapeutics revision based on these warnings."""
+    reflection_prompt_text = f"""You are SynapseAI, performing a critical safety review... [PROMPT OMITTED FOR BREVITY]""" # Use full prompt
     reflection_messages = [SystemMessage(content="Perform focused safety review based on interaction warnings."), HumanMessage(content=reflection_prompt_text)];
     print("Invoking LLM for reflection...");
     try: reflection_response = llm.invoke(reflection_messages); print(f"Reflection Response: {reflection_response.content}"); final_ai_message = AIMessage(content=reflection_response.content);
     except Exception as e: print(f"ERROR during reflection: {e}"); traceback.print_exc(); final_ai_message = AIMessage(content=f"Error during safety reflection: {e}");
     return {"messages": [final_ai_message], "interaction_warnings": None} # Return reflection response, clear warnings
 
-
 # --- Graph Routing Logic ---
 def should_continue(state: AgentState) -> str:
+    # ... (Keep implementation) ...
     print("\n---ROUTING DECISION (Agent Output)---"); last_message = state['messages'][-1] if state['messages'] else None;
     if not isinstance(last_message, AIMessage): return "end_conversation_turn";
     if "Sorry, an internal error occurred" in last_message.content: return "end_conversation_turn";
     if getattr(last_message, 'tool_calls', None): return "continue_tools"; else: return "end_conversation_turn";
-
 def after_tools_router(state: AgentState) -> str:
+    # ... (Keep implementation) ...
     print("\n---ROUTING DECISION (After Tools)---");
     if state.get("interaction_warnings"): print("Routing: Warnings found -> Reflection"); return "reflect_on_warnings";
     else: print("Routing: No warnings -> Agent"); return "continue_to_agent";
@@ -322,26 +270,13 @@ def after_tools_router(state: AgentState) -> str:
 # --- ClinicalAgent Class ---
 class ClinicalAgent:
     def __init__(self):
-        workflow = StateGraph(AgentState)
-        workflow.add_node("agent", agent_node)
-        workflow.add_node("tools", tool_node)
-        workflow.add_node("reflection", reflection_node)
-        workflow.set_entry_point("agent")
-        workflow.add_conditional_edges("agent", should_continue, {"continue_tools": "tools", "end_conversation_turn": END})
+        # ... (Keep graph compilation) ...
+        workflow = StateGraph(AgentState); workflow.add_node("agent", agent_node); workflow.add_node("tools", tool_node); workflow.add_node("reflection", reflection_node)
+        workflow.set_entry_point("agent"); workflow.add_conditional_edges("agent", should_continue, {"continue_tools": "tools", "end_conversation_turn": END})
         workflow.add_conditional_edges("tools", after_tools_router, {"reflect_on_warnings": "reflection", "continue_to_agent": "agent"})
-        workflow.add_edge("reflection", "agent")
-        self.graph_app = workflow.compile()
-        print("ClinicalAgent initialized and LangGraph compiled.")
-
+        workflow.add_edge("reflection", "agent"); self.graph_app = workflow.compile(); print("ClinicalAgent initialized and LangGraph compiled.")
     def invoke_turn(self, state: Dict) -> Dict:
-        """Invokes the LangGraph app for one turn."""
-        print(f"Invoking graph with state keys: {state.keys()}")
-        try:
-            final_state = self.graph_app.invoke(state, {"recursion_limit": 15})
-            final_state.setdefault('summary', state.get('summary')) # Ensure keys exist
-            final_state.setdefault('interaction_warnings', None)
-            return final_state
-        except Exception as e:
-            print(f"CRITICAL ERROR during graph invocation: {type(e).__name__} - {e}"); traceback.print_exc();
-            error_msg = AIMessage(content=f"Sorry, a critical error occurred during processing: {e}");
-            return {"messages": state.get('messages', []) + [error_msg], "patient_data": state.get('patient_data'), "summary": state.get('summary'), "interaction_warnings": None}
+        # ... (Keep implementation) ...
+        print(f"Invoking graph with state keys: {state.keys()}");
+        try: final_state = self.graph_app.invoke(state, {"recursion_limit": 15}); final_state.setdefault('summary', state.get('summary')); final_state.setdefault('interaction_warnings', None); return final_state
+        except Exception as e: print(f"CRITICAL ERROR during graph invocation: {type(e).__name__} - {e}"); traceback.print_exc(); error_msg = AIMessage(content=f"Sorry, error occurred: {e}"); return {"messages": state.get('messages', []) + [error_msg], "patient_data": state.get('patient_data'), "summary": state.get('summary'), "interaction_warnings": None}