Update app.py

app.py

@@ -4,7 +4,7 @@ import pandas as pd
 import pdfplumber
 import json
 import gradio as gr
-from typing import List, Dict, Generator, Any
+from typing import List, Dict, Generator, Any, Optional
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import hashlib
 import shutil
@@ -14,94 +14,50 @@ import subprocess
 import logging
 import torch
 import gc
-import atexit
-import signal
 from diskcache import Cache
 from transformers import AutoTokenizer
-from datetime import datetime
+from pathlib import Path
 
 # ==================== CONFIGURATION ====================
-# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Setup directories
-PERSISTENT_DIR = "/data/hf_cache"
+# Directory Setup
+BASE_DIR = Path("/data/hf_cache")
 DIRECTORIES = {
-    "models": os.path.join(PERSISTENT_DIR, "txagent_models"),
-    "tools": os.path.join(PERSISTENT_DIR, "tool_cache"),
-    "cache": os.path.join(PERSISTENT_DIR, "cache"),
-    "reports": os.path.join(PERSISTENT_DIR, "reports"),
-    "vllm": os.path.join(PERSISTENT_DIR, "vllm_cache")
+    "models": BASE_DIR / "txagent_models",
+    "tools": BASE_DIR / "tool_cache",
+    "cache": BASE_DIR / "cache",
+    "reports": BASE_DIR / "reports",
+    "vllm": BASE_DIR / "vllm_cache"
 }
 
-# Create directories
 for dir_path in DIRECTORIES.values():
-    os.makedirs(dir_path, exist_ok=True)
+    dir_path.mkdir(parents=True, exist_ok=True)
 
-# Environment variables
+# Environment Configuration
 os.environ.update({
-    "HF_HOME": DIRECTORIES["models"],
-    "TRANSFORMERS_CACHE": DIRECTORIES["models"],
-    "VLLM_CACHE_DIR": DIRECTORIES["vllm"],
+    "HF_HOME": str(DIRECTORIES["models"]),
+    "TRANSFORMERS_CACHE": str(DIRECTORIES["models"]),
+    "VLLM_CACHE_DIR": str(DIRECTORIES["vllm"]),
     "TOKENIZERS_PARALLELISM": "false",
     "CUDA_LAUNCH_BLOCKING": "1"
 })
 
-# Add src path for txagent
-current_dir = os.path.dirname(os.path.abspath(__file__))
-src_path = os.path.abspath(os.path.join(current_dir, "src"))
-sys.path.insert(0, src_path)
-
-from txagent.txagent import TxAgent
-
-# Log Gradio version for debugging
-logger.info(f"Gradio version: {gr.__version__}")
-
-# ==================== UTILITY FUNCTIONS ====================
-def sanitize_text(text: str) -> str:
-    """Clean and sanitize text input"""
-    return text.encode("utf-8", "ignore").decode("utf-8")
-
-def get_file_hash(file_path: str) -> str:
-    """Generate MD5 hash of file content"""
-    with open(file_path, "rb") as f:
-        return hashlib.md5(f.read()).hexdigest()
-
-def log_system_resources(tag: str = "") -> None:
-    """Log system resource usage"""
-    try:
-        cpu = psutil.cpu_percent(interval=1)
-        mem = psutil.virtual_memory()
-        logger.info(f"[{tag}] CPU: {cpu:.1f}% | RAM: {mem.used//(1024**2)}MB/{mem.total//(1024**2)}MB")
-        
-        gpu_info = subprocess.run(
-            ["nvidia-smi", "--query-gpu=memory.used,memory.total,utilization.gpu", 
-             "--format=csv,nounits,noheader"],
-            capture_output=True, text=True
-        )
-        if gpu_info.returncode == 0:
-            used, total, util = gpu_info.stdout.strip().split(", ")
-            logger.info(f"[{tag}] GPU: {used}MB/{total}MB | Util: {util}%")
-    except Exception as e:
-        logger.error(f"[{tag}] Resource monitoring failed: {e}")
-
-# ==================== FILE PROCESSING ====================
+# ==================== CORE COMPONENTS ====================
 class FileProcessor:
+    """Handles all file processing operations"""
+    
     @staticmethod
-    def extract_pdf_text(file_path: str, cache: Cache) -> str:
-        """Extract text from PDF with caching"""
-        cache_key = f"pdf_{get_file_hash(file_path)}"
-        if cache_key in cache:
-            return cache[cache_key]
-        
+    def extract_pdf_content(file_path: str) -> str:
+        """Extract text from PDF with parallel processing"""
         try:
             with pdfplumber.open(file_path) as pdf:
                 total_pages = len(pdf.pages)
                 if not total_pages:
                     return ""
 
-            def process_page_range(start: int, end: int) -> List[tuple]:
+            def process_batch(start: int, end: int) -> List[tuple]:
                 results = []
                 with pdfplumber.open(file_path) as pdf:
                     for page in pdf.pages[start:end]:
@@ -110,193 +66,180 @@ class FileProcessor:
                         results.append((page_num, f"=== Page {page_num + 1} ===\n{text.strip()}"))
                 return results
 
-            batch_size = 10
-            batches = [(i, min(i+batch_size, total_pages)) for i in range(0, total_pages, batch_size)]
+            batch_size = min(10, total_pages)
+            batches = [(i, min(i + batch_size, total_pages)) for i in range(0, total_pages, batch_size)]
             text_chunks = [""] * total_pages
 
-            with ThreadPoolExecutor(max_workers=2) as executor:
-                futures = [executor.submit(process_page_range, start, end) for start, end in batches]
+            with ThreadPoolExecutor(max_workers=min(6, os.cpu_count() or 4)) as executor:
+                futures = [executor.submit(process_batch, start, end) for start, end in batches]
                 for future in as_completed(futures):
                     for page_num, text in future.result():
                         text_chunks[page_num] = text
 
-            result = "\n\n".join(filter(None, text_chunks))
-            cache[cache_key] = result
-            return result
+            return "\n\n".join(filter(None, text_chunks))
         except Exception as e:
-            logger.error(f"PDF processing error: {e}")
+            logger.error(f"PDF extraction failed: {e}")
             return f"PDF processing error: {str(e)}"
 
     @staticmethod
-    def excel_to_data(file_path: str, cache: Cache) -> List[Dict]:
-        """Convert Excel file to structured data with caching"""
-        cache_key = f"excel_{get_file_hash(file_path)}"
-        if cache_key in cache:
-            return cache[cache_key]
-        
-        try:
-            df = pd.read_excel(file_path, engine='openpyxl', header=None, dtype=str)
-            content = df.where(pd.notnull(df), "").astype(str).values.tolist()
-            result = [{"filename": os.path.basename(file_path), "rows": content, "type": "excel"}]
-            cache[cache_key] = result
-            return result
-        except Exception as e:
-            logger.error(f"Excel processing error: {e}")
-            return [{"error": f"Excel processing error: {str(e)}"}]
-
-    @staticmethod
-    def csv_to_data(file_path: str, cache: Cache) -> List[Dict]:
-        """Convert CSV file to structured data with caching"""
-        cache_key = f"csv_{get_file_hash(file_path)}"
-        if cache_key in cache:
-            return cache[cache_key]
-        
+    def process_tabular_data(file_path: str, file_type: str) -> List[Dict]:
+        """Process Excel or CSV files"""
         try:
-            chunks = []
-            for chunk in pd.read_csv(
-                file_path, header=None, dtype=str,
-                encoding_errors='replace', on_bad_lines='skip', chunksize=10000
-            ):
-                chunks.append(chunk)
+            if file_type == "csv":
+                chunks = pd.read_csv(
+                    file_path, 
+                    header=None,
+                    dtype=str,
+                    encoding_errors='replace',
+                    on_bad_lines='skip',
+                    chunksize=10000
+                )
+                df = pd.concat(chunks) if chunks else pd.DataFrame()
+            else:  # Excel
+                try:
+                    df = pd.read_excel(file_path, engine='openpyxl', header=None, dtype=str)
+                except:
+                    df = pd.read_excel(file_path, engine='xlrd', header=None, dtype=str)
             
-            df = pd.concat(chunks) if chunks else pd.DataFrame()
-            content = df.where(pd.notnull(df), "").astype(str).values.tolist()
-            result = [{"filename": os.path.basename(file_path), "rows": content, "type": "csv"}]
-            cache[cache_key] = result
-            return result
+            return [{
+                "filename": os.path.basename(file_path),
+                "rows": df.where(pd.notnull(df), "").astype(str).values.tolist(),
+                "type": file_type
+            }]
         except Exception as e:
-            logger.error(f"CSV processing error: {e}")
-            return [{"error": f"CSV processing error: {str(e)}"}]
+            logger.error(f"{file_type.upper()} processing failed: {e}")
+            return [{"error": f"{file_type.upper()} processing error: {str(e)}"}]
 
     @classmethod
-    def process_file(cls, file_path: str, file_type: str, cache: Cache) -> List[Dict]:
+    def handle_upload(cls, file_path: str, file_type: str) -> List[Dict]:
         """Route file processing based on type"""
-        processors = {
-            "pdf": cls.extract_pdf_text,
-            "xls": cls.excel_to_data,
-            "xlsx": cls.excel_to_data,
-            "csv": cls.csv_to_data
+        processor_map = {
+            "pdf": cls.extract_pdf_content,
+            "xls": lambda x: cls.process_tabular_data(x, "excel"),
+            "xlsx": lambda x: cls.process_tabular_data(x, "excel"),
+            "csv": lambda x: cls.process_tabular_data(x, "csv")
         }
         
-        if file_type not in processors:
+        if file_type not in processor_map:
             return [{"error": f"Unsupported file type: {file_type}"}]
         
         try:
-            result = processors[file_type](file_path, cache)
+            result = processor_map[file_type](file_path)
             if file_type == "pdf":
                 return [{
                     "filename": os.path.basename(file_path),
                     "content": result,
-                    "status": "initial",
                     "type": "pdf"
                 }]
             return result
         except Exception as e:
-            logger.error(f"Error processing {file_type} file: {e}")
-            return [{"error": f"Error processing file: {str(e)}"}]
+            logger.error(f"File processing failed: {e}")
+            return [{"error": f"File processing error: {str(e)}"}]
 
-# ==================== TEXT PROCESSING ====================
-class TextProcessor:
+class TextAnalyzer:
+    """Handles text processing and analysis"""
+    
     def __init__(self):
         self.tokenizer = AutoTokenizer.from_pretrained("mims-harvard/TxAgent-T1-Llama-3.1-8B")
         self.cache = Cache(DIRECTORIES["cache"], size_limit=10*1024**3)
-
-    def chunk_text(self, text: str, max_tokens: int = 1200) -> List[str]:
+        
+    def chunk_content(self, text: str, max_tokens: int = 1800) -> List[str]:
         """Split text into token-limited chunks"""
         tokens = self.tokenizer.encode(text)
         return [
             self.tokenizer.decode(tokens[i:i+max_tokens])
             for i in range(0, len(tokens), max_tokens)
         ]
-
-    def clean_response(self, text: str) -> str:
+    
+    def clean_output(self, text: str) -> str:
         """Clean and format model response"""
-        text = sanitize_text(text)
-        text = re.sub(r"\[.*?\]|\bNone\b", "", text)
+        text = text.encode("utf-8", "ignore").decode("utf-8")
+        text = re.sub(
+            r"\[.*?\]|\bNone\b|To analyze the patient record excerpt.*?medications\."
+            r"|Since the previous attempts.*?\.|I need to.*?medications\."
+            r"|Retrieving tools.*?\.", "", text, flags=re.DOTALL
+        )
         
         diagnoses = []
-        in_diagnoses = False
+        in_section = False
         
         for line in text.splitlines():
             line = line.strip()
             if not line:
                 continue
             if re.match(r"###\s*Missed Diagnoses", line):
-                in_diagnoses = True
+                in_section = True
                 continue
             if re.match(r"###\s*(Medication Conflicts|Incomplete Assessments|Urgent Follow-up)", line):
-                in_diagnoses = False
+                in_section = False
                 continue
-            if in_diagnoses and re.match(r"-\s*.+", line):
+            if in_section and re.match(r"-\s*.+", line):
                 diagnosis = re.sub(r"^\-\s*", "", line).strip()
                 if diagnosis and not re.match(r"No issues identified", diagnosis, re.IGNORECASE):
                     diagnoses.append(diagnosis)
         
         return " ".join(diagnoses) if diagnoses else ""
-
-    def summarize_results(self, analysis: str) -> str:
-        """Generate concise summary from full analysis"""
-        chunks = analysis.split("--- Analysis for Chunk")
-        diagnoses = []
-        
-        for chunk in chunks:
+    
+    def generate_summary(self, analysis: str) -> str:
+        """Create concise clinical summary"""
+        findings = []
+        for chunk in analysis.split("--- Analysis for Chunk"):
             chunk = chunk.strip()
             if not chunk or "No oversights identified" in chunk:
                 continue
                 
-            in_diagnoses = False
+            in_section = False
             for line in chunk.splitlines():
                 line = line.strip()
                 if not line:
                     continue
                 if re.match(r"###\s*Missed Diagnoses", line):
-                    in_diagnoses = True
+                    in_section = True
                     continue
                 if re.match(r"###\s*(Medication Conflicts|Incomplete Assessments|Urgent Follow-up)", line):
-                    in_diagnoses = False
+                    in_section = False
                     continue
-                if in_diagnoses and re.match(r"-\s*.+", line):
-                    diagnosis = re.sub(r"^\-\s*", "", line).strip()
-                    if diagnosis and not re.match(r"No issues identified", diagnosis, re.IGNORECASE):
-                        diagnoses.append(diagnosis)
+                if in_section and re.match(r"-\s*.+", line):
+                    finding = re.sub(r"^\-\s*", "", line).strip()
+                    if finding and not re.match(r"No issues identified", finding, re.IGNORECASE):
+                        findings.append(finding)
         
-        unique_diagnoses = list(dict.fromkeys(diagnoses))
+        unique_findings = list(dict.fromkeys(findings))
         
-        if not unique_diagnoses:
-            return "No missed diagnoses were identified in the provided records."
+        if not unique_findings:
+            return "No clinical concerns identified in the provided records."
         
-        if len(unique_diagnoses) > 1:
-            summary = "Missed diagnoses include " + ", ".join(unique_diagnoses[:-1])
-            summary += f", and {unique_diagnoses[-1]}"
+        if len(unique_findings) > 1:
+            summary = "Potential concerns include: " + ", ".join(unique_findings[:-1])
+            summary += f", and {unique_findings[-1]}"
         else:
-            summary = "Missed diagnoses include " + unique_diagnoses[0]
+            summary = "Potential concern identified: " + unique_findings[0]
         
-        return summary + ", all requiring urgent clinical review."
+        return summary + ". Recommend urgent clinical review."
 
-# ==================== CORE APPLICATION ====================
-class ClinicalOversightApp:
+class ClinicalAgent:
+    """Main application controller"""
+    
     def __init__(self):
-        self.agent = self._initialize_agent()
-        self.text_processor = TextProcessor()
+        self.agent = self._init_agent()
         self.file_processor = FileProcessor()
-        atexit.register(self.cleanup_resources)
-        signal.signal(signal.SIGTERM, self._signal_handler)
-        signal.signal(signal.SIGINT, self._signal_handler)
-
-    def _initialize_agent(self):
-        """Initialize the TxAgent with proper configuration"""
-        logger.info("Initializing AI model...")
-        log_system_resources("Before Load")
+        self.text_analyzer = TextAnalyzer()
+    
+    def _init_agent(self) -> Any:
+        """Initialize the AI agent"""
+        logger.info("Initializing clinical agent...")
+        self._log_system_status("pre-init")
+        
+        tool_path = DIRECTORIES["tools"] / "new_tool.json"
+        if not tool_path.exists():
+            default_tools = Path("data/new_tool.json")
+            if default_tools.exists():
+                shutil.copy(default_tools, tool_path)
         
-        tool_path = os.path.join(DIRECTORIES["tools"], "new_tool.json")
-        if not os.path.exists(tool_path):
-            default_tools = os.path.abspath("data/new_tool.json")
-            shutil.copy(default_tools, tool_path)
-
         agent = TxAgent(
             model_name="mims-harvard/TxAgent-T1-Llama-3.1-8B",
             rag_model_name="mims-harvard/ToolRAG-T1-GTE-Qwen2-1.5B",
-            tool_files_dict={"new_tool": tool_path},
+            tool_files_dict={"new_tool": str(tool_path)},
             force_finish=True,
             enable_checker=False,
             step_rag_num=4,
@@ -305,785 +248,299 @@ class ClinicalOversightApp:
         )
         agent.init_model()
         
-        log_system_resources("After Load")
-        logger.info("AI Agent Ready")
+        self._log_system_status("post-init")
+        logger.info("Clinical agent ready")
         return agent
-
-    def _signal_handler(self, signum, frame):
-        """Handle termination signals"""
-        logger.info(f"Received signal {signum}, cleaning up...")
-        self.cleanup_resources()
-        sys.exit(0)
-
-    def cleanup_resources(self):
-        """Clean up GPU memory and collect garbage"""
-        logger.info("Cleaning up resources...")
-        log_system_resources("Before Cleanup")
-        torch.cuda.empty_cache()
-        gc.collect()
-        for _ in range(2):  # Retry to ensure cleanup
-            try:
-                if torch.distributed.is_initialized():
-                    logger.info("Destroying PyTorch distributed process group...")
-                    torch.distributed.destroy_process_group()
-                    break
-            except Exception as e:
-                logger.error(f"Cleanup error: {e}")
-        log_system_resources("After Cleanup")
-
-    def process_response_stream(self, prompt: str, history: List[dict]) -> Generator[dict, None, None]:
-        """Stream the agent's response with proper formatting"""
+    
+    def _log_system_status(self, phase: str) -> None:
+        """Log system resource utilization"""
+        try:
+            cpu = psutil.cpu_percent(interval=1)
+            mem = psutil.virtual_memory()
+            logger.info(f"[{phase}] CPU: {cpu:.1f}% | RAM: {mem.used//(1024**2)}MB/{mem.total//(1024**2)}MB")
+            
+            gpu_info = subprocess.run(
+                ["nvidia-smi", "--query-gpu=memory.used,memory.total,utilization.gpu", 
+                 "--format=csv,nounits,noheader"],
+                capture_output=True, text=True
+            )
+            if gpu_info.returncode == 0:
+                used, total, util = gpu_info.stdout.strip().split(", ")
+                logger.info(f"[{phase}] GPU: {used}MB/{total}MB | Util: {util}%")
+        except Exception as e:
+            logger.error(f"Resource monitoring failed: {e}")
+    
+    def process_stream(self, prompt: str, history: List[Dict]) -> Generator[Dict, None, None]:
+        """Stream the agent's responses"""
         full_response = ""
         for chunk in self.agent.run_gradio_chat(prompt, [], 0.2, 512, 2048, False, []):
             if not chunk:
                 continue
             
             if isinstance(chunk, list):
-                for message in chunk:
-                    if hasattr(message, 'content') and message.content:
-                        cleaned = self.text_processor.clean_response(message.content)
+                for msg in chunk:
+                    if hasattr(msg, 'content') and msg.content:
+                        cleaned = self.text_analyzer.clean_output(msg.content)
                         if cleaned:
                             full_response += cleaned + " "
-                            yield {
-                                "role": "assistant",
-                                "content": f"✅ {cleaned} [{datetime.now().strftime('%H:%M:%S')}]"
-                            }
+                            yield {"role": "assistant", "content": full_response}
             elif isinstance(chunk, str) and chunk.strip():
-                cleaned = self.text_processor.clean_response(chunk)
+                cleaned = self.text_analyzer.clean_output(chunk)
                 if cleaned:
                     full_response += cleaned + " "
-                    yield {
-                        "role": "assistant",
-                        "content": f"✅ {cleaned} [{datetime.now().strftime('%H:%M:%S')}]"
-                    }
-
-    def analyze(self, message: str, history: List[dict], files: List) -> Generator[tuple, None, None]:
-        """Main analysis pipeline with proper output formatting"""
-        chatbot_output = history.copy()
-        download_output = None
-        final_summary = ""
-        progress_text = {"value": "Starting analysis...", "visible": True}
+                    yield {"role": "assistant", "content": full_response}
+    
+    def analyze_records(self, message: str, history: List[Dict], files: List) -> Generator[Dict[str, Any], None, None]:
+        """Main analysis workflow"""
+        outputs = {
+            "chatbot": history.copy(),
+            "download_output": None,
+            "final_summary": "",
+            "progress": {"value": "Initializing...", "visible": True}
+        }
+        yield outputs
         
         try:
-            # Add user message to history
-            chatbot_output.append({
-                "role": "user",
-                "content": f"{message} [{datetime.now().strftime('%H:%M:%S')}]"
-            })
-            yield (chatbot_output, download_output, final_summary, progress_text)
+            # Add user message
+            history.append({"role": "user", "content": message})
+            outputs["chatbot"] = history
+            yield outputs
             
-            # Process uploaded files
+            # Process files
             extracted = []
-            file_hash_value = ""
+            file_hash = ""
             
             if files:
-                with ThreadPoolExecutor(max_workers=2) as executor:
+                with ThreadPoolExecutor(max_workers=4) as executor:
                     futures = []
                     for f in files:
-                        file_type = f.name.split(".")[-1].lower()
-                        futures.append(executor.submit(self.file_processor.process_file, f.name, file_type, self.text_processor.cache))
+                        file_type = Path(f.name).suffix[1:].lower()
+                        futures.append(executor.submit(
+                            self.file_processor.handle_upload, 
+                            f.name, 
+                            file_type
+                        ))
                     
                     for i, future in enumerate(as_completed(futures), 1):
                         try:
                             extracted.extend(future.result())
-                            progress_text = self._update_progress(i, len(files), "Processing files")
-                            yield (chatbot_output, download_output, final_summary, progress_text)
+                            outputs["progress"] = self._format_progress(i, len(files), "Processing files")
+                            yield outputs
                         except Exception as e:
-                            logger.error(f"File processing error: {e}")
-                            extracted.append({"error": f"Error processing file: {str(e)}"})
+                            logger.error(f"File processing failed: {e}")
+                            extracted.append({"error": str(e)})
                 
-                file_hash_value = get_file_hash(files[0].name) if files else ""
-                chatbot_output.append({
-                    "role": "assistant",
-                    "content": f"✅ File processing complete [{datetime.now().strftime('%H:%M:%S')}]"
+                if files and os.path.exists(files[0].name):
+                    file_hash = hashlib.md5(open(files[0].name, "rb").read()).hexdigest()
+                
+                history.append({"role": "assistant", "content": "✅ Files processed successfully"})
+                outputs.update({
+                    "chatbot": history,
+                    "progress": self._format_progress(len(files), len(files), "Files processed")
                 })
-                progress_text = self._update_progress(len(files), len(files), "Files processed")
-                yield (chatbot_output, download_output, final_summary, progress_text)
+                yield outputs
 
             # Analyze content
             text_content = "\n".join(json.dumps(item) for item in extracted)
-            chunks = self.text_processor.chunk_text(text_content)
-            combined_response = ""
+            chunks = self.text_analyzer.chunk_content(text_content)
+            full_analysis = ""
             
-            for chunk_idx, chunk in enumerate(chunks, 1):
+            for idx, chunk in enumerate(chunks, 1):
                 prompt = f"""
-Analyze this patient record for missed diagnoses. Provide a concise, evidence-based summary 
-as a single paragraph without headings or bullet points. Include specific clinical findings 
-with their potential implications and urgent review recommendations. If no missed diagnoses 
-are found, state 'No missed diagnoses identified'.
-
-Patient Record (Chunk {chunk_idx}/{len(chunks)}):
-{chunk[:1200]}
+Analyze this clinical documentation for potential missed diagnoses. Provide:
+1. Specific clinical findings with references (e.g., "Elevated BP (160/95) on page 3")
+2. Their clinical significance
+3. Urgency of review
+Use concise, continuous prose without bullet points. If no concerns, state "No missed diagnoses identified."
+
+Document Excerpt (Part {idx}/{len(chunks)}):
+{chunk[:1750]}
 """
-                chatbot_output.append({"role": "assistant", "content": "⏳ Analyzing..."})
-                progress_text = self._update_progress(chunk_idx, len(chunks), "Analyzing")
-                yield (chatbot_output, download_output, final_summary, progress_text)
+                history.append({"role": "assistant", "content": ""})
+                outputs.update({
+                    "chatbot": history,
+                    "progress": self._format_progress(idx, len(chunks), "Analyzing")
+                })
+                yield outputs
                 
-                # Stream response
+                # Stream analysis
                 chunk_response = ""
-                for update in self.process_response_stream(prompt, chatbot_output):
-                    chatbot_output[-1] = update
+                for update in self.process_stream(prompt, history):
+                    history[-1] = update
                     chunk_response = update["content"]
-                    progress_text = self._update_progress(chunk_idx, len(chunks), "Analyzing")
-                    yield (chatbot_output, download_output, final_summary, progress_text)
+                    outputs.update({
+                        "chatbot": history,
+                        "progress": self._format_progress(idx, len(chunks), "Analyzing")
+                    })
+                    yield outputs
                 
-                combined_response += f"--- Analysis for Chunk {chunk_idx} ---\n{chunk_response}\n"
-                self.cleanup_resources()
+                full_analysis += f"--- Analysis Part {idx} ---\n{chunk_response}\n"
+                torch.cuda.empty_cache()
+                gc.collect()
 
-            # Generate final outputs
-            final_summary = self.text_processor.summarize_results(combined_response)
-            report_path = os.path.join(DIRECTORIES["reports"], f"{file_hash_value}_report.txt") if file_hash_value else None
+            # Final outputs
+            summary = self.text_analyzer.generate_summary(full_analysis)
+            report_path = DIRECTORIES["reports"] / f"{file_hash}_report.txt" if file_hash else None
             
             if report_path:
                 with open(report_path, "w", encoding="utf-8") as f:
-                    f.write(combined_response + "\n\n" + final_summary)
+                    f.write(full_analysis + "\n\nSUMMARY:\n" + summary)
             
-            download_output = report_path if report_path and os.path.exists(report_path) else None
-            progress_text = {"visible": False}
-            yield (chatbot_output, download_output, final_summary, progress_text)
+            outputs.update({
+                "download_output": str(report_path) if report_path and report_path.exists() else None,
+                "final_summary": summary,
+                "progress": {"visible": False}
+            })
+            yield outputs
 
         except Exception as e:
-            logger.error(f"Analysis error: {e}")
-            chatbot_output.append({
-                "role": "assistant",
-                "content": f"❌ Error: {str(e)} [{datetime.now().strftime('%H:%M:%S')}]"
+            logger.error(f"Analysis failed: {e}")
+            history.append({"role": "assistant", "content": f"❌ Analysis error: {str(e)}"})
+            outputs.update({
+                "chatbot": history,
+                "final_summary": f"Error: {str(e)}",
+                "progress": {"visible": False}
             })
-            final_summary = f"Error occurred: {str(e)}"
-            progress_text = {"visible": False}
-            yield (chatbot_output, download_output, final_summary, progress_text)
-        finally:
-            self.cleanup_resources()
-
-    def _update_progress(self, current: int, total: int, stage: str = "") -> Dict[str, Any]:
+            yield outputs
+    
+    def _format_progress(self, current: int, total: int, stage: str = "") -> Dict[str, Any]:
         """Format progress update for UI"""
-        progress = f"{stage} - {current}/{total}" if stage else f"{current}/{total}"
-        return {"value": progress, "visible": True}
-
-    def toggle_theme(self, theme_state: str) -> tuple[str, str]:
-        """Toggle between light and dark themes"""
-        new_theme = "dark" if theme_state == "light" else "light"
-        button_text = "☀️ Light Mode" if new_theme == "dark" else "🌙 Dark Mode"
-        return new_theme, button_text
-
-    def toggle_sidebar(self, sidebar_state: bool) -> bool:
-        """Toggle sidebar visibility"""
-        return not sidebar_state
-
-    def create_interface(self):
-        """Create Gradio interface with refined ChatGPT-like design"""
-        css = """
-        /* ==================== BASE STYLES ==================== */
-        :root {
-            --primary-color: #007bff;
-            --primary-dark: #0056b3;
-            --border-radius: 12px;
-            --transition: all 0.3s ease;
-            --shadow: 0 4px 12px rgba(0,0,0,0.15);
-            --font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            --background: #ffffff;
-            --text-color: #333333;
-            --chat-bg: #f9fafb;
-            --message-bg: #e5e5ea;
-            --sidebar-bg: rgba(241, 243, 245, 0.9);
-            --sidebar-dark-bg: rgba(42, 54, 80, 0.9);
-        }
-
-        [data-theme="dark"] {
-            --background: #1e2a44;
-            --text-color: #ffffff;
-            --chat-bg: #2d3b55;
-            --message-bg: #3e4c6a;
-            --sidebar-bg: var(--sidebar-dark-bg);
-        }
-
-        body, .gradio-container {
-            font-family: var(--font-family);
-            background: var(--background);
-            color: var(--text-color);
-            margin: 0;
-            padding: 0;
-            transition: var(--transition);
-        }
-
-        /* ==================== LAYOUT ==================== */
-        .gradio-container {
-            max-width: 900px;
-            margin: 0 auto;
-            padding: 1.5rem;
-            display: flex;
-            flex-direction: column;
-            gap: 1.5rem;
-        }
-
-        .chat-container {
-            background: var(--chat-bg);
-            border-radius: var(--border-radius);
-            padding: 1.5rem;
-            min-height: 60vh;
-            max-height: 80vh;
-            overflow-y: auto;
-            box-shadow: var(--shadow);
-            position: relative;
-            margin-bottom: 5rem; /* Space for sticky input */
-        }
-
-        .header {
-            text-align: center;
-            margin-bottom: 1.5rem;
-        }
-
-        .header h1 {
-            font-size: 1.8rem;
-            margin: 0.5rem 0;
-        }
-
-        .header p {
-            font-size: 1rem;
-            opacity: 0.7;
-        }
-
-        /* ==================== COMPONENTS ==================== */
-        .chat__message {
-            margin: 0.75rem 0;
-            padding: 0.75rem 1rem;
-            border-radius: var(--border-radius);
-            max-width: 85%;
-            transition: var(--transition);
-            background: var(--message-bg);
-            border: 1px solid rgba(0,0,0,0.05);
-            animation: messageFade 0.3s ease;
-        }
-
-        .chat__message:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-
-        .chat__message.user {
-            background: linear-gradient(135deg, var(--primary-color), var(--primary-dark));
-            color: white;
-            margin-left: auto;
-        }
-
-        .chat__message.assistant {
-            background: var(--message-bg);
-            color: var(--text-color);
-        }
-
-        .chat__message-timestamp {
-            font-size: 0.75rem;
-            opacity: 0.7;
-            margin-top: 0.25rem;
-            text-align: right;
-        }
-
-        .input-container {
-            display: flex;
-            align-items: center;
-            gap: 0.75rem;
-            background: var(--chat-bg);
-            padding: 0.75rem 1rem;
-            border-radius: 1.5rem;
-            box-shadow: var(--shadow);
-            position: sticky;
-            bottom: 1rem;
-            z-index: 10;
-        }
-
-        .input-textbox {
-            flex-grow: 1;
-            border: none;
-            background: transparent;
-            color: var(--text-color);
-            outline: none;
-            font-size: 1rem;
-        }
-
-        .input-textbox:focus {
-            border-bottom: 2px solid var(--primary-color);
-        }
-
-        .send-btn {
-            background: linear-gradient(135deg, var(--primary-color), var(--primary-dark));
-            color: white;
-            border: none;
-            border-radius: 1rem;
-            padding: 0.5rem 1.25rem;
-            font-size: 0.9rem;
-            transition: var(--transition);
-        }
-
-        .send-btn:hover {
-            transform: scale(1.05);
-        }
-
-        .send-btn:active {
-            animation: glow 0.3s ease;
-        }
-
-        .sidebar {
-            background: var(--sidebar-bg);
-            padding: 1.5rem;
-            border-radius: var(--border-radius);
-            box-shadow: var(--shadow);
-            transition: transform 0.4s ease, opacity 0.4s ease;
-            position: fixed;
-            right: 1rem;
-            top: 5rem;
-            width: 320px;
-            max-height: calc(100vh - 6rem);
-            overflow-y: auto;
-            z-index: 1000;
-            animation: fadeInUp 0.4s ease;
-        }
-
-        .sidebar-hidden {
-            transform: translateX(100%);
-            opacity: 0;
-        }
-
-        .sidebar-backdrop {
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0,0,0,0.4);
-            z-index: 999;
-            opacity: 0;
-            transition: opacity 0.4s ease;
-            pointer-events: none;
-        }
-
-        .sidebar:not(.sidebar-hidden) ~ .sidebar-backdrop {
-            opacity: 1;
-            pointer-events: auto;
-        }
-
-        .sidebar__tooltip, .file-tooltip {
-            display: block;
-            margin-bottom: 1rem;
-        }
-
-        .sidebar__tooltip:hover::after, .file-tooltip:hover::after {
-            content: attr(data-tip);
-            position: absolute;
-            top: -2.5rem;
-            left: 50%;
-            transform: translateX(-50%);
-            background: #333;
-            color: white;
-            padding: 0.4rem 0.8rem;
-            border-radius: 0.4rem;
-            font-size: 0.85rem;
-            max-width: 200px;
-            white-space: normal;
-            text-align: center;
-            z-index: 1000;
-            animation: fadeIn 0.3s ease;
-        }
-
-        .theme-toggle {
-            background: linear-gradient(135deg, var(--primary-color), var(--primary-dark));
-            color: white;
-            border: none;
-            border-radius: 1rem;
-            padding: 0.5rem 1rem;
-            font-size: 0.9rem;
-            position: fixed;
-            top: 1rem;
-            right: 1rem;
-            z-index: 100;
-            display: flex;
-            align-items: center;
-            gap: 0.5rem;
-        }
-
-        .tools-button {
-            background: var(--message-bg);
-            color: var(--text-color);
-            border: none;
-            border-radius: 1rem;
-            padding: 0.5rem 1.25rem;
-            font-size: 0.9rem;
-            transition: var(--transition);
-        }
-
-        .tools-button:hover {
-            background: var(--primary-color);
-            color: white;
-        }
-
-        .loading-spinner {
-            position: absolute;
-            bottom: 4rem;
-            left: 50%;
-            transform: translateX(-50%);
-            font-size: 1.2rem;
-            animation: glow 1.5s ease infinite;
-        }
-
-        .typing-indicator {
-            display: none;
-            font-size: 0.9rem;
-            color: var(--text-color);
-            opacity: 0.7;
-            margin: 0.75rem;
-        }
-
-        .typing-indicator.active {
-            display: block;
-            animation: blink 1s step-end infinite;
-        }
-
-        .progress-text {
-            position: relative;
-            padding: 0.5rem;
-            background: var(--message-bg);
-            border-radius: var(--border-radius);
-            margin-top: 0.75rem;
-            overflow: hidden;
-        }
-
-        .progress-text::before {
-            content: '';
-            position: absolute;
-            top: 0;
-            left: 0;
-            height: 100%;
-            width: 0;
-            background: linear-gradient(to right, var(--primary-color), var(--primary-dark));
-            opacity: 0.3;
-            animation: progress 2s ease-in-out infinite;
-        }
-
-        /* ==================== ANIMATIONS ==================== */
-        @keyframes glow {
-            0%, 100% { transform: translateX(-50%) scale(1); opacity: 1; color: var(--primary-color); }
-            50% { transform: translateX(-50%) scale(1.2); opacity: 0.7; color: var(--primary-dark); }
-        }
-
-        @keyframes blink {
-            50% { opacity: 0.3; }
-        }
-
-        @keyframes fadeIn {
-            from { opacity: 0; }
-            to { opacity: 1; }
-        }
-
-        @keyframes fadeInUp {
-            from { opacity: 0; transform: translateY(20px); }
-            to { opacity: 1; transform: translateY(0); }
-        }
-
-        @keyframes messageFade {
-            from { opacity: 0; transform: translateY(10px) scale(0.95); }
-            to { opacity: 1; transform: translateY(0) scale(1); }
-        }
-
-        @keyframes progress {
-            0% { width: 0; }
-            50% { width: 60%; }
-            100% { width: 0; }
-        }
-
-        /* ==================== MEDIA QUERIES ==================== */
-        @media (max-width: 768px) {
-            .gradio-container {
-                padding: 1rem;
-            }
-
-            .chat-container {
-                min-height: 50vh;
-                max-height: 70vh;
-                margin-bottom: 4rem;
-            }
-
-            .sidebar {
-                width: 100%;
-                right: 0;
-                top: 4rem;
-                max-height: calc(100vh - 4rem);
-            }
-
-            .theme-toggle {
-                top: 0.5rem;
-                right: 0.5rem;
-                padding: 0.4rem 0.8rem;
-                font-size: 0.85rem;
-            }
-
-            .input-container {
-                gap: 0.5rem;
-                padding: 0.5rem;
+        status = f"{stage} - {current}/{total}" if stage else f"{current}/{total}"
+        return {"value": status, "visible": True, "label": f"Progress: {status}"}
+
+    def create_interface(self) -> gr.Blocks:
+        """Build the Gradio interface"""
+        with gr.Blocks(
+            theme=gr.themes.Soft(
+                primary_hue="indigo",
+                secondary_hue="blue",
+                neutral_hue="slate"
+            ),
+            title="Clinical Oversight Assistant",
+            css="""
+            .summary-panel {
+                border-left: 4px solid #4f46e5;
+                padding: 16px;
+                background: #f8fafc;
+                border-radius: 8px;
+                margin-bottom: 16px;
             }
-
-            .send-btn {
-                padding: 0.4rem 1rem;
+            .upload-area {
+                border: 2px dashed #cbd5e1;
+                border-radius: 8px;
+                padding: 24px;
+                margin: 12px 0;
             }
-        }
-
-        @media (max-width: 480px) {
             .chat-container {
-                padding: 1rem;
-                margin-bottom: 3.5rem;
-            }
-
-            .input-container {
-                flex-direction: column;
-                padding: 0.5rem;
-            }
-
-            .input-textbox {
-                font-size: 0.9rem;
-            }
-
-            .send-btn {
-                width: 100%;
-                padding: 0.5rem;
-                font-size: 0.85rem;
+                border-radius: 8px;
+                border: 1px solid #e2e8f0;
             }
-
-            .chat__message {
-                max-width: 90%;
-                padding: 0.5rem 0.75rem;
-            }
-
-            .header h1 {
-                font-size: 1.5rem;
-            }
-
-            .header p {
-                font-size: 0.9rem;
-            }
-
-            .sidebar {
-                top: 3.5rem;
-                max-height: calc(100vh - 3.5rem);
-                animation: fadeInUp 0.4s ease;
-            }
-
-            .sidebar__tooltip:hover::after, .file-tooltip:hover::after {
-                top: auto;
-                bottom: -2.5rem;
-                max-width: 80vw;
-            }
-        }
-        """
-        
-        js = """
-        function applyTheme(theme) {
-            document.documentElement.setAttribute('data-theme', theme);
-            localStorage.setItem('theme', theme);
-            document.querySelector('.theme-toggle').innerHTML = theme === 'dark' ? '☀️ Light Mode' : '🌙 Dark Mode';
-        }
-
-        function toggleSidebar() {
-            const sidebar = document.querySelector('.sidebar');
-            sidebar.classList.toggle('sidebar-hidden');
-            if (!sidebar.classList.contains('sidebar-hidden')) {
-                setTimeout(() => {
-                    if (window.innerWidth <= 600) {
-                        sidebar.classList.add('sidebar-hidden');
-                    }
-                }, 5000);
-            }
-        }
-
-        document.addEventListener('DOMContentLoaded', () => {
-            const savedTheme = localStorage.getItem('theme') || 'light';
-            applyTheme(savedTheme);
-            document.querySelector('.sidebar').classList.add('sidebar-hidden');
-        });
-        """
-
-        with gr.Blocks(theme=gr.themes.Default(), css=css, js=js, title="Clinical Oversight Assistant") as app:
-            try:
-                theme_state = gr.State(value="light")
-                sidebar_state = gr.State(value=False)
-                
-                gr.HTML("""
-                <div class='header'>
-                    <h1 style='color: var(--text-color);'>🩺 Clinical Oversight Assistant</h1>
-                    <p style='color: var(--text-color); opacity: 0.7;'>
-                        AI-powered analysis of patient records for missed diagnoses
-                    </p>
-                </div>
-                <div class='sidebar-backdrop'></div>
-                """)
-                
-                theme_button = gr.Button("🌙 Dark Mode", elem_classes="theme-toggle")
-                
-                with gr.Column(elem_classes="chat-container"):
+            """
+        ) as app:
+            # Header
+            gr.Markdown("""
+            <div style='text-align: center; margin-bottom: 24px;'>
+                <h1 style='color: #4f46e5; margin-bottom: 8px;'>🩺 Clinical Oversight Assistant</h1>
+                <p style='color: #64748b;'>
+                    AI-powered analysis for identifying potential missed diagnoses in patient records
+                </p>
+            </div>
+            """)
+
+            with gr.Row(equal_height=False):
+                # Main Chat Panel
+                with gr.Column(scale=3):
+                    gr.Markdown("**Clinical Analysis Conversation**")
                     chatbot = gr.Chatbot(
-                        label="Clinical Analysis",
-                        height="100%",
+                        label="",
+                        height=650,
                         show_copy_button=True,
+                        avatar_images=(
+                            "assets/user.png", 
+                            "assets/assistant.png"
+                        ) if Path("assets/user.png").exists() else None,
+                        bubble_full_width=False,
                         type="messages",
-                        elem_classes="chatbot",
-                        render_markdown=True
-                    )
-                    gr.HTML("<div class='loading-spinner' style='display: none;'>⏳</div>")
-                    gr.HTML("<div class='typing-indicator'>Typing...</div>")
-                
-                with gr.Row():
-                    tools_button = gr.Button("📂 Tools", variant="secondary", elem_classes="tools-button")
-                
-                with gr.Column(elem_classes="sidebar"):
-                    gr.Markdown(
-                        "<div class='sidebar__tooltip' data-tip='Upload patient records'>### 📎 Upload Records</div>",
-                        elem_classes="markdown-tooltip"
+                        elem_classes=["chat-container"]
                     )
-                    gr.HTML(
-                        "<div class='file-tooltip' data-tip='Select PDF, CSV, or Excel files'>"
-                    )
-                    file_upload = gr.File(
-                        file_types=[".pdf", ".csv", ".xls", ".xlsx"],
-                        file_count="multiple",
-                        label="Patient Records",
-                        elem_classes="file-input"
-                    )
-                    gr.HTML("</div>")
-                    gr.Markdown(
-                        "<div class='sidebar__tooltip' data-tip='Summary of findings'>### 📝 Analysis Summary</div>",
-                        elem_classes="markdown-tooltip"
-                    )
-                    final_summary = gr.Markdown(
-                        "<div class='sidebar__tooltip' data-tip='View analysis results'>Analysis results will appear here...</div>",
-                        elem_classes="markdown-tooltip"
-                    )
-                    gr.Markdown(
-                        "<div class='sidebar__tooltip' data-tip='Download full report'>### 📄 Full Report</div>",
-                        elem_classes="markdown-tooltip"
-                    )
-                    gr.HTML(
-                        "<div class='file-tooltip' data-tip='Download analysis report'>"
-                    )
-                    download_output = gr.File(
-                        label="Download Report",
-                        visible=False,
-                        interactive=False,
-                        elem_classes="file-output"
-                    )
-                    gr.HTML("</div>")
-                
-                with gr.Row(elem_classes="input-container"):
-                    msg_input = gr.Textbox(
-                        placeholder="Ask about potential oversights or upload files...",
-                        show_label=False,
-                        container=False,
-                        elem_classes="input-textbox",
-                        autofocus=True
-                    )
-                    send_btn = gr.Button(
-                        "Analyze",
-                        variant="primary",
-                        elem_classes="send-btn"
-                    )
-                
-                progress_text = gr.Textbox(
-                    label="Progress Status",
-                    visible=False,
-                    interactive=False,
-                    elem_classes="progress-text"
-                )
 
-                def show_loading(state: bool) -> dict:
-                    return {
-                        "value": "<div class='loading-spinner'>⏳</div>" if state else "<div class='loading-spinner' style='display: none;'>⏳</div>",
-                        "visible": state
-                    }
-
-                def show_typing(state: bool) -> dict:
-                    return {
-                        "value": f"<div class='typing-indicator{' active' if state else ''}'>Typing...</div>",
-                        "visible": state
-                    }
-
-                # Theme toggle handler
-                theme_button.click(
-                    fn=self.toggle_theme,
-                    inputs=[theme_state],
-                    outputs=[theme_state, theme_button]
-                )
-
-                # Sidebar toggle handler
-                tools_button.click(
-                    fn=self.toggle_sidebar,
-                    inputs=[sidebar_state],
-                    outputs=[sidebar_state]
+                # Results Panel
+                with gr.Column(scale=1):
+                    with gr.Group():
+                        gr.Markdown("**Clinical Summary**")
+                        final_summary = gr.Markdown(
+                            "Analysis results will appear here...",
+                            elem_classes=["summary-panel"]
+                        )
+                    
+                    with gr.Group():
+                        gr.Markdown("**Report Export**")
+                        download_output = gr.File(
+                            label="Download Full Analysis",
+                            visible=False,
+                            interactive=False
+                        )
+
+            # Input Section
+            with gr.Row():
+                file_upload = gr.File(
+                    file_types=[".pdf", ".csv", ".xls", ".xlsx"],
+                    file_count="multiple",
+                    label="Upload Patient Records",
+                    elem_classes=["upload-area"]
                 )
 
-                # Analysis handlers
-                send_btn.click(
-                    fn=show_loading,
-                    inputs=[gr.State(value=True)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=show_typing,
-                    inputs=[gr.State(value=True)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=self.analyze,
-                    inputs=[msg_input, chatbot, file_upload],
-                    outputs=[chatbot, download_output, final_summary, progress_text],
-                    show_progress="hidden"
-                ).then(
-                    fn=show_loading,
-                    inputs=[gr.State(value=False)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=show_typing,
-                    inputs=[gr.State(value=False)],
-                    outputs=[chatbot]
+            with gr.Row():
+                user_input = gr.Textbox(
+                    placeholder="Enter your clinical query or analysis request...",
+                    show_label=False,
+                    container=False,
+                    scale=7,
+                    autofocus=True
                 )
-                
-                msg_input.submit(
-                    fn=show_loading,
-                    inputs=[gr.State(value=True)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=show_typing,
-                    inputs=[gr.State(value=True)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=self.analyze,
-                    inputs=[msg_input, chatbot, file_upload],
-                    outputs=[chatbot, download_output, final_summary, progress_text],
-                    show_progress="hidden"
-                ).then(
-                    fn=show_loading,
-                    inputs=[gr.State(value=False)],
-                    outputs=[chatbot]
-                ).then(
-                    fn=show_typing,
-                    inputs=[gr.State(value=False)],
-                    outputs=[chatbot]
-                )
-                
-                app.load(
-                    fn=lambda: [
-                        [], None, "<div class='sidebar__tooltip' data-tip='View analysis results'>Analysis results will appear here...</div>", 
-                        "", None, {"visible": False}, "light", False, "🌙 Dark Mode"
-                    ],
-                    outputs=[chatbot, download_output, final_summary, msg_input, file_upload, progress_text, theme_state, sidebar_state, theme_button],
-                    queue=False
+                submit_btn = gr.Button(
+                    "Analyze",
+                    variant="primary",
+                    scale=1,
+                    min_width=120
                 )
 
-            except Exception as e:
-                logger.error(f"Interface creation failed: {e}")
-                self.cleanup_resources()
-                raise
-            return app
+            # Hidden progress tracker
+            progress_tracker = gr.Textbox(
+                label="Analysis Progress",
+                visible=False,
+                interactive=False
+            )
+
+            # Event handlers
+            submit_btn.click(
+                self.analyze_records,
+                inputs=[user_input, chatbot, file_upload],
+                outputs=[chatbot, download_output, final_summary, progress_tracker],
+                show_progress="hidden"
+            )
+            
+            user_input.submit(
+                self.analyze_records,
+                inputs=[user_input, chatbot, file_upload],
+                outputs=[chatbot, download_output, final_summary, progress_tracker],
+                show_progress="hidden"
+            )
+            
+            app.load(
+                lambda: [[], None, "", "", None, {"visible": False}],
+                outputs=[chatbot, download_output, final_summary, user_input, file_upload, progress_tracker],
+                queue=False
+            )
+
+        return app
 
 # ==================== APPLICATION ENTRY POINT ====================
 if __name__ == "__main__":
-    app = None
     try:
-        logger.info("Starting Clinical Oversight Assistant...")
-        app = ClinicalOversightApp()
-        interface = app.create_interface()
+        logger.info("Launching Clinical Oversight Assistant...")
+        clinical_app = ClinicalAgent()
+        interface = clinical_app.create_interface()
         
         interface.queue(
             api_open=False,
@@ -1092,12 +549,12 @@ if __name__ == "__main__":
             server_name="0.0.0.0",
             server_port=7860,
             show_error=True,
-            allowed_paths=[DIRECTORIES["reports"]],
+            allowed_paths=[str(DIRECTORIES["reports"])],
             share=False
         )
     except Exception as e:
         logger.error(f"Application failed to start: {e}")
         raise
     finally:
-        if app:
-            app.cleanup_resources()
+        if torch.distributed.is_initialized():
+            torch.distributed.destroy_process_group()