Add per-session prompt override functionality across interfaces and AI client

src/core/ai_client.py

@@ -380,6 +380,10 @@ class AIClientManager:
         # Expected shape: {agent_name: model_string}
         self.model_overrides: Dict[str, str] = {}
 
+        # Optional per-session prompt overrides.
+        # Expected shape: {agent_name: system_prompt_string}
+        self.prompt_overrides = {}
+
     def set_model_overrides(self, overrides: Optional[Dict[str, str]] = None) -> None:
         """Set per-session model overrides.
 
@@ -387,6 +391,22 @@ class AIClientManager:
         (chat / manual input / file upload) can share the same mechanism.
         """
         self.model_overrides = dict(overrides or {})
+
+    def set_prompt_overrides(self, overrides: Optional[Dict[str, str]] = None) -> None:
+        """Set per-session prompt overrides.
+
+        This avoids mutating module-level prompt constants and prevents
+        cross-session leakage.
+
+        Expected keys are agent names, e.g.:
+        - SpiritualDistressAnalyzer
+        - SoftSpiritualTriage
+        - TriageResponseEvaluator
+        - MedicalAssistant
+        - SoftMedicalTriage
+        - EntryClassifier
+        """
+        self.prompt_overrides = dict(overrides or {})
         
         # NEW: Enhanced client management for medical AI optimization
         self.provider_performance_metrics = {}
@@ -491,6 +511,9 @@ class AIClientManager:
         if model_override is None and self.model_overrides:
             model_override = self.model_overrides.get("SpiritualDistressAnalyzer")
 
+        if self.prompt_overrides and "SpiritualDistressAnalyzer" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["SpiritualDistressAnalyzer"]
+
         return self.generate_response(
             system_prompt=system_prompt,
             user_prompt=user_prompt,
@@ -499,6 +522,28 @@ class AIClientManager:
             agent_name="SpiritualDistressAnalyzer",
             model_override=model_override,
         )
+
+    def call_entry_classifier_api(self, system_prompt: str, user_prompt: str,
+                                 temperature: float = 0.3,
+                                 model_override: Optional[str] = None) -> str:
+        """Call AI API for entry classification.
+
+        This is used by Enhanced Verification manual input / file upload modes.
+        """
+        if model_override is None and self.model_overrides:
+            model_override = self.model_overrides.get("EntryClassifier")
+
+        if self.prompt_overrides and "EntryClassifier" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["EntryClassifier"]
+
+        return self.generate_response(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            call_type="entry_classification",
+            agent_name="EntryClassifier",
+            model_override=model_override,
+        )
     
     def call_medical_api(self, system_prompt: str, user_prompt: str,
                         temperature: float = 0.3,
@@ -519,6 +564,9 @@ class AIClientManager:
         if model_override is None and self.model_overrides:
             model_override = self.model_overrides.get("SoftMedicalTriage")
 
+        if self.prompt_overrides and "SoftMedicalTriage" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["SoftMedicalTriage"]
+
         return self.generate_response(
             system_prompt=system_prompt,
             user_prompt=user_prompt,
@@ -528,6 +576,63 @@ class AIClientManager:
             model_override=model_override,
         )
 
+    def call_soft_spiritual_triage_api(self, system_prompt: str, user_prompt: str,
+                                      temperature: float = 0.3,
+                                      model_override: Optional[str] = None) -> str:
+        """Call AI API for soft spiritual triage question generation."""
+        if model_override is None and self.model_overrides:
+            model_override = self.model_overrides.get("SoftSpiritualTriage")
+
+        if self.prompt_overrides and "SoftSpiritualTriage" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["SoftSpiritualTriage"]
+
+        return self.generate_response(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            call_type="soft_spiritual_triage",
+            agent_name="SoftSpiritualTriage",
+            model_override=model_override,
+        )
+
+    def call_triage_response_evaluator_api(self, system_prompt: str, user_prompt: str,
+                                          temperature: float = 0.3,
+                                          model_override: Optional[str] = None) -> str:
+        """Call AI API for triage response evaluation."""
+        if model_override is None and self.model_overrides:
+            model_override = self.model_overrides.get("TriageResponseEvaluator")
+
+        if self.prompt_overrides and "TriageResponseEvaluator" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["TriageResponseEvaluator"]
+
+        return self.generate_response(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            call_type="triage_response_evaluator",
+            agent_name="TriageResponseEvaluator",
+            model_override=model_override,
+        )
+
+    def call_medical_assistant_api(self, system_prompt: str, user_prompt: str,
+                                  temperature: float = 0.3,
+                                  model_override: Optional[str] = None) -> str:
+        """Call AI API for medical assistant responses."""
+        if model_override is None and self.model_overrides:
+            model_override = self.model_overrides.get("MedicalAssistant")
+
+        if self.prompt_overrides and "MedicalAssistant" in self.prompt_overrides:
+            system_prompt = self.prompt_overrides["MedicalAssistant"]
+
+        return self.generate_response(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            call_type="medical_assistant",
+            agent_name="MedicalAssistant",
+            model_override=model_override,
+        )
+
 # Factory function for easy client creation
 def create_ai_client(agent_name: str, model_override: Optional[str] = None) -> UniversalAIClient:
     """

src/core/simplified_medical_app.py

@@ -66,6 +66,10 @@ class SimplifiedMedicalApp:
         self.api = AIClientManager()
         # Optional per-session model overrides (set by the UI Model Settings tab)
         self.model_overrides = {}
+
+        # Optional per-session prompt overrides (set by the UI Edit Prompts tab)
+        # Expected: {agent_name: system_prompt_text}
+        self.prompt_overrides = {}
         
         # Medical components
         self.medical_assistant = MedicalAssistant(self.api)
@@ -81,7 +85,7 @@ class SimplifiedMedicalApp:
         logger.info(f"✅ Loaded patient: {self.clinical_background.patient_name}")
         
         # Session state
-        self.chat_history: List[ChatMessage] = []
+        self.chat_history = []
         self.spiritual_state = SessionSpiritualState()
         self.session_active = False
         
@@ -109,6 +113,16 @@ class SimplifiedMedicalApp:
         if hasattr(self, "api") and hasattr(self.api, "model_overrides"):
             self.api.model_overrides = dict(self.model_overrides)
 
+    def set_prompt_overrides(self, overrides: Optional[dict] = None) -> None:
+        """Set per-session prompt overrides.
+
+        `overrides` is expected to be a mapping of agent_name -> system_prompt string.
+        """
+        self.prompt_overrides = dict(overrides or {})
+
+        if hasattr(self, "api") and hasattr(self.api, "set_prompt_overrides"):
+            self.api.set_prompt_overrides(self.prompt_overrides)
+
     def _get_model_override(self, agent_name: str) -> Optional[str]:
         """Return the model override for an agent, if any."""
         if not getattr(self, "model_overrides", None):

src/interface/file_upload_interface.py

@@ -48,6 +48,9 @@ class FileUploadInterfaceController(ProgressTrackingMixin):
         # Optional per-session model overrides (UI Model Settings tab)
         self.model_overrides = {}
         self.ai_client.set_model_overrides(self.model_overrides)
+        # Optional per-session prompt overrides (UI Edit Prompts tab)
+        self.prompt_overrides = {}
+        self.ai_client.set_prompt_overrides(self.prompt_overrides)
         self.current_session = None
         self.current_file_result = None
         self.current_message_index = 0
@@ -57,6 +60,11 @@ class FileUploadInterfaceController(ProgressTrackingMixin):
         """Set per-session model overrides from the UI."""
         self.model_overrides = dict(overrides or {})
         self.ai_client.set_model_overrides(self.model_overrides)
+
+    def set_prompt_overrides(self, overrides: Optional[Dict[str, str]] = None) -> None:
+        """Set per-session prompt overrides from the UI."""
+        self.prompt_overrides = dict(overrides or {})
+        self.ai_client.set_prompt_overrides(self.prompt_overrides)
         
     def process_uploaded_file(self, file_path: str) -> Tuple[bool, str, Optional[FileUploadResult], str]:
         """
@@ -298,10 +306,10 @@ class FileUploadInterfaceController(ProgressTrackingMixin):
             # Call AI classifier using the same approach as manual input
             user_prompt = f"Please analyze this patient message for spiritual distress:\n\n{test_message.text}"
             
-            response = self.ai_client.call_spiritual_api(
+            response = self.ai_client.call_entry_classifier_api(
                 system_prompt=SYSTEM_PROMPT_ENTRY_CLASSIFIER,
                 user_prompt=user_prompt,
-                temperature=0.3
+                temperature=0.3,
             )
             
             # Parse the response to extract classification details
@@ -407,11 +415,11 @@ class FileUploadInterfaceController(ProgressTrackingMixin):
                     "Please analyze this patient message for spiritual distress:\n\n"
                     f"{test_message.text}"
                 )
-                raw_response = self.ai_client.call_spiritual_api(
+                raw_response = self.ai_client.call_entry_classifier_api(
                     system_prompt=SYSTEM_PROMPT_ENTRY_CLASSIFIER,
                     user_prompt=user_prompt,
                     temperature=0.3,
-                    model_override=self.model_overrides.get("SpiritualDistressAnalyzer"),
+                    model_override=self.model_overrides.get("EntryClassifier"),
                 )
 
                 classification_result = self._parse_classification_response(raw_response)

src/interface/manual_input_interface.py

@@ -60,16 +60,23 @@ class ManualInputController(ProgressTrackingMixin):
         self.store = JSONVerificationStore()
         self.ai_client = AIClientManager()
         self.model_overrides = {}
+        self.prompt_overrides = {}
         self.state = ManualInputState()
         self.classification_start_time = None
 
         # Ensure the underlying AI client manager sees our overrides.
         self.ai_client.set_model_overrides(self.model_overrides)
+        self.ai_client.set_prompt_overrides(self.prompt_overrides)
 
     def set_model_overrides(self, overrides: Optional[Dict[str, str]] = None) -> None:
         """Set per-session model overrides from the UI."""
         self.model_overrides = dict(overrides or {})
         self.ai_client.set_model_overrides(self.model_overrides)
+
+    def set_prompt_overrides(self, overrides: Optional[Dict[str, str]] = None) -> None:
+        """Set per-session prompt overrides from the UI."""
+        self.prompt_overrides = dict(overrides or {})
+        self.ai_client.set_prompt_overrides(self.prompt_overrides)
     
     def start_new_session(self, verifier_name: str) -> Tuple[bool, str, Optional[EnhancedVerificationSession]]:
         """
@@ -139,11 +146,11 @@ class ManualInputController(ProgressTrackingMixin):
             
             # Call AI classifier
             user_prompt = f"Please analyze this patient message for spiritual distress:\n\n{message_text.strip()}"
-            
-            response = self.ai_client.call_spiritual_api(
+
+            response = self.ai_client.call_entry_classifier_api(
                 system_prompt=SYSTEM_PROMPT_ENTRY_CLASSIFIER,
                 user_prompt=user_prompt,
-                temperature=0.3
+                temperature=0.3,
             )
             # Parse the response to extract classification details
             classification_result = self._parse_classification_response(response)

src/interface/simplified_gradio_app.py

@@ -604,6 +604,13 @@ Changes apply only to your current session.
                 session.app_instance.set_model_overrides(custom_models)
             else:
                 session.app_instance.set_model_overrides({})
+
+            # Apply per-session prompt overrides (if configured in Edit Prompts)
+            custom_prompts = getattr(session, 'custom_prompts', None)
+            if custom_prompts:
+                session.app_instance.set_prompt_overrides(custom_prompts)
+            else:
+                session.app_instance.set_prompt_overrides({})
             new_history, status = session.app_instance.process_message(message, history)
             
             # Get updated conversation stats
@@ -866,8 +873,22 @@ Changes apply only to your current session.
             
             return formatted
         
-        def load_prompt(prompt_name: str):
-            """Load selected prompt for editing."""
+        def _prompt_name_to_agent(prompt_name: str) -> str:
+            """Map UI prompt selection to internal agent/prompt key."""
+            mapping = {
+                "🔍 Spiritual Monitor (Classifier)": "SpiritualDistressAnalyzer",
+                "🟡 Soft Spiritual Triage": "SoftSpiritualTriage",
+                "📊 Triage Response Evaluator": "TriageResponseEvaluator",
+                "🏥 Medical Assistant": "MedicalAssistant",
+                "🩺 Soft Medical Triage": "SoftMedicalTriage",
+            }
+            return mapping.get(prompt_name, prompt_name)
+
+        def load_prompt(prompt_name: str, session: Optional[SimplifiedSessionData] = None):
+            """Load selected prompt for editing.
+
+            If a session override exists, show it instead of the default.
+            """
             from src.core.spiritual_monitor import SYSTEM_PROMPT_SPIRITUAL_MONITOR
             from src.core.soft_triage_manager import (
                 SYSTEM_PROMPT_TRIAGE_QUESTION,
@@ -886,7 +907,12 @@ Changes apply only to your current session.
                 "🩺 Soft Medical Triage": SYSTEM_PROMPT_SOFT_MEDICAL_TRIAGE
             }
             
+            agent_key = _prompt_name_to_agent(prompt_name)
             prompt_text = prompts.get(prompt_name, "")
+
+            # Prefer session override (true session-scoped behavior)
+            if session is not None and hasattr(session, 'custom_prompts'):
+                prompt_text = session.custom_prompts.get(agent_key, prompt_text)
             
             # Format with HTML for display
             formatted_html = format_prompt_with_html(prompt_text)
@@ -924,32 +950,18 @@ Changes apply only to your current session.
 </div>"""
                 return error_html, session
             
-            # Store custom prompt in session
+            # Store custom prompt in session (session-scoped)
             if not hasattr(session, 'custom_prompts'):
                 session.custom_prompts = {}
             
-            session.custom_prompts[prompt_name] = prompt_text
-            
-            # Apply to app components
-            try:
-                if prompt_name == "🔍 Spiritual Monitor (Classifier)":
-                    # Update spiritual monitor prompt
-                    import src.core.spiritual_monitor as sm
-                    sm.SYSTEM_PROMPT_SPIRITUAL_MONITOR = prompt_text
-                elif prompt_name == "🟡 Soft Spiritual Triage":
-                    import src.core.soft_triage_manager as stm
-                    stm.SYSTEM_PROMPT_TRIAGE_QUESTION = prompt_text
-                elif prompt_name == "📊 Triage Response Evaluator":
-                    import src.core.soft_triage_manager as stm
-                    stm.SYSTEM_PROMPT_TRIAGE_EVALUATE = prompt_text
-                elif prompt_name == "🏥 Medical Assistant":
-                    import src.config.prompts as p
-                    p.SYSTEM_PROMPT_MEDICAL_ASSISTANT = prompt_text
-                elif prompt_name == "🩺 Soft Medical Triage":
-                    import src.config.prompts as p
-                    p.SYSTEM_PROMPT_SOFT_MEDICAL_TRIAGE = prompt_text
-                
-                status = f"""<div style="padding: 1em; background-color: #ecfdf5; border-left: 4px solid #10b981; border-radius: 4px;">
+            agent_key = _prompt_name_to_agent(prompt_name)
+            session.custom_prompts[agent_key] = prompt_text
+
+            # Apply into the current session app instance (no global mutation)
+            if hasattr(session, 'app_instance') and hasattr(session.app_instance, 'set_prompt_overrides'):
+                session.app_instance.set_prompt_overrides(session.custom_prompts)
+
+            status = f"""<div style="padding: 1em; background-color: #ecfdf5; border-left: 4px solid #10b981; border-radius: 4px;">
 <h4 style="color: #059669; margin-top: 0;">✅ Prompt Applied Successfully</h4>
 
 <p><strong>Prompt:</strong> {prompt_name}</p>
@@ -961,15 +973,8 @@ Changes apply only to your current session.
 To revert, use "Reset to Default" button.
 </p>
 </div>"""
-                
-                return status, session
-                
-            except Exception as e:
-                error_html = f"""<div style="padding: 1em; background-color: #fef2f2; border-left: 4px solid #dc2626; border-radius: 4px;">
-<h4 style="color: #dc2626; margin-top: 0;">❌ Error Applying Prompt</h4>
-<p style="margin-bottom: 0;"><code>{str(e)}</code></p>
-</div>"""
-                return error_html, session
+            
+            return status, session
         
         def reset_prompt(prompt_name: str, session: SimplifiedSessionData):
             """Reset prompt to default."""
@@ -977,14 +982,16 @@ To revert, use "Reset to Default" button.
                 session = SimplifiedSessionData()
             
             # Remove from custom prompts
-            if hasattr(session, 'custom_prompts') and prompt_name in session.custom_prompts:
-                del session.custom_prompts[prompt_name]
+            agent_key = _prompt_name_to_agent(prompt_name)
+            if hasattr(session, 'custom_prompts') and agent_key in session.custom_prompts:
+                del session.custom_prompts[agent_key]
+
+            # Apply into current session app instance
+            if hasattr(session, 'app_instance') and hasattr(session.app_instance, 'set_prompt_overrides'):
+                session.app_instance.set_prompt_overrides(getattr(session, 'custom_prompts', {}))
             
             # Reload default
-            prompt_text, info, status = load_prompt(prompt_name)
-            
-            # Reapply default
-            apply_status, session = apply_prompt_changes(prompt_name, prompt_text, session)
+            prompt_text, info, status = load_prompt(prompt_name, session)
             
             reset_status = """<div style="padding: 1em; background-color: #eff6ff; border-left: 4px solid #3b82f6; border-radius: 4px;">
 <h4 style="color: #2563eb; margin-top: 0;">🔄 Reset to Default</h4>
@@ -2235,7 +2242,7 @@ To revert, use "Reset to Default" button.
         # Prompt editing events
         load_prompt_btn.click(
             load_prompt,
-            inputs=[prompt_selector],
+            inputs=[prompt_selector, session_data],
             outputs=[prompt_editor, prompt_info_display, prompt_status]
         )
         
@@ -2254,7 +2261,7 @@ To revert, use "Reset to Default" button.
         # Auto-load prompt when selector changes
         prompt_selector.change(
             load_prompt,
-            inputs=[prompt_selector],
+            inputs=[prompt_selector, session_data],
             outputs=[prompt_editor, prompt_info_display, prompt_status]
         )
         

tests/test_model_overrides_cross_mode.py

@@ -26,7 +26,7 @@ def test_file_upload_controller_applies_overrides_to_ai_client():
 
 def test_file_upload_batch_passes_override_into_call(monkeypatch):
     controller = FileUploadInterfaceController()
-    controller.set_model_overrides({"SpiritualDistressAnalyzer": "gemini-batch-override"})
+    controller.set_model_overrides({"EntryClassifier": "gemini-batch-override"})
 
     # Minimal session + dataset state so the batch method can run without UI.
     controller.current_session = types.SimpleNamespace(
@@ -60,13 +60,13 @@ def test_file_upload_batch_passes_override_into_call(monkeypatch):
 
     captured = {}
 
-    def fake_call_spiritual_api(*, system_prompt=None, user_prompt=None, model_override=None, **kwargs):
+    def fake_call_entry_classifier_api(*, system_prompt=None, user_prompt=None, model_override=None, **kwargs):
         captured["system_prompt"] = system_prompt
         captured["user_prompt"] = user_prompt
         captured["model_override"] = model_override
         return "green"
 
-    monkeypatch.setattr(controller.ai_client, "call_spiritual_api", fake_call_spiritual_api)
+    monkeypatch.setattr(controller.ai_client, "call_entry_classifier_api", fake_call_entry_classifier_api)
 
     # Run the simplest possible classification path.
     result = controller.run_batch_classification()

tests/verification_mode/test_properties_persistence.py

@@ -213,7 +213,7 @@ class TestSessionStatePersistence:
         assert restored_session.is_complete == session.is_complete
 
     @given(verification_session_strategy())
-    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture], deadline=None)
     def test_session_with_multiple_records_persists(
         self, verification_store, session
     ):