Update app.py

app.py

@@ -18,64 +18,82 @@ if GEMINI_API_KEY:
         genai.configure(api_key=GEMINI_API_KEY)
         genai_client_configured = True
     except Exception as e:
-        st.error(f"Failed to configure Google Generative AI: {e}")
+        st.error(f"Fatal Error: Failed to configure Google Generative AI. Check API Key. Details: {e}")
         st.stop() # Stop execution if configuration fails
 else:
     st.error("⚠️ Gemini API Key not found. Please configure `GEMINI_API_KEY` in Streamlit secrets or environment variables.")
     st.stop() # Stop execution if no API key
 
-# Initialize models (only if client configured)
-# Using specific model versions can be good practice for reproducibility
-TEXT_MODEL_NAME = 'gemini-1.5-flash' # Or 'gemini-pro' if preferred
-VISION_MODEL_NAME = 'gemini-1.5-flash' # Or 'gemini-pro-vision' if preferred
+# Initialize models (Consider more powerful model for agentic reasoning if needed)
+# Using 1.5 Pro for text (agentic) and 1.5 Flash for vision might be a good balance
+TEXT_MODEL_NAME = 'gemini-1.5-pro-latest' # Model for agentic text reasoning
+VISION_MODEL_NAME = 'gemini-1.5-flash' # Model for image analysis
 
 if genai_client_configured:
     try:
-        model = genai.GenerativeModel(TEXT_MODEL_NAME)
+        text_model = genai.GenerativeModel(TEXT_MODEL_NAME)
         vision_model = genai.GenerativeModel(VISION_MODEL_NAME)
+        st.success(f"Successfully initialized models: Text ({TEXT_MODEL_NAME}), Vision ({VISION_MODEL_NAME})", icon="✅")
     except Exception as e:
-        st.error(f"Failed to initialize Gemini models ({TEXT_MODEL_NAME}, {VISION_MODEL_NAME}): {e}")
+        st.error(f"Fatal Error: Failed to initialize Gemini models. Text: {TEXT_MODEL_NAME}, Vision: {VISION_MODEL_NAME}. Details: {e}")
         st.stop()
 else:
-    # This state should technically not be reached due to earlier st.stop() calls,
-    # but it's good defensive programming.
     st.error("AI Models could not be initialized due to configuration issues.")
     st.stop()
 
 
 # --- Core AI Interaction Functions ---
 
-# Define more sophisticated prompts emphasizing analysis and *potential* findings
-# CRITICAL: Avoid definitive "diagnosis" language. Focus on assisting clinical judgment.
-TEXT_ANALYSIS_PROMPT_TEMPLATE = """
-**Medical Information Analysis Request:**
+# AGENTIC prompt for Text Analysis
+AGENTIC_TEXT_ANALYSIS_PROMPT_TEMPLATE = """
+**Simulated Clinical Reasoning Agent Task:**
 
-**Context:** Analyze the provided medical text (symptoms, history, or reports).
-**Task:**
-1.  **Identify Key Findings:** Extract significant symptoms, signs, or data points.
-2.  **Potential Considerations:** Based *only* on the provided text, list potential underlying conditions or areas of concern that *might* warrant further investigation by a qualified healthcare professional. Use cautious language (e.g., "suggests potential for," "could be consistent with," "warrants investigation into").
-3.  **Risk Factors (if applicable):** Mention any potential risk factors identifiable from the text.
-4.  **Information Gaps:** Highlight any missing information that would be crucial for a clinical assessment.
-5.  **Disclaimer:** Explicitly state that this analysis is AI-generated, not a diagnosis, and cannot replace professional medical evaluation.
+**Role:** AI assistant simulating an agentic clinical reasoning process to support a healthcare professional by structuring information, generating possibilities, and suggesting investigation pathways based *strictly* on the provided text. **This is NOT a diagnosis.**
+
+**Input Data:** Unstructured clinical information (e.g., symptoms, history, basic findings).
+
+**Simulated Agentic Steps (Perform sequentially):**
+
+1.  **Information Extraction & Structuring:**
+    *   Key Demographics (Age, Sex if provided).
+    *   Primary Symptoms/Signs.
+    *   Relevant Medical History.
+    *   Pertinent Negatives (if mentioned).
+
+2.  **Differential Considerations Generation:**
+    *   Based *only* on Step 1, list **potential differential considerations** (possible conditions).
+    *   **Use cautious language:** "could be consistent with," "warrants consideration," "less likely but possible." **AVOID definitive statements.**
+    *   Briefly justify each consideration based on findings.
+
+3.  **Information Gap Analysis:**
+    *   Identify critical missing information (e.g., lab results, imaging, exam specifics, duration/onset).
 
-**Input Text:**
+4.  **Suggested Next Steps for Investigation (for Clinician):**
+    *   Propose logical next steps a **healthcare professional might consider**.
+    *   Categorize (e.g., Further History, Exam Points, Labs, Imaging).
+    *   Frame as *suggestions* (e.g., "Consider ordering...", "Assessment of X may be informative").
+
+5.  **Mandatory Disclaimer:** Conclude with: "This AI-generated analysis is for informational support only. It is **NOT** a diagnosis and cannot replace the judgment of a qualified healthcare professional."
+
+**Input Clinical Information:**
 ---
 {text_input}
 ---
 
-**Analysis:**
+**Agentic Analysis:**
 """
 
+# Standard prompt for Image Analysis
 IMAGE_ANALYSIS_PROMPT_TEMPLATE = """
 **Medical Image Analysis Request:**
 
 **Context:** Analyze the provided medical image. User may provide additional context or questions.
 **Task:**
-1.  **Describe Visible Structures:** Briefly describe the main anatomical structures visible.
-2.  **Identify Potential Anomalies:** Point out any visible areas that *appear* abnormal or deviate from typical presentation (e.g., "potential opacity in the lower left lung field," "area of altered signal intensity," "possible asymmetry"). Use cautious, descriptive language.
-3.  **Correlate with User Prompt (if provided):** If the user asked a specific question, address it based *only* on the visual information.
-4.  **Limitations:** State that image quality, view, and lack of clinical context limit the analysis.
-5.  **Disclaimer:** Explicitly state this is an AI-based visual analysis, not a radiological interpretation or diagnosis, and requires review by a qualified radiologist or physician alongside clinical information.
+1.  **Describe Visible Structures:** Briefly describe main anatomical structures.
+2.  **Identify Potential Anomalies:** Point out areas that *appear* abnormal or deviate from typical presentation (e.g., "potential opacity," "altered signal intensity," "possible asymmetry"). Use cautious, descriptive language.
+3.  **Correlate with User Prompt (if provided):** Address specific user questions based *only* on visual information.
+4.  **Limitations:** State that image quality, view, and lack of clinical context limit analysis.
+5.  **Disclaimer:** Explicitly state this is AI visual analysis, not radiological interpretation or diagnosis, requiring review by a qualified professional with clinical context.
 
 **User's Additional Context/Question (if any):**
 ---
@@ -85,190 +103,200 @@ IMAGE_ANALYSIS_PROMPT_TEMPLATE = """
 **Image Analysis:**
 """
 
-def analyze_medical_text(text_input: str) -> Tuple[Optional[str], Optional[str]]:
+def run_agentic_text_analysis(text_input: str) -> Tuple[Optional[str], Optional[str]]:
     """
-    Sends medical text to the Gemini model for analysis using a structured prompt.
+    Sends clinical text to the Gemini text model for simulated agentic analysis.
 
     Args:
-        text_input: The medical text provided by the user.
+        text_input: The clinical text provided by the user.
 
     Returns:
-        A tuple containing:
-        - The analysis text (str) if successful, None otherwise.
-        - An error message (str) if an error occurred, None otherwise.
+        Tuple: (analysis_text, error_message)
     """
-    if not text_input:
+    if not text_input or not text_input.strip():
         return None, "Input text cannot be empty."
     try:
-        prompt = TEXT_ANALYSIS_PROMPT_TEMPLATE.format(text_input=text_input)
-        response = model.generate_content(prompt)
-        # Add safety check for response structure if needed (e.g., check for blocked content)
+        prompt = AGENTIC_TEXT_ANALYSIS_PROMPT_TEMPLATE.format(text_input=text_input)
+        # Using the designated text model
+        response = text_model.generate_content(prompt)
+
         if response.parts:
             return response.text, None
         elif response.prompt_feedback.block_reason:
-             return None, f"Analysis blocked due to: {response.prompt_feedback.block_reason.name}. Please revise input."
+             return None, f"Analysis blocked by safety filters: {response.prompt_feedback.block_reason.name}. Review input."
         else:
-             return None, "Received an empty or unexpected response from the AI."
+             candidate = response.candidates[0] if response.candidates else None
+             if candidate and candidate.finish_reason != "STOP":
+                 return None, f"Analysis stopped prematurely. Reason: {candidate.finish_reason.name}."
+             else:
+                 return None, "Received an empty or unexpected response from the AI model."
 
     except Exception as e:
-        st.error(f"An error occurred during text analysis: {e}") # Log for debugging
-        return None, f"Error communicating with the AI model. Details: {e}"
+        st.error(f"Error during agentic text analysis: {e}", icon="🚨")
+        return None, f"Error communicating with the AI model for text analysis. Details: {e}"
 
 def analyze_medical_image(image_file: Any, user_prompt: str = "") -> Tuple[Optional[str], Optional[str]]:
     """
     Sends a medical image (and optional prompt) to the Gemini Vision model for analysis.
 
     Args:
-        image_file: The uploaded image file object from Streamlit.
-        user_prompt: Optional text context or specific questions from the user.
+        image_file: Uploaded image file object from Streamlit.
+        user_prompt: Optional text context/questions from the user.
 
     Returns:
-        A tuple containing:
-        - The analysis text (str) if successful, None otherwise.
-        - An error message (str) if an error occurred, None otherwise.
+        Tuple: (analysis_text, error_message)
     """
     if not image_file:
         return None, "Image file cannot be empty."
     try:
-        # Ensure image is opened correctly, handle potential errors
         try:
             image = Image.open(image_file)
-            # Optional: Convert image to a supported format if needed, e.g., RGB
             if image.mode != 'RGB':
                  image = image.convert('RGB')
         except Exception as img_e:
              return None, f"Error opening or processing image file: {img_e}"
 
         prompt_text = IMAGE_ANALYSIS_PROMPT_TEMPLATE.format(user_prompt=user_prompt if user_prompt else "N/A")
-
-        # Prepare content for the vision model
         model_input = [prompt_text, image]
-
+        # Using the designated vision model
         response = vision_model.generate_content(model_input)
 
-        # Add safety check for response structure
         if response.parts:
             return response.text, None
         elif response.prompt_feedback.block_reason:
-            return None, f"Analysis blocked due to: {response.prompt_feedback.block_reason.name}. This might be due to sensitive content policies."
+            return None, f"Image analysis blocked by safety filters: {response.prompt_feedback.block_reason.name}. May relate to sensitive content policies."
         else:
-            return None, "Received an empty or unexpected response from the AI."
+             candidate = response.candidates[0] if response.candidates else None
+             if candidate and candidate.finish_reason != "STOP":
+                 return None, f"Image analysis stopped prematurely. Reason: {candidate.finish_reason.name}."
+             else:
+                 return None, "Received an empty or unexpected response from the AI model for image analysis."
 
     except Exception as e:
-        st.error(f"An error occurred during image analysis: {e}") # Log for debugging
-        return None, f"Error communicating with the AI model. Details: {e}"
+        st.error(f"Error during image analysis: {e}", icon="🖼️")
+        return None, f"Error communicating with the AI model for image analysis. Details: {e}"
 
 
 # --- Streamlit User Interface ---
 
 def main():
-    st.set_page_config(page_title="AI Medical Information Assistant", layout="wide")
+    st.set_page_config(
+        page_title="AI Clinical Support Demonstrator",
+        layout="wide",
+        initial_sidebar_state="expanded"
+        )
 
-    st.title("🤖 AI Medical Information Assistant")
-    st.caption(f"Powered by Google Gemini ({TEXT_MODEL_NAME} / {VISION_MODEL_NAME})")
+    st.title("🤖 AI Clinical Support Demonstrator")
+    st.caption(f"Agentic Text Analysis ({TEXT_MODEL_NAME}) & Image Analysis ({VISION_MODEL_NAME})")
+    st.markdown("---")
 
     # --- CRITICAL DISCLAIMER ---
     st.warning(
         """
-        **IMPORTANT DISCLAIMER:**
-        *   This tool uses AI to analyze information but **DOES NOT PROVIDE MEDICAL ADVICE OR DIAGNOSIS.**
-        *   The analysis is based solely on the input provided and may be incomplete, inaccurate, or lack clinical context.
-        *   **ALWAYS consult a qualified healthcare professional** for any health concerns, diagnosis, or treatment decisions.
-        *   Do not rely on this tool for medical decisions. It is for informational and educational purposes only, potentially assisting clinicians by highlighting areas for review.
-        *   **Do not upload identifiable patient information** unless you have explicit consent and comply with all privacy regulations (e.g., HIPAA).
-        """
+        **🔴 IMPORTANT SAFETY & USE DISCLAIMER 🔴**
+        *   This tool **DEMONSTRATES** AI capabilities. It **DOES NOT** provide medical advice or diagnosis.
+        *   **Agentic Text Analysis:** Simulates reasoning on text input. Output is illustrative, not diagnostic.
+        *   **Image Analysis:** Provides observations on images. Output is **NOT** a radiological interpretation.
+        *   AI analysis lacks full clinical context, may be inaccurate, and **CANNOT** replace professional judgment.
+        *   **ALWAYS consult qualified healthcare professionals** for diagnosis and treatment.
+        *   **PRIVACY:** Do **NOT** upload identifiable patient information (PHI) without explicit consent and adherence to all privacy laws (e.g., HIPAA).
+        """,
+        icon="⚠️"
     )
+    st.markdown("---")
+
 
-    st.sidebar.header("Input Options")
+    st.sidebar.header("Analysis Options")
     input_method = st.sidebar.radio(
-        "Select Input Type:",
-        ("Text Description", "Medical Image"),
-        help="Choose whether to analyze text-based medical information or a medical image."
+        "Select Analysis Type:",
+        ("Agentic Text Analysis", "Medical Image Analysis"),
+        key="input_method_radio",
+        help="Choose 'Agentic Text Analysis' for reasoning simulation on clinical text, or 'Medical Image Analysis' for visual observations on images."
     )
-
     st.sidebar.markdown("---") # Visual separator
 
     col1, col2 = st.columns(2)
 
     with col1:
-        st.header("Input")
-        if input_method == "Text Description":
-            st.subheader("Enter Medical Text")
+        st.header("Input Data")
+        analysis_result = None # Initialize results variables
+        error_message = None
+        output_header = "Analysis Results" # Default header for the output column
+
+        # --- Agentic Text Analysis Input ---
+        if input_method == "Agentic Text Analysis":
+            st.subheader("Clinical Text for Agentic Analysis")
             text_input = st.text_area(
-                "Paste symptoms, patient history excerpt, or non-identifiable report sections:",
-                height=300,
-                placeholder="Example: 55-year-old male presents with intermittent chest pain, worse on exertion. History of hypertension. Non-smoker...",
-                key="text_input_area" # Add key for potential state management
+                "Paste de-identified clinical information (symptoms, history, findings):",
+                height=350, # Slightly larger text area
+                placeholder="Example: 68yo male, sudden SOB & pleuritic chest pain post-flight. HR 110, SpO2 92% RA. No known cardiac hx...",
+                key="text_input_area"
             )
-            analyze_button = st.button("Analyze Text", key="analyze_text_button", type="primary")
-
-            if analyze_button and text_input:
-                with st.spinner("🧠 Analyzing Text... Please wait."):
-                    analysis_result, error_message = analyze_medical_text(text_input)
-
-                if error_message:
-                     with col2:
-                        st.error(f"Analysis Failed: {error_message}")
-                elif analysis_result:
-                     with col2:
-                        st.header("Analysis Results")
-                        st.markdown(analysis_result) # Use markdown for better formatting
-                else:
-                    # Handle unexpected case where both are None
-                     with col2:
-                         st.error("An unknown error occurred during analysis.")
-
-            elif analyze_button and not text_input:
-                 st.warning("Please enter some text to analyze.")
+            analyze_button = st.button("▶️ Run Agentic Text Analysis", key="analyze_text_button", type="primary")
 
+            if analyze_button:
+                if text_input:
+                    with st.spinner("🧠 Simulating agentic reasoning..."):
+                        analysis_result, error_message = run_agentic_text_analysis(text_input)
+                    output_header = "Simulated Agentic Analysis Output"
+                else:
+                    st.warning("Please enter clinical text to analyze.", icon="☝️")
 
-        elif input_method == "Medical Image":
-            st.subheader("Upload Medical Image")
+        # --- Medical Image Analysis Input ---
+        elif input_method == "Medical Image Analysis":
+            st.subheader("Medical Image for Analysis")
             image_file = st.file_uploader(
-                "Upload an image (e.g., X-ray, CT slice, pathology slide). Supported: PNG, JPG, JPEG.",
+                "Upload a de-identified medical image (e.g., X-ray, CT slice). Supported: PNG, JPG, JPEG.",
                 type=["png", "jpg", "jpeg"],
                 key="image_uploader"
             )
             user_image_prompt = st.text_input(
-                "Optional: Add context or specific questions for the image analysis:",
-                placeholder="Example: 'Check for abnormalities in the left lung apex' or 'Patient context: Follow-up scan after treatment'",
+                "Optional: Add context or specific question for image analysis:",
+                placeholder="Example: 'Describe findings in the lung fields' or 'Any visible fractures?'",
                 key="image_prompt_input"
             )
-            analyze_button = st.button("Analyze Image", key="analyze_image_button", type="primary")
-
-            if analyze_button and image_file:
-                 # Display uploaded image immediately for confirmation
-                 st.image(image_file, caption="Uploaded Image Preview", use_column_width=True)
-                 with st.spinner("🖼️ Analyzing Image... Please wait."):
-                     analysis_result, error_message = analyze_medical_image(image_file, user_image_prompt)
-
-                 if error_message:
-                     with col2:
-                        st.error(f"Analysis Failed: {error_message}")
-                 elif analysis_result:
-                     with col2:
-                        st.header("Image Analysis Results")
-                        st.markdown(analysis_result)
-                 else:
-                      with col2:
-                        st.error("An unknown error occurred during analysis.")
-
-            elif analyze_button and not image_file:
-                 st.warning("Please upload an image file to analyze.")
-
-
-    # Display placeholder in result column if nothing submitted yet
-    # Check if 'analysis_result' or 'error_message' exists in session state if needed for persistence,
-    # but for this simpler flow, checking button presses is often sufficient.
-    # A simple way is to check if the button was pressed in the current run.
-    button_pressed = st.session_state.get('analyze_text_button', False) or st.session_state.get('analyze_image_button', False)
-    if not button_pressed:
-         with col2:
-             st.info("Analysis results will appear here once input is submitted.")
+            analyze_button = st.button("🖼️ Analyze Medical Image", key="analyze_image_button", type="primary")
+
+            if analyze_button:
+                if image_file:
+                    st.image(image_file, caption="Uploaded Image Preview", use_column_width=True)
+                    with st.spinner("👁️ Analyzing image..."):
+                        analysis_result, error_message = analyze_medical_image(image_file, user_image_prompt)
+                    output_header = "Medical Image Analysis Output"
+                else:
+                    st.warning("Please upload an image file to analyze.", icon="☝️")
+
+    # --- Output Column ---
+    with col2:
+        st.header(output_header)
+        # Check if a button was pressed in this run (using session state keys is more robust for complex apps,
+        # but checking the result variables works here as they are reset on each run unless persisted).
+        button_pressed = st.session_state.get('analyze_text_button', False) or st.session_state.get('analyze_image_button', False)
+
+        if button_pressed: # Only show results if a button was pressed in this run cycle
+            if error_message:
+                 st.error(f"Analysis Failed: {error_message}", icon="❌")
+            elif analysis_result:
+                 st.markdown(analysis_result) # Display the successful result
+            # Removed the "unknown error" case here, as the functions should return either result or error message
+        else:
+            st.info("Analysis results will appear here after providing input and clicking the corresponding analysis button.")
 
 
+    # --- Sidebar Explanations ---
+    st.sidebar.markdown("---")
+    st.sidebar.header("About The Prompts")
+    with st.sidebar.expander("View Agentic Text Prompt Structure"):
+        st.markdown(f"```plaintext\n{AGENTIC_TEXT_ANALYSIS_PROMPT_TEMPLATE.split('---')[0]} ... [Input Text] ...\n```")
+        st.caption("Guides the AI through structured reasoning steps for text.")
+    with st.sidebar.expander("View Image Analysis Prompt Structure"):
+        st.markdown(f"```plaintext\n{IMAGE_ANALYSIS_PROMPT_TEMPLATE.split('---')[0]} ... [User Prompt] ...\n```")
+        st.caption("Guides the AI to describe visual features and potential anomalies in images.")
+
     st.sidebar.markdown("---")
-    st.sidebar.info("Remember: This AI tool is an assistant, not a substitute for professional medical expertise.")
+    st.sidebar.error(
+        "**Ethical Use Reminder:** AI in medicine requires extreme caution. This tool is for demonstration and education, not clinical practice. Verify all information and rely on professional expertise."
+        )
 
 if __name__ == "__main__":
     main()