Видалено застарілі файли, включаючи модулі для логування, інтерфейси Gradio та приклади використання. Оновлено документацію для відображення нових змін у структурі проекту.

README.md

@@ -5,7 +5,7 @@ colorFrom: indigo
 colorTo: green
 sdk: gradio
 sdk_version: 5.36.2
-app_file: lmai_dx_interface_log.py
+app_file: run_mai_dx_fixed.py
 pinned: false
 short_description: MAI-DX Enhanced Research Platform
 ---

agent_conversation_logger.py

@@ -1,254 +0,0 @@
-#!/usr/bin/env python3
-"""
-Модуль для логування та управління діагностичними сесіями MAI-DX.
-
-Цей модуль забезпечує:
-- Створення та відстеження окремих діагностичних сесій.
-- Запис детальних повідомлень від кожного ШІ-агента.
-- Збереження повної інформації про сесію у форматі JSON.
-- Надання функцій для аналітики: перелік сесій, експорт у CSV та генерація звітів.
-"""
-import os
-import json
-import csv
-from datetime import datetime
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass, asdict, field
-import threading
-import uuid
-
-@dataclass
-class DiagnosisSession:
-    """
-    Датаклас для зберігання повної інформації про одну діагностичну сесію.
-    """
-    case_id: str
-    timestamp: str
-    case_name: str
-    patient_info: str
-    mode: str
-    budget: int
-    diagnosis: str = "N/A"
-    confidence: float = 0.0
-    cost: float = 0.0
-    iterations: int = 0
-    duration: float = 0.0
-    status: str = "In Progress"
-    reasoning: str = "N/A"
-    messages: List[Dict[str, Any]] = field(default_factory=list)
-
-class AgentConversationLogger:
-    """
-    Клас для управління логуванням діагностичних сесій.
-    Зберігає кожну сесію в окремому JSON-файлі для легкого доступу та аналізу.
-    """
-
-    def __init__(self, log_dir: str = "mai_dx_logs"):
-        """
-        Ініціалізує логгер, створюючи директорію для логів, якщо її не існує.
-
-        Args:
-            log_dir (str): Директорія для збереження файлів логів.
-        """
-        self.log_dir = log_dir
-        os.makedirs(self.log_dir, exist_ok=True)
-        # Використовуємо локальне сховище потоку для ізоляції сесій
-        self.thread_local = threading.local()
-        print(f"✅ Справжній AgentConversationLogger ініціалізовано. Логи зберігаються в '{self.log_dir}'.")
-
-    def start_conversation(self, case_name: str, patient_info: str, mode: str) -> str:
-        """
-        Розпочинає нову діагностичну сесію.
-
-        Args:
-            case_name (str): Назва клінічного випадку.
-            patient_info (str): Вхідна інформація про пацієнта.
-            mode (str): Режим діагностики.
-
-        Returns:
-            str: Унікальний ідентифікатор створеної сесії (case_id).
-        """
-        case_id = f"case_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:6]}"
-        session = DiagnosisSession(
-            case_id=case_id,
-            timestamp=datetime.now().isoformat(),
-            case_name=case_name,
-            patient_info=patient_info,
-            mode=mode,
-            budget=0 # Буде встановлено пізніше, якщо потрібно
-        )
-        self.thread_local.session = session
-        return case_id
-
-    def log_agent_message(self, agent_name: str, action: str, content: str, reasoning: str, confidence: float, cost: float, iteration: int):
-        """
-        Логує повідомлення від одного з ШІ-агентів.
-        """
-        if not hasattr(self.thread_local, 'session'):
-            print("⚠️ Попередження: Спроба логування без активної сесії.")
-            return
-
-        message = {
-            "timestamp": datetime.now().isoformat(),
-            "agent": agent_name,
-            "action": action,
-            "content": content,
-            "reasoning": reasoning,
-            "confidence": confidence,
-            "cost": cost,
-            "iteration": iteration,
-        }
-        self.thread_local.session.messages.append(message)
-
-    def end_conversation(self, final_diagnosis: str, confidence: float, cost: float, **kwargs) -> str:
-        """
-        Завершує сесію, оновлює фінальні дані та зберігає її у файл.
-
-        Returns:
-            str: Ідентифікатор збереженої сесії.
-        """
-        if not hasattr(self.thread_local, 'session'):
-            print("⚠️ Попередження: Спроба завершити неіснуючу сесію.")
-            return "no_active_session"
-
-        session = self.thread_local.session
-        
-        # Оновлення фінальних даних сесії
-        session.diagnosis = final_diagnosis
-        session.confidence = confidence
-        session.cost = cost
-        session.status = "✅ Успішно" if confidence >= 3.0 else "⚠️ Потребує перегляду"
-        session.reasoning = kwargs.get('reasoning', 'N/A')
-        session.iterations = kwargs.get('iterations', len(session.messages))
-        
-        start_time = datetime.fromisoformat(session.timestamp)
-        session.duration = (datetime.now() - start_time).total_seconds()
-
-        # Збереження сесії у файл
-        file_path = os.path.join(self.log_dir, f"{session.case_id}.json")
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(asdict(session), f, ensure_ascii=False, indent=4)
-
-        del self.thread_local.session # Очищення сесії для поточного потоку
-        return session.case_id
-
-    def list_conversations(self) -> List[Dict[str, Any]]:
-        """
-        Зчитує всі збережені сесії з директорії логів.
-
-        Returns:
-            List[Dict[str, Any]]: Список словників, де кожен словник - це одна сесія.
-        """
-        all_sessions = []
-        for filename in sorted(os.listdir(self.log_dir), reverse=True):
-            if filename.endswith(".json"):
-                try:
-                    with open(os.path.join(self.log_dir, filename), 'r', encoding='utf-8') as f:
-                        data = json.load(f)
-                        # Видаляємо детальні повідомлення для короткого списку
-                        data.pop('messages', None) 
-                        all_sessions.append(data)
-                except (json.JSONDecodeError, IOError) as e:
-                    print(f"Помилка читання файлу логу {filename}: {e}")
-        return all_sessions
-
-    def export_analytics_csv(self) -> str:
-        """
-        Експортує зведену аналітику по всіх сесіях у CSV файл.
-
-        Returns:
-            str: Назва створеного CSV файлу.
-        """
-        sessions = self.list_conversations()
-        if not sessions:
-            return "Немає даних для експорту."
-
-        filename = f"analytics_report_{datetime.now().strftime('%Y%m%d_%H%M')}.csv"
-        file_path = os.path.join(self.log_dir, filename)
-
-        # Визначаємо поля (колонки) на основі ключів першої сесії
-        fieldnames = sessions[0].keys()
-
-        with open(file_path, 'w', newline='', encoding='utf-8') as csvfile:
-            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            writer.writeheader()
-            writer.writerows(sessions)
-
-        return file_path
-
-    def export_conversation_report(self, case_id: str, format: str = 'html') -> str:
-        """
-        Створює детальний звіт для конкретного випадку.
-
-        Args:
-            case_id (str): Ідентифікатор сесії для звіту.
-            format (str): Формат звіту ('html' або 'json').
-
-        Returns:
-            str: Назва створеного файлу звіту.
-        """
-        file_path = os.path.join(self.log_dir, f"{case_id}.json")
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-        except FileNotFoundError:
-            return f"Помилка: Файл для випадку {case_id} не знайдено."
-
-        if format == 'json':
-            return file_path
-
-        # Генерація HTML-звіту
-        report_filename = f"report_{case_id}.html"
-        report_path = os.path.join(self.log_dir, report_filename)
-
-        html = f"""
-        <html>
-        <head>
-            <title>Звіт по випадку: {data['case_name']}</title>
-            <style>
-                body {{ font-family: sans-serif; line-height: 1.6; padding: 20px; }}
-                h1, h2 {{ color: #333; }}
-                table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
-                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
-                th {{ background-color: #f2f2f2; }}
-                .summary {{ background-color: #eef; padding: 15px; border-radius: 8px; }}
-            </style>
-        </head>
-        <body>
-            <h1>Клінічний звіт по випадку: {data['case_name']}</h1>
-            <p><strong>ID:</strong> {data['case_id']}</p>
-            <p><strong>Час:</strong> {data['timestamp']}</p>
-            
-            <div class="summary">
-                <h2>Підсумки діагностики</h2>
-                <p><strong>Фінальний діагноз:</strong> {data['diagnosis']}</p>
-                <p><strong>Впевненість:</strong> {data['confidence']}/5.0</p>
-                <p><strong>Вартість:</strong> ${data['cost']}</p>
-                <p><strong>Тривалість:</strong> {data['duration']:.2f} сек.</p>
-            </div>
-
-            <h2>Детальний лог взаємодії агентів</h2>
-            <table>
-                <tr>
-                    <th>Час</th><th>Агент</th><th>Дія</th><th>Результат/Контент</th>
-                </tr>
-        """
-        for msg in data.get('messages', []):
-            html += f"""
-                <tr>
-                    <td>{datetime.fromisoformat(msg['timestamp']).strftime('%H:%M:%S')}</td>
-                    <td>{msg['agent']}</td>
-                    <td>{msg['action']}</td>
-                    <td>{msg['content']}</td>
-                </tr>
-            """
-        html += """
-            </table>
-        </body>
-        </html>
-        """
-
-        with open(report_path, 'w', encoding='utf-8') as f:
-            f.write(html)
-
-        return report_path

enhanced_mai_dx_logger.py

@@ -0,0 +1,516 @@
+#!/usr/bin/env python3
+"""
+Покращений модуль для повного логування діагностичних сесій MAI-DX 
+з детальним захопленням розмов між агентами.
+"""
+import os
+import io
+import sys
+import json
+import time
+import uuid
+import re
+import logging
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Callable
+from dataclasses import dataclass, asdict, field
+from contextlib import contextmanager, redirect_stdout, redirect_stderr
+import threading
+from queue import Queue
+
+@dataclass
+class AgentMessage:
+    """Повідомлення від одного агента"""
+    timestamp: str
+    agent_name: str
+    message_type: str  # 'input', 'reasoning', 'output', 'decision'
+    content: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass 
+class AgentConversation:
+    """Повна розмова між агентами для одного раунду"""
+    round_number: int
+    start_time: str
+    end_time: Optional[str] = None
+    messages: List[AgentMessage] = field(default_factory=list)
+    decision: Optional[str] = None
+    tests_ordered: List[str] = field(default_factory=list)
+    questions_asked: List[str] = field(default_factory=list)
+    cost_incurred: float = 0.0
+
+@dataclass
+class DiagnosisSession:
+    """Повна діагностична сесія з усіма розмовами агентів"""
+    case_id: str
+    timestamp: str
+    case_name: str
+    patient_info: str
+    mode: str
+    budget: int = 0
+    diagnosis: str = "N/A"
+    confidence: float = 0.0
+    cost: float = 0.0
+    iterations: int = 0
+    duration: float = 0.0
+    status: str = "In Progress"
+    reasoning: str = "N/A"
+    conversations: List[AgentConversation] = field(default_factory=list)
+    raw_output: str = ""  # Повний сирий вивід
+
+class EnhancedOutputCapture:
+    """Клас для захоплення всіх видів виводу з різних джерел"""
+    def __init__(self):
+        self.captured_output = io.StringIO()
+        self.original_stdout = sys.stdout
+        self.original_stderr = sys.stderr
+        self.original_write = None
+        self.log_queue = Queue()
+        self.capture_thread = None
+        self.is_capturing = False
+        self.log_handler = None
+        
+    def start_capture(self):
+        """Розпочати захоплення виводу"""
+        self.is_capturing = True
+        sys.stdout = self
+        sys.stderr = self
+        
+        # Перехоплення логів
+        self._setup_logging_capture()
+        
+    def stop_capture(self):
+        """Зупинити захоплення виводу"""
+        self.is_capturing = False
+        sys.stdout = self.original_stdout
+        sys.stderr = self.original_stderr
+        
+        # Видаляємо log handler
+        if self.log_handler:
+            logging.root.removeHandler(self.log_handler)
+            
+        captured_text = self.captured_output.getvalue()
+        # Очищаємо ANSI escape коди
+        return self._strip_ansi_codes(captured_text)
+        
+    def write(self, text):
+        """Перехоплення всіх записів"""
+        if self.is_capturing:
+            self.captured_output.write(text)
+        self.original_stdout.write(text)  # Дублюємо на консоль
+        
+    def flush(self):
+        """Flush для сумісності"""
+        if hasattr(self.captured_output, 'flush'):
+            self.captured_output.flush()
+        self.original_stdout.flush()
+        
+    def _setup_logging_capture(self):
+        """Налаштування перехоплення логів"""
+        class QueueHandler(logging.Handler):
+            def __init__(self, queue):
+                super().__init__()
+                self.queue = queue
+                
+            def emit(self, record):
+                self.queue.put(self.format(record))
+                
+        # Додаємо handler до root logger
+        self.log_handler = QueueHandler(self.log_queue)
+        logging.root.addHandler(self.log_handler)
+        
+    @staticmethod
+    def _strip_ansi_codes(text):
+        """Видалити ANSI escape коди з тексту"""
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        return ansi_escape.sub('', text)
+
+class MAIDxConversationLogger:
+    """Покращений логгер для MAI-DX з повним захопленням розмов"""
+    
+    def __init__(self, log_dir: str = "mai_dx_logs"):
+        self.log_dir = log_dir
+        os.makedirs(self.log_dir, exist_ok=True)
+        self.sessions: Dict[str, DiagnosisSession] = {}
+        self.output_capture = EnhancedOutputCapture()
+        
+    def start_session(self, case_name: str, patient_info: str, mode: str, budget: int) -> str:
+        """Розпочати нову діагностичну сесію"""
+        case_id = f"case_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:6]}"
+        session = DiagnosisSession(
+            case_id=case_id,
+            timestamp=datetime.now().isoformat(),
+            case_name=case_name,
+            patient_info=patient_info,
+            mode=mode,
+            budget=budget
+        )
+        self.sessions[case_id] = session
+        return case_id
+        
+    def capture_orchestrator_output(self, case_id: str, orchestrator_func: Callable, *args, **kwargs):
+        """Захопити весь вивід від orchestrator.run()"""
+        if case_id not in self.sessions:
+            raise ValueError(f"Сесія {case_id} не існує")
+            
+        session = self.sessions[case_id]
+        
+        # Розпочинаємо захоплення
+        self.output_capture.start_capture()
+        
+        try:
+            # Виконуємо функцію orchestrator
+            result = orchestrator_func(*args, **kwargs)
+            
+            # Зупиняємо захоплення
+            captured_text = self.output_capture.stop_capture()
+            session.raw_output = captured_text
+            
+            # Парсимо захоплений текст
+            self._parse_captured_output(case_id, captured_text)
+            
+            return result
+            
+        except Exception as e:
+            # Завжди зупиняємо захоплення
+            self.output_capture.stop_capture()
+            raise e
+            
+    def _parse_captured_output(self, case_id: str, captured_text: str):
+        """Детальний парсинг захопленого тексту"""
+        session = self.sessions[case_id]
+        lines = captured_text.split('\n')
+        
+        current_round = None
+        current_agent = None
+        buffer = []
+        in_agent_output = False
+        round_number = 0
+        
+        for i, line in enumerate(lines):
+            # Пропускаємо порожні рядки та помилки Rich
+            if not line.strip() or "rich.errors.NotRenderableError" in line or "Exception in thread" in line:
+                continue
+                
+            # Початок нового раунду
+            if "Starting Diagnostic Loop" in line:
+                if current_round and buffer:
+                    # Зберігаємо попередній раунд
+                    self._save_buffered_conversation(session, current_round, buffer)
+                    buffer = []
+                    
+                # Витягуємо номер раунду
+                round_match = re.search(r'Starting Diagnostic Loop (\d+)/\d+', line)
+                if round_match:
+                    round_number = int(round_match.group(1))
+                else:
+                    round_number += 1
+                    
+                current_round = AgentConversation(
+                    round_number=round_number,
+                    start_time=datetime.now().isoformat()
+                )
+                session.conversations.append(current_round)
+                continue
+                
+            # Визначаємо початок виводу агента за рамкою
+            if "Agent Name" in line and ("╭" in line or "┌" in line):
+                # Витягуємо ім'я агента
+                agent_match = re.search(r'Agent Name (\w+\.?\s*\w+)', line)
+                if agent_match:
+                    if buffer and current_agent and current_round:
+                        # Зберігаємо повідомлення попереднього агента
+                        self._add_agent_message(current_round, current_agent, '\n'.join(buffer))
+                        buffer = []
+                    current_agent = agent_match.group(1).strip()
+                    in_agent_output = True
+                continue
+                
+            # Кінець виводу агента
+            if in_agent_output and ("╰" in line or "└" in line):
+                in_agent_output = False
+                if buffer and current_agent and current_round:
+                    self._add_agent_message(current_round, current_agent, '\n'.join(buffer))
+                    buffer = []
+                    current_agent = None
+                continue
+                
+            # Збираємо вміст всередині рамки
+            if in_agent_output and current_agent:
+                # Очищаємо лінію від символів рамки
+                clean_line = re.sub(r'^[│|]\s*', '', line)
+                clean_line = re.sub(r'\s*[│|]\s*', '', clean_line)
+                if clean_line.strip():
+                    buffer.append(clean_line.strip())
+                continue
+                
+            # Логи від INFO рівня
+            if " | INFO " in line:
+                # Парсимо INFO логи
+                info_match = re.search(r'mai_dx\.main:(\w+):.*? - (.+)', line)
+                if info_match and current_round:
+                    action = info_match.group(1)
+                    content = info_match.group(2)
+                    
+                    # Визначаємо агента з контексту
+                    agent_name = self._extract_agent_from_log(content)
+                    if agent_name:
+                        self._add_agent_message(
+                            current_round, 
+                            agent_name, 
+                            content,
+                            message_type="log"
+                        )
+                        
+                    # Спеціальні маркери
+                    if "Panel decision:" in content:
+                        decision_match = re.search(r'Panel decision: (\w+) -> (.+)', content)
+                        if decision_match:
+                            current_round.decision = f"{decision_match.group(1)}: {decision_match.group(2)}"
+                            
+                    if "Current cost:" in content:
+                        cost_match = re.search(r'Current cost: \$(\d+(?:\.\d+)?)', content)
+                        if cost_match:
+                            current_round.cost_incurred = float(cost_match.group(1))
+                            
+                    if "tests ordered:" in content.lower():
+                        # Можна додати парсинг тестів
+                        pass
+                        
+        # Зберігаємо останній буфер
+        if buffer and current_round and current_agent:
+            self._add_agent_message(current_round, current_agent, '\n'.join(buffer))
+            
+        # Завершуємо останній раунд
+        if current_round:
+            current_round.end_time = datetime.now().isoformat()
+            
+    def _extract_agent_from_log(self, log_content: str) -> Optional[str]:
+        """Витягти ім'я агента з лог повідомлення"""
+        agent_patterns = {
+            'Dr. Hypothesis': ['Dr. Hypothesis', 'differential diagnosis'],
+            'Dr. Test-Chooser': ['Dr. Test-Chooser', 'selecting optimal tests'],
+            'Dr. Challenger': ['Dr. Challenger', 'challenging assumptions'],
+            'Dr. Stewardship': ['Dr. Stewardship', 'cost-effectiveness'],
+            'Dr. Checklist': ['Dr. Checklist', 'quality control'],
+            'Consensus Coordinator': ['Consensus Coordinator', 'synthesizing panel'],
+            'Judge': ['Judge', 'evaluation'],
+            'Gatekeeper': ['Gatekeeper']
+        }
+        
+        for agent, patterns in agent_patterns.items():
+            for pattern in patterns:
+                if pattern in log_content:
+                    return agent
+        return None
+            
+    def _extract_agent_name(self, line: str) -> Optional[str]:
+        """Витягти ім'я агента з рядка"""
+        agents = [
+            "Dr. Hypothesis", "Dr. Test-Chooser", "Dr. Challenger",
+            "Dr. Stewardship", "Dr. Checklist", "Consensus Coordinator",
+            "Gatekeeper", "Judge"
+        ]
+        
+        for agent in agents:
+            if agent in line:
+                return agent
+        return None
+        
+    def _extract_round_number(self, line: str) -> int:
+        """Витягти номер раунду"""
+        import re
+        match = re.search(r'(\d+)', line)
+        return int(match.group(1)) if match else 0
+        
+    def _extract_tests(self, line: str) -> List[str]:
+        """Витягти список тестів"""
+        # Тут потрібна більш складна логіка залежно від формату
+        return []
+        
+    def _extract_questions(self, line: str) -> List[str]:
+        """Витягти список питань"""
+        # Тут потрібна більш складна логіка залежно від формату
+        return []
+        
+    def _extract_cost(self, line: str) -> Optional[float]:
+        """Витягти вартість"""
+        import re
+        match = re.search(r'\$?(\d+(?:\.\d+)?)', line)
+        return float(match.group(1)) if match else None
+        
+    def _add_agent_message(self, conversation: AgentConversation, agent_name: str, content: str, message_type: Optional[str] = None):
+        """Додати повідомлення агента до розмови"""
+        if not conversation or not content.strip():
+            return
+            
+        if not message_type:
+            message_type = self._determine_message_type(agent_name, content)
+        
+        message = AgentMessage(
+            timestamp=datetime.now().isoformat(),
+            agent_name=agent_name,
+            message_type=message_type,
+            content=content.strip(),
+            metadata={}
+        )
+        
+        conversation.messages.append(message)
+        
+    def _determine_message_type(self, agent_name: str, content: str) -> str:
+        """Визначити тип повідомлення"""
+        content_lower = content.lower()
+        
+        if "analyzing" in content_lower or "considering" in content_lower:
+            return "reasoning"
+        elif "recommend" in content_lower or "suggest" in content_lower:
+            return "decision"
+        elif "?" in content:
+            return "input"
+        else:
+            return "output"
+            
+    def _save_buffered_conversation(self, session: DiagnosisSession, conversation: AgentConversation, buffer: List[str]):
+        """Зберегти буферизовану розмову"""
+        if conversation and buffer:
+            conversation.end_time = datetime.now().isoformat()
+            # Можна додати додаткову обробку
+            
+    def end_session(self, case_id: str, **kwargs) -> str:
+        """Завершити сесію та зберегти всі дані"""
+        if case_id not in self.sessions:
+            return "no_active_session"
+            
+        session = self.sessions[case_id]
+        
+        # Оновлюємо фінальні дані
+        session.diagnosis = kwargs.get('final_diagnosis', session.diagnosis)
+        session.confidence = kwargs.get('confidence', session.confidence)
+        session.cost = kwargs.get('cost', session.cost)
+        session.reasoning = kwargs.get('reasoning', session.reasoning)
+        session.iterations = len(session.conversations)
+        session.status = "✅ Успішно" if session.confidence >= 3.0 else "⚠️ Потребує перегляду"
+        
+        start_time = datetime.fromisoformat(session.timestamp)
+        session.duration = (datetime.now() - start_time).total_seconds()
+        
+        # Зберігаємо у файл
+        self._save_session_to_file(session)
+        
+        del self.sessions[case_id]
+        return case_id
+        
+    def _save_session_to_file(self, session: DiagnosisSession):
+        """Зберегти сесію у JSON файл з повною структурою"""
+        file_path = os.path.join(self.log_dir, f"{session.case_id}.json")
+        
+        # Конвертуємо в словник з усіма вкладеними даними
+        session_dict = asdict(session)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(session_dict, f, ensure_ascii=False, indent=2)
+            
+        # Додатково зберігаємо сирий вивід
+        raw_output_path = os.path.join(self.log_dir, f"{session.case_id}_raw.txt")
+        with open(raw_output_path, 'w', encoding='utf-8') as f:
+            f.write(session.raw_output)
+            
+    def get_session_conversations(self, case_id: str) -> List[AgentConversation]:
+        """Отримати всі розмови для сесії"""
+        file_path = os.path.join(self.log_dir, f"{case_id}.json")
+        
+        if not os.path.exists(file_path):
+            # Спробувати з активних сесій
+            if case_id in self.sessions:
+                return self.sessions[case_id].conversations
+            return []
+            
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        # Реконструюємо об'єкти з JSON
+        conversations = []
+        for conv_data in data.get('conversations', []):
+            messages = [AgentMessage(**msg) for msg in conv_data.get('messages', [])]
+            conv = AgentConversation(
+                round_number=conv_data['round_number'],
+                start_time=conv_data['start_time'],
+                end_time=conv_data.get('end_time'),
+                messages=messages,
+                decision=conv_data.get('decision'),
+                tests_ordered=conv_data.get('tests_ordered', []),
+                questions_asked=conv_data.get('questions_asked', []),
+                cost_incurred=conv_data.get('cost_incurred', 0.0)
+            )
+            conversations.append(conv)
+            
+        return conversations
+        
+    def export_conversation_html(self, case_id: str) -> str:
+        """Експортувати розмови у читабельний HTML формат"""
+        conversations = self.get_session_conversations(case_id)
+        
+        html_content = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>MAI-DX Conversation Log - {case_id}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }}
+        .round {{ background: white; padding: 20px; margin: 20px 0; border-radius: 10px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }}
+        .agent-message {{ margin: 10px 0; padding: 10px; border-left: 4px solid #007bff; background: #f8f9fa; }}
+        .agent-name {{ font-weight: bold; color: #007bff; }}
+        .message-type {{ font-size: 0.9em; color: #666; }}
+        .decision {{ background: #d4edda; border-color: #28a745; }}
+        .tests {{ background: #fff3cd; border-color: #ffc107; }}
+        .cost {{ color: #dc3545; font-weight: bold; }}
+        .raw-output {{ background: #2d3748; color: #e2e8f0; padding: 15px; border-radius: 5px; font-family: 'Courier New', monospace; white-space: pre-wrap; }}
+    </style>
+</head>
+<body>
+    <h1>MAI-DX Diagnostic Session: {case_id}</h1>
+"""
+        
+        for conv in conversations:
+            html_content += f"""
+    <div class="round">
+        <h2>Round {conv.round_number}</h2>
+        <p><strong>Time:</strong> {conv.start_time} - {conv.end_time or 'In Progress'}</p>
+"""
+            
+            for msg in conv.messages:
+                css_class = "agent-message"
+                if msg.message_type == "decision":
+                    css_class += " decision"
+                    
+                html_content += f"""
+        <div class="{css_class}">
+            <div class="agent-name">{msg.agent_name}</div>
+            <div class="message-type">[{msg.message_type}]</div>
+            <div class="content">{msg.content}</div>
+        </div>
+"""
+            
+            if conv.decision:
+                html_content += f'<div class="decision"><strong>Decision:</strong> {conv.decision}</div>'
+                
+            if conv.tests_ordered:
+                html_content += f'<div class="tests"><strong>Tests:</strong> {", ".join(conv.tests_ordered)}</div>'
+                
+            if conv.cost_incurred > 0:
+                html_content += f'<div class="cost">Cost: ${conv.cost_incurred:.2f}</div>'
+                
+            html_content += "</div>"
+            
+        html_content += """
+</body>
+</html>
+"""
+        
+        # Зберігаємо HTML файл
+        html_path = os.path.join(self.log_dir, f"{case_id}_conversation.html")
+        with open(html_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+            
+        return html_path

lmai_dx_interface_log.py

@@ -1,601 +0,0 @@
-#!/usr/bin/env python3
-"""
-Виправлений MAI-DX Gradio Interface з сумісністю для нових версій Gradio
-"""
-import os
-import sys
-import json
-import time
-import pandas as pd
-import gradio as gr
-from datetime import datetime, timedelta
-from typing import Dict, List, Tuple, Optional
-from dataclasses import dataclass, asdict
-import warnings
-import threading
-import queue
-import io
-import re # Імпортуємо re для парсингу
-from contextlib import redirect_stdout, redirect_stderr
-
-# Налаштування середовища
-os.environ.update({
-    "SWARMS_VERBOSITY": "ERROR",
-    "RICH_TRACEBACK": "0", 
-    "SWARMS_SHOW_PANEL": "false",
-    "SWARMS_AUTO_PRINT": "false"
-})
-warnings.filterwarnings("ignore")
-
-from dotenv import load_dotenv
-load_dotenv()
-
-# Патч Rich formatter
-def patch_rich_formatter():
-    try:
-        import swarms.utils.formatter
-        def dummy_print_panel(*args, **kwargs):
-            pass
-        if hasattr(swarms.utils.formatter, 'Formatter'):
-            swarms.utils.formatter.Formatter._print_panel = dummy_print_panel
-        return True
-    except:
-        return False
-
-patch_rich_formatter()
-
-# Імпорт MAI-DX
-try:
-    from mai_dx import MaiDxOrchestrator
-    MAI_DX_AVAILABLE = True
-except ImportError as e:
-    MAI_DX_AVAILABLE = False
-    IMPORT_ERROR = str(e)
-
-# Перевірка доступності Plotly
-try:
-    import plotly.graph_objects as go
-    import plotly.express as px
-    PLOTLY_AVAILABLE = True
-except ImportError:
-    PLOTLY_AVAILABLE = False
-    print("⚠️ Plotly не встановлено, візуалізації будуть недоступні")
-
-# Імпорт логгера (створюємо заглушку якщо немає)
-try:
-    from agent_conversation_logger import AgentConversationLogger, DiagnosisSession
-    LOGGER_AVAILABLE = True
-except ImportError as e:
-    LOGGER_AVAILABLE = False
-    print(f"⚠️ Не вдалося завантажити логгер, буде використана заглушка: {e}")
-    
-    @dataclass
-    class DiagnosisSession:
-        case_id: str
-        timestamp: str
-        case_name: str
-        patient_info: str
-        mode: str
-        budget: int
-        diagnosis: str
-        confidence: float
-        cost: float
-        iterations: int
-        duration: float
-        status: str
-        reasoning: str
-    
-    class AgentConversationLogger:
-        def __init__(self, *args, **kwargs):
-            self.conversations = []
-        def start_conversation(self, *args):
-            return f"mock_{len(self.conversations)}"
-        def log_agent_message(self, *args, **kwargs):
-            pass
-        def end_conversation(self, *args, **kwargs):
-            return f"saved_{len(self.conversations)}"
-        def list_conversations(self):
-            return self.conversations
-        def export_conversation_report(self, case_id, format):
-            return f"report_{case_id}.{format}"
-        def export_analytics_csv(self):
-            return "analytics.csv"
-
-class RealTimeMetrics:
-    """Метрики в реальному часі"""
-    
-    def __init__(self):
-        self.reset()
-    
-    def reset(self):
-        self.start_time = time.time()
-        self.agents_activity = {
-            'Dr. Hypothesis': 0,
-            'Dr. Test-Chooser': 0, 
-            'Dr. Challenger': 0,
-            'Dr. Stewardship': 0,
-            'Dr. Checklist': 0,
-            'Consensus Coordinator': 0,
-            'Gatekeeper': 0,
-            'Judge': 0
-        }
-        self.cost_progression = []
-        self.confidence_progression = []
-        self.decision_timeline = []
-    
-    def update_agent_activity(self, agent_name: str):
-        if agent_name in self.agents_activity:
-            self.agents_activity[agent_name] += 1
-    
-    def add_cost_point(self, cost: float):
-        self.cost_progression.append({
-            'time': time.time() - self.start_time,
-            'cost': cost
-        })
-    
-    def add_confidence_point(self, confidence: float):
-        self.confidence_progression.append({
-            'time': time.time() - self.start_time,
-            'confidence': confidence
-        })
-
-class EnhancedMAIDXInterface:
-    """Покращений інтерфейс з сумісністю для Gradio"""
-    
-    def __init__(self):
-        self.sessions_history = []
-        self.conversation_logger = AgentConversationLogger("mai_dx_logs")
-        self.current_metrics = RealTimeMetrics()
-        
-        # Розширені тестові кейси (з виправленими очікуваними діагнозами)
-        self.sample_cases = {
-            "🫀 Кардіологічний (Гострий MI)": {
-                "info": """Пацієнт: 58-річний чоловік, менеджер, гіпертонія в анамнезі
-Скарги: Гострий роздираючий біль у грудях 3 години, іррадіація в ліву руку
-Огляд: Блідий, пітливий, АТ 160/90, ЧСС 95
-ЕКГ: ST-підйоми у відведеннях II, III, aVF (нижня стінка)
-Тропонін I: 8.5 нг/мл (норма <0.04)
-Анамнез: Куріння 30 років, дислипідемія, сімейний анамнез ІХС""",
-                "expected": "Acute inferior wall myocardial infarction (STEMI)"
-            },
-            
-            "🧠 Неврологічний (Гострий інсульт)": {
-                "info": """Пацієнтка: 67-річна жінка, раптові неврологічні симптоми
-Презентація: Раптова слабкість правої сторони 2 години тому
-Огляд: Свідома, дезорієнтована у часі, правостороннє опущення обличчя
-Неврологія: Правостороння геміплегія, афазія, девіація очей вліво
-КТ голови: Гострого крововиливу немає, рання ішемія у лівій МСА
-NIHSS: 15 балів""",
-                "expected": "Acute ischemic stroke in the left middle cerebral artery territory"
-            },
-            
-            "🦠 Інфекційний (Сепсис)": {
-                "info": """Пацієнт: 45-річний чоловік з прогресуючою лихоманкою
-Скарги: Висока температура 39.5°C, озноб, загальна слабкість 3 дні
-Огляд: Гарячий, тахікардія 120/хв, гіпотензія 85/50
-Лабораторно: Лейкоцити 18000, С-реактивний білок 180, прокальцитонін 5.2
-Посів крові: Pending, lactate 4.2 ммоль/л
-Анамнез: Нещодавна стоматологічна процедура""",
-                "expected": "Sepsis with a possible odontogenic source"
-            }
-        }
-    
-    def diagnose_with_enhanced_tracking(
-        self,
-        case_name: str,
-        patient_info: str, 
-        mode: str,
-        budget: int,
-        max_iterations: int,
-        model_name: str,
-        expected_diagnosis: str = "",
-        enable_logging: bool = True,
-        progress=gr.Progress()
-    ) -> Tuple[str, str, str, Optional[object], Optional[object], str]:
-        """Діагностика з покращеним відстеженням - ВИПРАВЛЕНА ВЕРСІЯ"""
-        
-        if not MAI_DX_AVAILABLE:
-            return self._format_error(f"❌ MAI-DX недоступний: {IMPORT_ERROR}")
-        
-        if not patient_info.strip():
-            return self._format_error("❌ Введіть інформацію про пацієнта")
-        
-        self.current_metrics.reset()
-        conversation_log = ""
-        case_id = None
-        
-        try:
-            progress(0.1, desc="🚀 Ініціалізація системи...")
-            
-            if enable_logging:
-                case_id = self.conversation_logger.start_conversation(
-                    case_name or f"Case_{datetime.now().strftime('%H%M%S')}", 
-                    patient_info, 
-                    mode
-                )
-                conversation_log += f"📝 Розпочато логування: {case_id}\n\n"
-            
-            progress(0.2, desc="🤖 Створення AI-панелі лікарів...")
-            
-            orchestrator = MaiDxOrchestrator(
-                model_name=model_name,
-                max_iterations=max_iterations,
-                initial_budget=budget,
-                mode=mode if mode != "ensemble" else "budgeted"
-            )
-            
-            progress(0.3, desc="🔍 Запуск діагностичного процесу...")
-            start_time = time.time()
-            
-            # Запуск діагностики з перехопленням виводу
-            with io.StringIO() as captured_output, redirect_stdout(captured_output):
-                try:
-                    result = orchestrator.run(
-                        initial_case_info=patient_info,
-                        full_case_details=patient_info,
-                        ground_truth_diagnosis=expected_diagnosis or "Unknown"
-                    )
-                except Exception as e:
-                     # Спроба обробити помилку і отримати частковий результат
-                    print(f"\nПОМИЛКА ПІД ЧАС ВИКОНАННЯ: {e}")
-                    result = getattr(orchestrator, 'result', None)
-                    if not result:
-                        raise e from e
-                finally:
-                    captured_text = captured_output.getvalue()
-
-            duration = time.time() - start_time
-            progress(0.9, desc="📊 Обробка результатів...")
-            
-            if enable_logging and captured_text:
-                conversation_log += "🤖 Захоплені логи агентів:\n" + "=" * 60 + "\n"
-                conversation_log += captured_text + "\n" + "=" * 60 + "\n\n"
-                # ВИПРАВЛЕНО: Парсинг логів для метрик та повідомлень
-                self._parse_and_log_agent_activity(captured_text)
-            
-            if enable_logging:
-                # Логування фінальної оцінки
-                self.conversation_logger.log_agent_message(
-                    agent_name="Judge",
-                    action="final_evaluation", 
-                    content=result.final_diagnosis,
-                    reasoning=getattr(result, 'accuracy_reasoning', 'Фінальна оцінка'),
-                    confidence=result.accuracy_score / 5.0, # Нормалізація до 0-1
-                    cost=result.total_cost,
-                    iteration=getattr(result, 'iterations', max_iterations)
-                )
-                
-                # ВИПРАВЛЕНО: Завершення сесії з усіма даними
-                saved_case_id = self.conversation_logger.end_conversation(
-                    final_diagnosis=result.final_diagnosis,
-                    confidence=result.accuracy_score,
-                    cost=result.total_cost,
-                    budget=budget,
-                    reasoning=getattr(result, 'accuracy_reasoning', 'N/A'),
-                    iterations=getattr(result, 'iterations', max_iterations)
-                )
-                conversation_log += f"💾 Сесію збережено як: {saved_case_id}\n"
-            
-            # Створення об'єкту сесії для відображення
-            session = DiagnosisSession(
-                case_id=case_id,
-                timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                case_name=case_name or f"Case_{len(self.sessions_history) + 1}",
-                patient_info=patient_info[:200] + "..." if len(patient_info) > 200 else patient_info,
-                mode=mode,
-                budget=budget,
-                diagnosis=result.final_diagnosis,
-                confidence=result.accuracy_score,
-                cost=result.total_cost,
-                iterations=getattr(result, 'iterations', max_iterations),
-                duration=duration,
-                status="✅ Успішно" if result.accuracy_score >= 3.0 else "⚠️ Потребує перегляду",
-                reasoning=getattr(result, 'accuracy_reasoning', 'Недоступно')[:300] + "..."
-            )
-            self.sessions_history.append(session)
-            
-            progress(1.0, desc="✅ Готово!")
-            
-            metrics_plot = self._create_metrics_visualization_safe()
-            agent_plot = self._create_agent_activity_chart_safe()
-            
-            return (
-                self._format_main_result(session, result),
-                self._format_detailed_analysis(session, result), 
-                self._generate_enhanced_recommendations(result, expected_diagnosis),
-                metrics_plot,
-                agent_plot,
-                conversation_log
-            )
-            
-        except Exception as e:
-            error_msg = f"❌ Помилка діагностики: {str(e)}"
-            if case_id:
-                error_msg += f"\n🗂️ Case ID: {case_id}"
-            return self._format_error(error_msg)
-    
-    def _create_metrics_visualization_safe(self):
-        try:
-            if not PLOTLY_AVAILABLE: return None
-            fig = go.Figure()
-            if not self.current_metrics.cost_progression:
-                return None # Немає даних - не показуємо графік
-            
-            times = [p['time'] for p in self.current_metrics.cost_progression]
-            costs = [p['cost'] for p in self.current_metrics.cost_progression]
-            
-            fig.add_trace(go.Scatter(x=times, y=costs, mode='lines+markers', name='Вартість', line=dict(color='#1f77b4', width=3)))
-            fig.update_layout(title='📈 Прогресія вартості діагностики', xaxis_title='Час (секунди)', yaxis_title='Вартість ($)', template='plotly_white', height=400)
-            return fig
-        except Exception as e:
-            print(f"Помилка візуалізації метрик: {e}")
-            return None
-    
-    def _create_agent_activity_chart_safe(self):
-        try:
-            if not PLOTLY_AVAILABLE: return None
-            
-            activity_data = {k: v for k, v in self.current_metrics.agents_activity.items() if v > 0}
-            if not activity_data: return None
-
-            agents = list(activity_data.keys())
-            activities = list(activity_data.values())
-            
-            colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57', '#FF9FF3', '#54A0FF', '#5F27CD']
-            
-            fig = go.Figure(data=[go.Bar(x=agents, y=activities, marker_color=colors, text=activities, textposition='auto')])
-            fig.update_layout(title='🤖 Активність ШІ-агентів', xaxis_title='Агенти', yaxis_title='Кількість взаємодій', template='plotly_white', height=400, showlegend=False)
-            fig.update_xaxes(tickangle=-45)
-            return fig
-        except Exception as e:
-            print(f"Помилка графіку агентів: {e}")
-            return None
-    
-    def _parse_and_log_agent_activity(self, captured_text: str):
-        """
-        Парсить перехоплений текстовий лог для оновлення метрик та логування повідомлень.
-        """
-        lines = captured_text.split('\n')
-        
-        agent_keywords = {
-            "Dr. Hypothesis": "Dr. Hypothesis", "Dr. Test-Chooser": "Dr. Test-Chooser",
-            "Dr. Challenger": "Dr. Challenger", "Dr. Stewardship": "Dr. Stewardship",
-            "Dr. Checklist": "Dr. Checklist", "Consensus Coordinator": "Consensus Coordinator"
-        }
-
-        for line in lines:
-            line = line.strip()
-            if not line: continue
-
-            # 1. Логування активності агентів
-            for keyword, agent_name in agent_keywords.items():
-                if keyword in line and "analyzing" in line:
-                    self.current_metrics.update_agent_activity(agent_name)
-                    self.conversation_logger.log_agent_message(
-                        agent_name=agent_name, action="analysis_start", content=line,
-                        reasoning="Parsed from orchestrator output", confidence=0.0, cost=0.0, iteration=0
-                    )
-                    break
-            
-            # 2. Логування рішень панелі
-            if "Panel decision:" in line:
-                self.current_metrics.update_agent_activity("Consensus Coordinator")
-                self.conversation_logger.log_agent_message(
-                    agent_name="Consensus Coordinator", action="panel_decision", content=line.split("Panel decision:")[-1].strip(),
-                    reasoning="Parsed from orchestrator output", confidence=0.0, cost=0.0, iteration=0
-                )
-
-            # 3. Парсинг вартості
-            cost_match = re.search(r'Current cost: \$(\d+(?:\.\d+)?)', line)
-            if cost_match:
-                current_cost = float(cost_match.group(1))
-                self.current_metrics.add_cost_point(current_cost)
-    
-    def _format_main_result(self, session, result):
-        """Форматування основного результату"""
-        confidence_emoji = "🎯" if session.confidence >= 4.0 else "👍" if session.confidence >= 3.0 else "⚠️"
-        efficiency = ((session.budget - session.cost) / session.budget * 100) if session.budget > 0 else 0
-        
-        return f"""
-## 🏥 Результати MAI-DX Діагностики
-### 📋 Основна інформація
-- **🗂️ Випадок**: {session.case_name}
-- **⏰ Час**: {session.timestamp}  
-- **🔧 Режим**: {session.mode}
-### {confidence_emoji} Діагностичний висновок
-**{session.diagnosis}**
-### 📊 Показники якості
-- **Точність**: {session.confidence:.1f}/5.0 ⭐
-- **Статус**: {session.status}
-- **Ітерації**: {session.iterations}
-### 💰 Економічні показники  
-- **Витрачено**: ${session.cost:,.2f}
-- **Бюджет**: ${session.budget:,}
-- **Ефективність**: {efficiency:.1f}% бюджету збережено
-- **Швидкість**: {session.duration:.1f} сек
-### 🎖️ Загальна оцінка
-{self._get_overall_rating(session)}
-        """
-    
-    def _get_overall_rating(self, session):
-        """Загальна оцінка ефективності"""
-        efficiency = ((session.budget - session.cost) / session.budget * 100) if session.budget > 0 else 0
-        if session.confidence >= 4.0 and efficiency >= 50: return "🏆 **ВІДМІННО**"
-        if session.confidence >= 3.0 and efficiency >= 20: return "🥈 **ДОБРЕ**"
-        if session.confidence >= 2.0: return "🥉 **ЗАДОВІЛЬНО**"
-        return "❌ **ПОТРЕБУЄ ПЕРЕГЛЯДУ**"
-    
-    def _format_detailed_analysis(self, session, result):
-        """Детальний аналіз"""
-        return f"""
-## 🔬 Детальний клінічний аналіз
-### 💭 Медичне обґрунтування
-{session.reasoning}
-### 📈 Аналіз ефективності
-- **💸 Економічна ефективність**: {((session.budget - session.cost) / session.budget * 100) if session.budget > 0 else 0:.1f}%
-- **🎯 Клінічна точність**: {(session.confidence / 5.0 * 100):.1f}%
-### 🤖 Процес прийняття рішень
-Система використала **{session.iterations} ітерацій** для консенсусу між **8 ШІ-агентами**.
-        """
-    
-    def _generate_enhanced_recommendations(self, result, expected_diagnosis):
-        """Покращені рекомендації"""
-        comparison = ""
-        if expected_diagnosis:
-            is_match = expected_diagnosis.lower() in result.final_diagnosis.lower() or \
-                       result.final_diagnosis.lower() in expected_diagnosis.lower()
-            comparison = f"""
-### 🎯 Порівняння з очікуваним
-**Очікувався**: {expected_diagnosis}
-**Отримано**: {result.final_diagnosis}
-**Збіг**: {'✅ Так' if is_match else '❌ Ні'}
-            """
-        return f"""
-## 💡 Клінічні рекомендації
-### 🏥 Негайні дії
-- 🔍 Верифікація діагнозу з лікарем
-- 📋 Розгляд додаткових досліджень
-### 🔬 Дослідницький потенціал  
-- 📊 Аналіз логів для вивчення роботи агентів
-- 📈 Валідація на додаткових випадках
-{comparison}
-### ⚠️ Важливе застереження
-🔴 **Цей діагноз згенеровано ШІ і НЕ замінює професійну медичну консультацію.**
-        """
-    
-    def _format_error(self, error_msg):
-        return (error_msg, "", "", None, None, "")
-    
-    def load_sample_case(self, sample_key):
-        if sample_key and sample_key in self.sample_cases:
-            case_data = self.sample_cases[sample_key]
-            return case_data["info"], sample_key, case_data["expected"]
-        return "", "", ""
-    
-    def get_enhanced_analytics(self):
-        try:
-            conversations = self.conversation_logger.list_conversations()
-            if not conversations:
-                return pd.DataFrame(), "📊 Немає даних для аналізу", []
-            
-            df = pd.DataFrame(conversations)
-            df = df.reindex(columns=['case_id', 'timestamp', 'case_name', 'mode', 'diagnosis', 'confidence', 'cost', 'budget', 'duration', 'status'])
-            
-            total_cases = len(df)
-            avg_accuracy = df['confidence'].mean()
-            avg_cost = df['cost'].mean()
-            
-            summary = f"""
-### 🎯 Загальна статистика
-- **Всього випадків**: {total_cases}
-- **Середня точність**: {avg_accuracy:.2f}/5.0 ⭐
-- **Середня вартість**: ${avg_cost:,.2f}
-            """
-            
-            case_choices = [(f"{row['case_name']} ({row.get('case_id', 'N/A')})", row.get('case_id')) for _, row in df.iterrows()]
-            return df, summary, gr.Dropdown(choices=case_choices)
-        except Exception as e:
-            return pd.DataFrame(), f"❌ Помилка аналітики: {e}", []
-
-def create_enhanced_gradio_interface():
-    interface = EnhancedMAIDXInterface()
-    custom_css = """.gradio-container {font-family: 'Inter', sans-serif;} .main-header {background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 2rem; border-radius: 15px; margin-bottom: 2rem; text-align: center;} .conversation-log {font-family: 'Fira Code', monospace; background: #2d3748; color: #e2e8f0; border-radius: 8px; padding: 1rem; max-height: 500px; overflow-y: auto; white-space: pre-wrap;}"""
-    
-    with gr.Blocks(title="🏥 MAI-DX Enhanced Research Platform", theme=gr.themes.Soft(primary_hue="blue"), css=custom_css) as demo:
-        gr.HTML("""<div class="main-header"><h1>🏥 MAI-DX Enhanced Research Platform</h1><p>🤖 Дослідницька платформа для ШІ-діагностики з детальним логуванням</p></div>""")
-        
-        with gr.Tabs():
-            with gr.Tab("🩺 Діагностика", elem_id="diagnosis-tab"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 📝 Клінічний випадок")
-                        case_name = gr.Textbox(label="🏷️ Назва випадку", placeholder="Наприклад: Кардіологічний випадок №1")
-                        sample_selector = gr.Dropdown(choices=list(interface.sample_cases.keys()), label="🎯 Готові тестові випадки", interactive=True)
-                        patient_info = gr.Textbox(label="👤 Інформація про пацієнта", lines=10, placeholder="Введіть опис клінічного випадку...")
-                        expected_diagnosis = gr.Textbox(label="🎯 Очікуваний діагноз (для порівняння)", lines=2)
-                    
-                    with gr.Column(scale=1):
-                        gr.Markdown("### ⚙️ Налаштування")
-                        mode = gr.Radio(choices=["instant", "question_only", "budgeted", "no_budget", "ensemble"], label="🔧 Режим", value="budgeted", interactive=True)
-                        budget = gr.Slider(minimum=500, maximum=10000, step=500, value=3000, label="💵 Бюджет ($)", interactive=True)
-                        max_iterations = gr.Slider(minimum=1, maximum=15, step=1, value=8, label="🔄 Макс. ітерацій", interactive=True)
-                        model_name = gr.Dropdown(choices=["gemini/gemini-1.5-flash", "gpt-4", "gpt-4-turbo"], label="🤖 LLM Модель", value="gemini/gemini-1.5-flash", interactive=True)
-                        enable_logging = gr.Checkbox(label="📝 Детальне логування", value=True, interactive=True)
-                        diagnose_btn = gr.Button("🚀 Запустити діагностику", variant="primary", size="lg")
-                
-                sample_selector.change(interface.load_sample_case, inputs=[sample_selector], outputs=[patient_info, case_name, expected_diagnosis])
-                
-                gr.Markdown("--- \n ## 📊 Результати діагностики")
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        main_result = gr.Markdown(label="🎯 Основний результат")
-                        detailed_analysis = gr.Markdown(label="🔬 Детальний аналіз")
-                    with gr.Column(scale=1):
-                        recommendations = gr.Markdown(label="💡 Рекомендації")
-                
-                with gr.Row():
-                    metrics_plot = gr.Plot(label="📈 Метрики діагностики")
-                    agent_activity_plot = gr.Plot(label="🤖 Активність агентів")
-                
-                conversation_logs = gr.Textbox(label="💬 Логи взаємодії ШІ-агентів", lines=12, elem_classes=["conversation-log"], interactive=False, show_copy_button=True)
-                
-                diagnose_btn.click(interface.diagnose_with_enhanced_tracking, 
-                                   inputs=[case_name, patient_info, mode, budget, max_iterations, model_name, expected_diagnosis, enable_logging],
-                                   outputs=[main_result, detailed_analysis, recommendations, metrics_plot, agent_activity_plot, conversation_logs])
-            
-            with gr.Tab("📊 Аналітика", elem_id="analytics-tab"):
-                gr.Markdown("### 🔍 Аналіз збережених діагностичних сесій")
-                with gr.Row():
-                    refresh_analytics_btn = gr.Button("🔄 Оновити")
-                    export_data_btn = gr.Button("📤 Експортувати CSV")
-                analytics_table = gr.Dataframe(label="📋 Історія сесій", interactive=False, wrap=True)
-                analytics_summary = gr.Markdown(label="📊 Статистичний звіт")
-                
-                gr.Markdown("### 🔬 Детальний звіт по випадку")
-                with gr.Row():
-                    case_selector = gr.Dropdown(label="🗂️ Оберіть випадок", choices=[], interactive=True)
-                    analyze_case_btn = gr.Button("📋 Створити звіт (HTML)")
-                analysis_status = gr.Markdown()
-                
-                def refresh_analytics():
-                    df, summary, dd = interface.get_enhanced_analytics()
-                    return df, summary, dd
-                
-                refresh_analytics_btn.click(refresh_analytics, outputs=[analytics_table, analytics_summary, case_selector])
-                export_data_btn.click(lambda: interface.conversation_logger.export_analytics_csv(), outputs=[analysis_status])
-                analyze_case_btn.click(lambda case_id: f"✅ Звіт створено: {interface.conversation_logger.export_conversation_report(case_id, 'html')}" if case_id else "⚠️ Оберіть випадок", inputs=[case_selector], outputs=[analysis_status])
-                demo.load(refresh_analytics, outputs=[analytics_table, analytics_summary, case_selector])
-            
-            with gr.Tab("📚 Документація", elem_id="docs-tab"):
-                gr.Markdown(f"""
-### 🔧 Статус системи
-- **MAI-DX доступність**: {'✅' if MAI_DX_AVAILABLE else '❌'}
-- **Logger доступність**: {'✅' if LOGGER_AVAILABLE else '⚠️ Заглушка'}
-- **Plotly візуалізації**: {'✅' if PLOTLY_AVAILABLE else '❌'}
-- **Gradio версія**: {gr.__version__}
-{'**Помилка MAI-DX**: ' + IMPORT_ERROR if not MAI_DX_AVAILABLE else ''}
-### 📖 Короткий гайд
-1. Оберіть готовий випадок або введіть свій.
-2. Налаштуйте режим, бюджет та модель.
-3. Натис��іть "Запустити діагностику".
-4. Аналізуйте результати та логи взаємодії агентів.
-5. Переходьте на вкладку "Аналітика" для перегляду історії.
-                """)
-    
-    return demo
-
-if __name__ == "__main__":
-    print("🚀 Запуск виправленого MAI-DX Enhanced Research Platform...")
-    print(f"🤖 MAI-DX доступність: {'✅' if MAI_DX_AVAILABLE else '❌'}")
-    print(f"📊 Plotly візуалізації: {'✅' if PLOTLY_AVAILABLE else '❌'}")
-    print(f"📝 Logger: {'✅' if LOGGER_AVAILABLE else '⚠️ заглушка'}")
-    print("🔍 Логи зберігаються у: mai_dx_logs/")
-    
-    demo = create_enhanced_gradio_interface()
-    
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        debug=False
-    )

mai_dx_interface.py

@@ -1,855 +0,0 @@
-#!/usr/bin/env python3
-"""
-MAI-DX Gradio Research Interface
-Зручний веб-інтерфейс для дослідження медичної діагностики з ШІ
-"""
-import os
-import sys
-import json
-import time
-import pandas as pd
-import gradio as gr
-from datetime import datetime
-from typing import Dict, List, Tuple, Optional
-from dataclasses import dataclass, asdict
-import warnings
-
-# Налаштування для запобігання помилок
-os.environ["SWARMS_VERBOSITY"] = "ERROR"
-os.environ["RICH_TRACEBACK"] = "0"
-os.environ["SWARMS_SHOW_PANEL"] = "false"
-os.environ["SWARMS_AUTO_PRINT"] = "false"
-warnings.filterwarnings("ignore")
-
-# Завантаження змінних середовища
-from dotenv import load_dotenv
-load_dotenv()
-
-# Патч Rich formatter
-def patch_rich_formatter():
-    try:
-        import swarms.utils.formatter
-        def dummy_print_panel(*args, **kwargs):
-            pass
-        if hasattr(swarms.utils.formatter, 'Formatter'):
-            swarms.utils.formatter.Formatter._print_panel = dummy_print_panel
-        return True
-    except:
-        return False
-
-patch_rich_formatter()
-
-# Імпорт MAI-DX
-try:
-    from mai_dx import MaiDxOrchestrator
-    MAI_DX_AVAILABLE = True
-except ImportError as e:
-    MAI_DX_AVAILABLE = False
-    IMPORT_ERROR = str(e)
-
-@dataclass
-class DiagnosisSession:
-    """Структура для зберігання сесії діагностики"""
-    timestamp: str
-    case_name: str
-    patient_info: str
-    mode: str
-    budget: int
-    diagnosis: str
-    confidence: float
-    cost: float
-    iterations: int
-    duration: float
-    status: str
-    reasoning: str = ""
-
-class MAIDXGradioInterface:
-    """Gradio інтерфейс для MAI-DX"""
-    
-    def __init__(self):
-        self.sessions_history = []
-        self.current_session = None
-        
-        # Перевірка доступності MAI-DX
-        if not MAI_DX_AVAILABLE:
-            print(f"❌ MAI-DX не доступний: {IMPORT_ERROR}")
-            print("📋 Інструкції установки:")
-            print("   pip install mai-dx python-dotenv")
-            print("   Створіть .env файл з API ключами")
-        
-        # Предвизначені тестові кейси
-        self.sample_cases = {
-            "Кардіологічний (Інфаркт)": """
-Пацієнт: 58-річний чоловік, менеджер
-Скарги: Гострий біль у грудях протягом 3 годин
-
-Анамнез:
-- Біль почався під час підйому по сходах
-- Сильний, здавлюючий, іррадіює в ліву руку та щелепу
-- Супроводжується потовиділенням, нудотою, задишкою
-- Не зменшується у спокої
-
-Фактори ризику:
-- Цукровий діабет 2 типу
-- Артеріальна гіпертензія
-- Куріння 2 пачки на день протягом 30 років
-- Сімейний анамнез: батько помер від ІМ у 52 роки
-
-Огляд:
-- Дискомфорт, потовиділення
-- АТ 180/110, ЧСС 105, ЧД 24
-- Серце: S4 галоп, шумів немає
-- Легені: ясні з обох сторін
-
-ЕКГ: ST-підйоми у відведеннях II, III, aVF
-Тропонін I: 8.5 нг/мл (норма <0.04)
-            """,
-            
-            "Неврологічний (Інсульт)": """
-Пацієнтка: 67-річна жінка з раптовими неврологічними симптомами
-
-Презентація:
-- Раптова слабкість правої сторони 2 години тому
-- Утруднення мови (невиразна мова)
-- Опущення правої сторони обличчя
-- Без втрати свідомості
-
-Анамнез:
-- Фібриляція передсердь (не приймає антикоагулянти)
-- Артеріальна гіпертензія
-- Попередня ТІА 6 місяців тому
-
-Огляд:
-- У свідомості, але плутається
-- Правостороннє опущення обличчя
-- Дрейф правої руки
-- Дизартрія
-- NIHSS балів: 8
-
-КТ голови: Гострого крововиливу немає
-Час від початку: 2 години 15 хвилин
-            """,
-            
-            "Педіатричний (Отит)": """
-Пацієнт: 3-річний хлопчик, привели батьки через лихоманку
-
-Анамнез:
-- Лихоманка до 39.5°C протягом 2 днів
-- Зменшення апетиту та активності
-- Тягне за праве вухо
-- Плаче більше звичайного, особли��о лежачи
-- Без кашлю, нежиті або блювання
-
-Анамнез життя:
-- Доношена вагітність, нормальний розвиток
-- Щеплення за календарем
-- Алергії невідомі
-
-Огляд:
-- Температура: 39.2°C, ЧСС: 130, ЧД: 28
-- Загалом дратівливий, але заспокоюється
-- ЛОР: права барабанна перетинка еритематозна і випнута
-- Шия: м'яка, лімфаденопатії немає
-- Груди: ясні з обох сторін
-- Живіт: м'який, безболісний
-            """,
-            
-            "Ендокринологічний (Гіпертиреоз)": """
-Пацієнтка: 45-річна жінка з прогресуючою втомою
-
-Скарги: "Постійно втомлююся і худну, хоча їм"
-
-Анамнез захворювання:
-- 6-місячна історія прогресуючої втоми
-- Ненавмисне схуднення на 7 кг
-- Непереносимість спеки та надмірне потовиділення
-- Серцебиття та тривожність
-- Порушення сну
-- Тремор рук
-
-Огляд систем:
-- Часті випорожнення (3-4 рази на день)
-- Випадіння волосся
-- Порушення менструального циклу
-
-Огляд:
-- АТ 150/85, ЧСС 110, ЧД 16, Т 37.1°C
-- Худорлява, тривожна жінка
-- Очі: легкий екзофтальм, симптом запізнення повік
-- Щитовидна залоза: дифузно збільшена
-- Серце: тахікардія, шумів немає
-- Тремор витягнутих рук
-- Шкіра: тепла та волога
-            """
-        }
-
-    def check_api_keys(self) -> Tuple[str, str]:
-        """Перевірка наявності API ключів"""
-        required_keys = ["OPENAI_API_KEY", "GEMINI_API_KEY", "ANTHROPIC_API_KEY"]
-        missing_keys = []
-        available_keys = []
-        
-        for key in required_keys:
-            if os.getenv(key):
-                available_keys.append(key)
-            else:
-                missing_keys.append(key)
-        
-        if available_keys:
-            status = f"✅ Доступні ключі: {', '.join(available_keys)}"
-            color = "green"
-        else:
-            status = f"❌ Відсутні всі API ключі: {', '.join(missing_keys)}"
-            color = "red"
-            
-        if missing_keys:
-            status += f"\n⚠️ Відсутні: {', '.join(missing_keys)}"
-            
-        return status, color
-
-    def diagnose_case(
-        self,
-        case_name: str,
-        patient_info: str,
-        mode: str,
-        budget: int,
-        max_iterations: int,
-        model_name: str,
-        expected_diagnosis: str = "",
-        progress=gr.Progress()
-    ) -> Tuple[str, str, str, pd.DataFrame]:
-        """Основна функція діагностики"""
-        
-        if not MAI_DX_AVAILABLE:
-            return (
-                f"❌ MAI-DX не доступний: {IMPORT_ERROR}",
-                "",
-                "",
-                pd.DataFrame()
-            )
-        
-        if not patient_info.strip():
-            return (
-                "❌ Будь ласка, введіть інформацію про пацієнта",
-                "",
-                "",
-                pd.DataFrame()
-            )
-        
-        # Початок діагностики
-        progress(0.1, desc="Ініціалізація MAI-DX...")
-        
-        start_time = time.time()
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        try:
-            # Створення оркестратора
-            progress(0.2, desc="Створення діагностичного оркестратора...")
-            
-            orchestrator = MaiDxOrchestrator(
-                model_name=model_name,
-                max_iterations=max_iterations,
-                initial_budget=budget,
-                mode=mode if mode != "ensemble" else "budgeted"  # Ensemble використовує базовий режим
-            )
-            
-            progress(0.3, desc="Початок аналізу медичного випадку...")
-            
-            # Запуск діагностики
-            if mode == "ensemble":
-                # Для ensemble режиму використовуємо run_ensemble якщо доступний
-                progress(0.4, desc="Запуск ensemble діагностики (кілька прогонів)...")
-                try:
-                    result = orchestrator.run_ensemble(
-                        initial_case_info=patient_info,
-                        full_case_details=patient_info,
-                        ground_truth_diagnosis=expected_diagnosis or "Unknown",
-                        num_runs=2  # Зменшено для швидкості в інтерфейсі
-                    )
-                except AttributeError:
-                    # Якщо run_ensemble недоступний, використовуємо звичайний run
-                    progress(0.4, desc="Ensemble недоступний, використовуємо стандартний режим...")
-                    result = orchestrator.run(
-                        initial_case_info=patient_info,
-                        full_case_details=patient_info,
-                        ground_truth_diagnosis=expected_diagnosis or "Unknown"
-                    )
-            else:
-                result = orchestrator.run(
-                    initial_case_info=patient_info,
-                    full_case_details=patient_info,
-                    ground_truth_diagnosis=expected_diagnosis or "Unknown"
-                )
-            
-            progress(0.8, desc="Обробка результатів...")
-            
-            duration = time.time() - start_time
-            
-            # Створення сесії
-            session = DiagnosisSession(
-                timestamp=timestamp,
-                case_name=case_name or f"Case_{len(self.sessions_history) + 1}",
-                patient_info=patient_info[:200] + "..." if len(patient_info) > 200 else patient_info,
-                mode=mode,
-                budget=budget,
-                diagnosis=result.final_diagnosis,
-                confidence=result.accuracy_score,
-                cost=result.total_cost,
-                iterations=result.iterations,
-                duration=duration,
-                status="Успішно" if result.accuracy_score >= 2.0 else "Потребує перегляду",
-                reasoning=getattr(result, 'accuracy_reasoning', 'Недоступно')[:300] + "..."
-            )
-            
-            self.sessions_history.append(session)
-            self.current_session = session
-            
-            progress(1.0, desc="Готово!")
-            
-            # Форматування результатів
-            main_result = self._format_main_result(session, result)
-            detailed_analysis = self._format_detailed_analysis(session, result)
-            recommendations = self._generate_recommendations(result)
-            history_df = self._get_history_dataframe()
-            
-            return main_result, detailed_analysis, recommendations, history_df
-            
-        except Exception as e:
-            error_msg = f"❌ Помилка діагностики: {str(e)}"
-            return error_msg, "", "", pd.DataFrame()
-
-    def _format_main_result(self, session: DiagnosisSession, result) -> str:
-        """Форматування основного результату"""
-        
-        # Визначення рівня довіри
-        if session.confidence >= 4.0:
-            confidence_level = "🎉 ВИСОКИЙ"
-            confidence_color = "green"
-        elif session.confidence >= 3.0:
-            confidence_level = "👍 СЕРЕДНІЙ"
-            confidence_color = "orange"
-        elif session.confidence >= 2.0:
-            confidence_level = "⚠️ НИЗЬКИЙ"
-            confidence_color = "orange"
-        else:
-            confidence_level = "❌ ДУЖЕ НИЗЬКИЙ"
-            confidence_color = "red"
-        
-        main_result = f"""
-# 🏥 Результати MAI-DX Діагностики
-
-## 📋 Основна інформація
-- **Випадок**: {session.case_name}
-- **Час**: {session.timestamp}
-- **Режим**: {session.mode}
-
-## 🎯 Діагноз
-**{session.diagnosis}**
-
-## 📊 Оцінка якості
-- **Рівень довіри**: {confidence_level}
-- **Бал точності**: {session.confidence}/5.0
-- **Статус**: {session.status}
-
-## 💰 Ресурси
-- **Загальна вартість**: ${session.cost:,.2f}
-- **Бюджет**: ${session.budget:,}
-- **Ітерації**: {session.iterations}
-- **Тривалість**: {session.duration:.1f} сек
-        """
-        
-        return main_result
-
-    def _format_detailed_analysis(self, session: DiagnosisSession, result) -> str:
-        """Детальний аналіз результатів"""
-        
-        analysis = f"""
-# 🔬 Детальний Аналіз
-
-## 💭 Медичне обґрунтування
-{session.reasoning}
-
-## 📈 Показники ефективності
-- **Швидкість діагностики**: {session.duration:.1f} секунд
-- **Економічна ефективність**: {((session.budget - session.cost) / session.budget * 100):.1f}% бюджету залишилось
-- **Ітеративна ефективність**: {session.iterations} циклів аналізу
-
-## 🔄 Про��ес діагностики
-1. **Початковий аналіз** пацієнтських даних
-2. **Диференційна діагностика** з {session.iterations} ітераціями
-3. **Консенсус панелі** 8 ШІ-лікарів
-4. **Фінальна оцінка** та верифікація
-
-## 📊 Порівняння з попередніми випадками
-        """
-        
-        if len(self.sessions_history) > 1:
-            avg_confidence = sum(s.confidence for s in self.sessions_history[:-1]) / len(self.sessions_history[:-1])
-            avg_cost = sum(s.cost for s in self.sessions_history[:-1]) / len(self.sessions_history[:-1])
-            
-            analysis += f"""
-- **Середня точність** попередніх випадків: {avg_confidence:.1f}/5.0
-- **Середня вартість** попередніх випадків: ${avg_cost:,.2f}
-- **Поточний випадок**: {"Вище середнього" if session.confidence > avg_confidence else "Нижче середнього"} за точністю
-            """
-        else:
-            analysis += "\n- Це ваш перший діагностичний випадок"
-            
-        return analysis
-
-    def _generate_recommendations(self, result) -> str:
-        """Генерація рекомендацій"""
-        
-        recommendations = """
-# 💡 Рекомендації
-
-## 🏥 Клінічні рекомендації
-        """
-        
-        diagnosis = result.final_diagnosis.lower()
-        
-        # Базові рекомендації залежно від діагнозу
-        if any(word in diagnosis for word in ["emergency", "acute", "urgent", "infarction", "stroke"]):
-            recommendations += """
-- 🚨 **НЕВІДКЛАДНА МЕДИЧНА ДОПОМОГА**
-- Негайна госпіталізація
-- Моніторинг життєво важливих функцій
-- Консультація спеціаліста протягом години
-            """
-        elif any(word in diagnosis for word in ["infection", "bacterial", "viral"]):
-            recommendations += """
-- 💊 Розгляньте антибактеріальну терапію
-- 🌡️ Моніторинг температури тіла
-- 🔬 Додаткові лабораторні дослідження
-- 📅 Контрольний огляд через 48-72 години
-            """
-        elif any(word in diagnosis for word in ["chronic", "management", "control"]):
-            recommendations += """
-- 📋 Розробка довготривалого плану лікування
-- 🗓️ Регулярні контрольні огляди
-- 👨‍⚕️ Консультація профільних спеціалістів
-- 📚 Навчання пацієнта самоконтролю
-            """
-        else:
-            recommendations += """
-- 🔍 Подальше спостереження та моніторинг
-- 📋 Розгляньте додаткові діагностичні тести
-- 👨‍⚕️ Консультація з лікарем для верифікації
-- 📝 Документування симптомів та їх динаміки
-            """
-        
-        recommendations += f"""
-
-## 🔬 Дослідницькі рекомендації
-- **Валідація ШІ-діагнозу**: Порівняйте з експертною оцінкою
-- **Документування**: Збережіть результат для дослідження
-- **Аналіз точності**: Оцініть відповідність реальному діагнозу
-- **Поліпшення**: Використайте результат для налаштування параметрів
-
-## ⚠️ Важливі застереження
-- Цей діагноз згенеровано ШІ для дослідницьких цілей
-- НЕ замінює професійну медичну консультацію
-- Завжди консультуйтеся з кваліфікованими медичними працівниками
-- Використовуйте лише як допоміжний інструмент для навчання
-
-## 📈 Поліпшення точності
-- Додайте більше клінічних деталей до опису випадку
-- Використайте режим "no_budget" для складних випадків
-- Розгляньте ensemble діагностику для критичних випадків
-        """
-        
-        return recommendations
-
-    def _get_history_dataframe(self) -> pd.DataFrame:
-        """Отримання історії у вигляді DataFrame"""
-        
-        if not self.sessions_history:
-            return pd.DataFrame()
-        
-        data = []
-        for session in self.sessions_history:
-            data.append({
-                "Час": session.timestamp,
-                "Випадок": session.case_name,
-                "Режим": session.mode,
-                "Діагноз": session.diagnosis[:50] + "..." if len(session.diagnosis) > 50 else session.diagnosis,
-                "Точність": f"{session.confidence:.1f}/5.0",
-                "Вартість": f"${session.cost:.2f}",
-                "Ітерації": session.iterations,
-                "Тривалість": f"{session.duration:.1f}с",
-                "Статус": session.status
-            })
-        
-        return pd.DataFrame(data)
-
-    def export_results(self) -> str:
-        """Експорт результатів дослідження"""
-        
-        if not self.sessions_history:
-            return "Немає даних для експорту"
-        
-        # Підготовка даних для експорту
-        export_data = {
-            "metadata": {
-                "export_date": datetime.now().isoformat(),
-                "total_sessions": len(self.sessions_history),
-                "software_version": "MAI-DX Gradio Interface v1.0"
-            },
-            "sessions": [asdict(session) for session in self.sessions_history],
-            "statistics": self._calculate_statistics()
-        }
-        
-        # Збереження у файл
-        filename = f"mai_dx_research_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        
-        try:
-            with open(filename, 'w', encoding='utf-8') as f:
-                json.dump(export_data, f, indent=2, ensure_ascii=False)
-            
-            return f"✅ Дані експортовано у файл: {filename}"
-        except Exception as e:
-            return f"❌ Помилка експорту: {e}"
-
-    def _calculate_statistics(self) -> Dict:
-        """Розрахунок статистики досліджень"""
-        
-        if not self.sessions_history:
-            return {}
-        
-        sessions = self.sessions_history
-        
-        stats = {
-            "total_cases": len(sessions),
-            "average_confidence": sum(s.confidence for s in sessions) / len(sessions),
-            "average_cost": sum(s.cost for s in sessions) / len(sessions),
-            "average_duration": sum(s.duration for s in sessions) / len(sessions),
-            "mode_distribution": {},
-            "confidence_distribution": {
-                "high": len([s for s in sessions if s.confidence >= 4.0]),
-                "medium": len([s for s in sessions if 2.0 <= s.confidence < 4.0]),
-                "low": len([s for s in sessions if s.confidence < 2.0])
-            },
-            "success_rate": len([s for s in sessions if s.confidence >= 2.0]) / len(sessions)
-        }
-        
-        # Розподіл по режимах
-        for session in sessions:
-            mode = session.mode
-            stats["mode_distribution"][mode] = stats["mode_distribution"].get(mode, 0) + 1
-        
-        return stats
-
-def create_gradio_interface():
-    """Створення Gradio інтерфейсу"""
-    
-    interface = MAIDXGradioInterface()
-    
-    with gr.Blocks(
-        title="MAI-DX Research Interface",
-        theme=gr.themes.Soft(),
-        css="""
-        .main-header { text-align: center; color: #2c3e50; }
-        .status-good { color: green; font-weight: bold; }
-        .status-bad { color: red; font-weight: bold; }
-        .case-input { font-family: monospace; }
-        """
-    ) as demo:
-        
-        # Заголовок
-        gr.Markdown("""
-        # 🏥 MAI-DX Research Interface
-        ## Дослідницький інтерфейс для медичної діагностики з ШІ
-        
-        Цей інтерфейс дозволяє проводити дослідження діагностичних можливостей MAI-DX системи з 8 ШІ-агентами лікарів.
-        """, elem_classes=["main-header"])
-        
-        # Статус системи
-        with gr.Row():
-            status_display = gr.Markdown()
-            
-        # Оновлення статусу при завантаженні
-        def update_status():
-            status, color = interface.check_api_keys()
-            return f"**Статус системи**: {status}"
-        
-        demo.load(update_status, outputs=[status_display])
-        
-        # Основний інтерфейс
-        with gr.Tabs():
-            
-            # Вкладка діагностики
-            with gr.Tab("🩺 Діагностика"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 📝 Введення медичного випадку")
-                        
-                        case_name = gr.Textbox(
-                            label="Назва випадку",
-                            placeholder="Наприклад: Кардіологічний випадок №1",
-                            value=""
-                        )
-                        
-                        # Dropdown з прикладами
-                        sample_selector = gr.Dropdown(
-                            choices=list(interface.sample_cases.keys()),
-                            label="Приклади випадків",
-                            value=None
-                        )
-                        
-                        patient_info = gr.Textbox(
-                            label="Інформація про пацієнта",
-                            lines=15,
-                            placeholder="Введіть детальний опис медичного випадку...",
-                            elem_classes=["case-input"]
-                        )
-                        
-                        # Завантаження прикладу
-                        def load_sample(sample_name):
-                            if sample_name:
-                                return interface.sample_cases[sample_name], sample_name
-                            return "", ""
-                        
-                        sample_selector.change(
-                            load_sample,
-                            inputs=[sample_selector],
-                            outputs=[patient_info, case_name]
-                        )
-                        
-                        expected_diagnosis = gr.Textbox(
-                            label="Очікуваний діагноз (опціонально)",
-                            placeholder="Для оцінки точності...",
-                            value=""
-                        )
-                        
-                    with gr.Column(scale=1):
-                        gr.Markdown("### ⚙️ Налаштування діагностики")
-                        
-                        mode = gr.Radio(
-                            choices=[
-                                ("instant", "Миттєвий (найшвидший)"),
-                                ("question_only", "Тільки питання (швидко)"),
-                                ("budgeted", "З бюджетом (збалансовано)"),
-                                ("no_budget", "Без обмежень (повний аналіз)"),
-                                ("ensemble", "Консенсус (найточніший)")
-                            ],
-                            label="Режим діагностики",
-                            value="budgeted"
-                        )
-                        
-                        budget = gr.Slider(
-                            minimum=500,
-                            maximum=10000,
-                            step=500,
-                            value=3000,
-                            label="Бюджет ($)"
-                        )
-                        
-                        max_iterations = gr.Slider(
-                            minimum=1,
-                            maximum=10,
-                            step=1,
-                            value=5,
-                            label="Максимум ітерацій"
-                        )
-                        
-                        model_name = gr.Dropdown(
-                            choices=[
-                                "gemini/gemini-2.5-flash",
-                                "gpt-4",
-                                "gpt-3.5-turbo", 
-                                "claude-3-5-sonnet",
-                                "grok-beta",
-                                "deepseek-chat",
-                                "llama-3.1-405b"
-                            ],
-                            label="LLM Модель",
-                            value="gemini/gemini-2.5-flash"
-                        )
-                        
-                        diagnose_btn = gr.Button(
-                            "🚀 Запустити діагностику",
-                            variant="primary",
-                            size="lg"
-                        )
-                
-                # Результати
-                gr.Markdown("### 📊 Результати діагностики")
-                
-                with gr.Row():
-                    with gr.Column():
-                        main_result = gr.Markdown(label="Основний результат")
-                    
-                with gr.Row():
-                    with gr.Column():
-                        detailed_analysis = gr.Markdown(label="Детальний аналіз")
-                        
-                    with gr.Column():
-                        recommendations = gr.Markdown(label="Рекомендації")
-                
-                # Запуск діагностики
-                diagnose_btn.click(
-                    interface.diagnose_case,
-                    inputs=[
-                        case_name, patient_info, mode, budget,
-                        max_iterations, model_name, expected_diagnosis
-                    ],
-                    outputs=[main_result, detailed_analysis, recommendations, gr.State()]
-                )
-            
-            # Вкладка історії
-            with gr.Tab("📈 Історія та Статистика"):
-                gr.Markdown("### 📋 Історія діагностичних сесій")
-                
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 Оновити", variant="secondary")
-                    export_btn = gr.Button("💾 Експортувати результати", variant="primary")
-                
-                history_table = gr.Dataframe(
-                    label="Історія діагнозів",
-                    interactive=False
-                )
-                
-                export_status = gr.Markdown()
-                
-                # Функції для оновлення
-                def refresh_history():
-                    return interface._get_history_dataframe()
-                
-                def export_data():
-                    return interface.export_results()
-                
-                refresh_btn.click(refresh_history, outputs=[history_table])
-                export_btn.click(export_data, outputs=[export_status])
-                
-                # Статистика
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### 📊 Статистика досліджень")
-                        stats_display = gr.Markdown()
-                        
-                        def update_stats():
-                            if not interface.sessions_history:
-                                return "Поки що немає даних для статистики"
-                            
-                            stats = interface._calculate_statistics()
-                            
-                            return f"""
-**Загальна статистика:**
-- Всього випадків: {stats['total_cases']}
-- Середня точність: {stats['average_confidence']:.2f}/5.0
-- Середня вартість: ${stats['average_cost']:.2f}
-- Середня тривалість: {stats['average_duration']:.1f}с
-- Рівень успішності: {stats['success_rate']:.1%}
-
-**Розподіл по режимах:**
-{chr(10).join([f"- {mode}: {count}" for mode, count in stats['mode_distribution'].items()])}
-
-**Розподіл по точності:**
-- Висока (≥4.0): {stats['confidence_distribution']['high']}
-- Середня (2.0-3.9): {stats['confidence_distribution']['medium']}
-- Низька (<2.0): {stats['confidence_distribution']['low']}
-                            """
-                        
-                        refresh_stats_btn = gr.Button("🔄 Оновити статистику")
-                        refresh_stats_btn.click(update_stats, outputs=[stats_display])
-            
-            # Вкладка налаштувань
-            with gr.Tab("⚙️ Налаштування"):
-                gr.Markdown("### 🔧 Конфігурація системи")
-                
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("""
-#### 📋 Інструкції з установки
-
-**Для pip (ваша конфігурація):**
-```bash
-# 1. Встановлення залежностей
-pip install mai-dx python-dotenv gradio pandas
-
-# 2. Створення .env файлу
-echo "OPENAI_API_KEY=your-key-here" > .env
-echo "GEMINI_API_KEY=your-key-here" >> .env
-echo "ANTHROPIC_API_KEY=your-key-here" >> .env
-
-# 3. Запуск інтерфейсу
-python mai_dx_gradio_interface.py
-```
-
-#### 🔑 Необхідні API ключі:
-- **OpenAI**: для GPT моделей
-- **Google AI**: для Gemini моделей  
-- **Anthropic**: для Claude моделей
-
-Отримайте ключі на відповідних платформах та додайте їх у .env файл.
-                        """)
-                    
-                    with gr.Column():
-                        gr.Markdown("""
-#### 🛠️ Troubleshooting
-
-**Часті проблеми:**
-
-1. **MAI-DX не імпортується**
-   - Встановіть: `pip install mai-dx`
-   - Перевірте віртуальне середовище
-
-2. **API ключі не працюють**
-   - Перевірте .env файл
-   - Переконайтеся що файл у тій же папці
-
-3. **Rich console помилки**
-   - Це нормально, можна ігнорувати
-   - Система працює попри помилки
-
-4. **Повільна робота**
-   - Використовуйте ��видші моделі
-   - Зменшіть кількість ітерацій
-   - Оберіть режим "question_only"
-
-#### 📞 Підтримка:
-- GitHub: [MAI-DX Repository](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator)
-- Документація: включена у репозиторій
-                        """)
-                
-                # Тестування підключення
-                with gr.Row():
-                    test_connection_btn = gr.Button("🔍 Тест підключення", variant="secondary")
-                    connection_status = gr.Markdown()
-                    
-                    def test_system():
-                        if not MAI_DX_AVAILABLE:
-                            return f"❌ MAI-DX недоступний: {IMPORT_ERROR}"
-                        
-                        api_status, _ = interface.check_api_keys()
-                        
-                        return f"""
-**Результати тестування:**
-
-📦 **MAI-DX статус**: ✅ Доступний
-🔑 **API ключі**: {api_status}
-🐍 **Python**: {sys.version.split()[0]}
-📍 **Робоча директорія**: {os.getcwd()}
-
-**Готовність до роботи**: {"✅ Готово" if MAI_DX_AVAILABLE else "❌ Потребує налаштування"}
-                        """
-                    
-                    test_connection_btn.click(test_system, outputs=[connection_status])
-    
-    return demo
-
-if __name__ == "__main__":
-    # Створення та запуск інтерфейсу
-    demo = create_gradio_interface()
-    
-    print("🚀 Запуск MAI-DX Research Interface...")
-    print("📱 Інтерфейс буде доступний у браузері")
-    print("🔧 Переконайтеся що .env файл з API ключами у поточній директорії")
-    
-    demo.launch(
-        server_name="0.0.0.0",  # Доступ з мережі
-        server_port=7860,       # Порт
-        share=False,            # Встановіть True для публічного доступу
-        debug=True,             # Режим налагодження
-        show_error=True         # Показувати помилки
-    )

mai_dx_logs/case_20250710_173828_5d4912.json

@@ -1,27 +0,0 @@
-{
-    "case_id": "case_20250710_173828_5d4912",
-    "timestamp": "2025-07-10T17:38:28.722692",
-    "case_name": "🫀 Кардіологічний (Гострий MI)",
-    "patient_info": "Пацієнт: 58-річний чоловік, менеджер, гіпертонія в анамнезі\nСкарги: Гострий роздираючий біль у грудях 3 години, іррадіація в ліву руку\nОгляд: Блідий, пітливий, АТ 160/90, ЧСС 95\nЕКГ: ST-підйоми у відведеннях II, III, aVF (нижня стінка)\nТропонін I: 8.5 нг/мл (норма <0.04)\nАнамнез: Куріння 30 років, дислипідемія, сімейний анамнез ІХС",
-    "mode": "⚡ Миттєвий (найшвидший, базовий аналіз)",
-    "budget": 0,
-    "diagnosis": "ST-elevation Myocardial Infarction (STEMI)",
-    "confidence": 1.0,
-    "cost": 300,
-    "iterations": 1,
-    "duration": 97.490005,
-    "status": "⚠️ Потребує перегляду",
-    "reasoning": "N/A",
-    "messages": [
-        {
-            "timestamp": "2025-07-10T17:40:06.212655",
-            "agent": "Judge",
-            "action": "final_evaluation",
-            "content": "ST-elevation Myocardial Infarction (STEMI)",
-            "reasoning": "[detailed reasoning for the score]",
-            "confidence": 0.2,
-            "cost": 300,
-            "iteration": 8
-        }
-    ]
-}

mai_dx_logs/case_20250710_174912_2b0a2d.json

@@ -1,27 +0,0 @@
-{
-    "case_id": "case_20250710_174912_2b0a2d",
-    "timestamp": "2025-07-10T17:49:12.547474",
-    "case_name": "🫀 Кардіологічний (Гострий MI)",
-    "patient_info": "Пацієнт: 58-річний чоловік, менеджер, гіпертонія в анамнезі\nСкарги: Гострий роздираючий біль у грудях 3 години, іррадіація в ліву руку\nОгляд: Блідий, пітливий, АТ 160/90, ЧСС 95\nЕКГ: ST-підйоми у відведеннях II, III, aVF (нижня стінка)\nТропонін I: 8.5 нг/мл (норма <0.04)\nАнамнез: Куріння 30 років, дислипідемія, сімейний анамнез ІХС",
-    "mode": "budgeted",
-    "budget": 0,
-    "diagnosis": "ST-Elevation Myocardial Infarction (STEMI)",
-    "confidence": 5.0,
-    "cost": 300,
-    "iterations": 1,
-    "duration": 95.609545,
-    "status": "✅ Успішно",
-    "reasoning": "N/A",
-    "messages": [
-        {
-            "timestamp": "2025-07-10T17:50:48.156978",
-            "agent": "Judge",
-            "action": "final_evaluation",
-            "content": "ST-Elevation Myocardial Infarction (STEMI)",
-            "reasoning": "[detailed reasoning for the score]",
-            "confidence": 1.0,
-            "cost": 300,
-            "iteration": 8
-        }
-    ]
-}

mai_dx_wrapper.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+Обгортка для MAI-DX що виправляє проблеми з Rich форматуванням
+"""
+import os
+import sys
+import warnings
+
+# Налаштування середовища
+os.environ.update({
+    "SWARMS_VERBOSITY": "ERROR",
+    "RICH_TRACEBACK": "0", 
+    "SWARMS_SHOW_PANEL": "true",
+    "SWARMS_AUTO_PRINT": "true",
+    "PYTHONWARNINGS": "ignore"
+})
+
+def patch_rich_and_swarms():
+    """Патчимо Rich та Swarms для уникнення помилок виводу"""
+    try:
+        # Патчимо Rich Console
+        import rich.console
+        
+        original_print = rich.console.Console.print
+        
+        def safe_print(self, *args, **kwargs):
+            """Безпечний print що ігнорує None значення"""
+            try:
+                # Фільтруємо None значення
+                filtered_args = [arg for arg in args if arg is not None]
+                if filtered_args:
+                    return original_print(self, *filtered_args, **kwargs)
+            except Exception:
+                # Ігноруємо всі помилки виводу
+                pass
+                
+        rich.console.Console.print = safe_print
+        
+        # Патчимо Swarms formatter
+        try:
+            import swarms.utils.formatter as formatter
+            
+            # # Заміняємо _print_panel на заглушку
+            # def dummy_print_panel(*args, **kwargs):
+            #     pass
+                
+            # if hasattr(formatter, 'Formatter'):
+            #     formatter.Formatter._print_panel = dummy_print_panel
+                
+            # Патчимо print_panel_token_usage
+            def safe_print_panel_token_usage(self, *args, **kwargs):
+                try:
+                    # Просто виводимо базову інформацію без форматування
+                    if args and hasattr(args[0], '__dict__'):
+                        data = args[0].__dict__ if hasattr(args[0], '__dict__') else str(args[0])
+                        print(f"[Token Usage] {data}")
+                except:
+                    pass
+                    
+            if hasattr(formatter, 'print_panel_token_usage'):
+                formatter.print_panel_token_usage = safe_print_panel_token_usage
+                
+        except ImportError:
+            pass
+            
+        # Патчимо threading для уникнення помилок в потоках
+        import threading
+        original_thread_init = threading.Thread.__init__
+        
+        def safe_thread_init(self, *args, **kwargs):
+            """Обгортаємо target функцію в try/except"""
+            original_target = kwargs.get('target')
+            
+            if original_target:
+                def safe_target(*args, **kwargs):
+                    try:
+                        return original_target(*args, **kwargs)
+                    except Exception:
+                        # Ігноруємо помилки в потоках
+                        pass
+                        
+                kwargs['target'] = safe_target
+                
+            return original_thread_init(self, *args, **kwargs)
+            
+        threading.Thread.__init__ = safe_thread_init
+        
+    except Exception as e:
+        print(f"Warning: Could not patch Rich/Swarms: {e}")
+
+# Застосовуємо патчі перед імпортом MAI-DX
+patch_rich_and_swarms()
+
+# Тепер можна безпечно імпортувати MAI-DX
+try:
+    from mai_dx import MaiDxOrchestrator
+    MAI_DX_AVAILABLE = True
+except ImportError as e:
+    MAI_DX_AVAILABLE = False
+    print(f"MAI-DX not available: {e}")
+
+class SafeMaiDxOrchestrator:
+    """Безпечна обгортка для MaiDxOrchestrator"""
+    
+    def __init__(self, *args, **kwargs):
+        if not MAI_DX_AVAILABLE:
+            raise ImportError("MAI-DX is not available")
+            
+        # Додаткові патчі безпосередньо перед створенням
+        patch_rich_and_swarms()
+        
+        # Створюємо оригінальний orchestrator
+        self.orchestrator = MaiDxOrchestrator(*args, **kwargs)
+        
+    def run(self, *args, **kwargs):
+        """Виконати діагностику з додатковим захистом"""
+        # Переконуємося що патчі активні
+        patch_rich_and_swarms()
+        
+        # Тимчасово змінюємо stderr щоб приховати помилки Rich
+        import io
+        original_stderr = sys.stderr
+        sys.stderr = io.StringIO()
+        
+        try:
+            # Виконуємо оригінальний run
+            result = self.orchestrator.run(*args, **kwargs)
+            return result
+        finally:
+            # Відновлю��мо stderr
+            sys.stderr = original_stderr
+            
+    def __getattr__(self, name):
+        """Проксі для всіх інших методів"""
+        return getattr(self.orchestrator, name)
+
+# Експортуємо класи
+__all__ = ['SafeMaiDxOrchestrator', 'MAI_DX_AVAILABLE', 'patch_rich_and_swarms']

production_mai_dx.py

@@ -1,254 +0,0 @@
-#!/usr/bin/env python3
-"""
-Production-ready MAI-DX Orchestrator
-Оптимізовано для реального використання
-"""
-import os
-import sys
-import warnings
-from dotenv import load_dotenv
-
-# Завантажуємо змінні середовища
-load_dotenv()
-
-# Виробничі налаштування для стабільності
-os.environ["SWARMS_VERBOSITY"] = "SILENT"
-os.environ["RICH_TRACEBACK"] = "0" 
-os.environ["SWARMS_SHOW_PANEL"] = "false"
-os.environ["SWARMS_AUTO_PRINT"] = "false"
-os.environ["LOGURU_LEVEL"] = "WARNING"  # Менше спаму в логах
-warnings.filterwarnings("ignore")
-
-# Rich formatter патч (довелося ефективність!)
-def patch_rich_formatter():
-    try:
-        import swarms.utils.formatter
-        def dummy_print_panel(*args, **kwargs):
-            pass
-        if hasattr(swarms.utils.formatter, 'Formatter'):
-            swarms.utils.formatter.Formatter._print_panel = dummy_print_panel
-        return True
-    except:
-        return False
-
-patch_rich_formatter()
-
-from mai_dx import MaiDxOrchestrator
-from loguru import logger
-
-class ProductionMAIDX:
-    """Production-wrapper для MAI-DX з поліпшеннями"""
-    
-    def __init__(self, model="gemini/gemini-2.5-flash"):
-        self.model = model
-        self.available_modes = ["question_only", "budgeted", "no_budget"]
-        
-    def create_optimized_orchestrator(self, mode="question_only", budget=2000, max_iterations=5):
-        """Створює оптимізований оркестратор для production"""
-        
-        # Рекомендовані налаштування для кожного режиму
-        configs = {
-            "question_only": {"budget": 1000, "iterations": 3},
-            "budgeted": {"budget": 3000, "iterations": 5}, 
-            "no_budget": {"budget": 10000, "iterations": 7}
-        }
-        
-        config = configs.get(mode, {"budget": budget, "iterations": max_iterations})
-        
-        try:
-            orchestrator = MaiDxOrchestrator(
-                model_name=self.model,
-                max_iterations=config["iterations"],
-                initial_budget=config["budget"],
-                mode=mode
-            )
-            
-            print(f"✅ MAI-DX готовий: {mode} режим, бюджет ${config['budget']}")
-            return orchestrator
-            
-        except Exception as e:
-            print(f"❌ Помилка створення: {e}")
-            return None
-    
-    def diagnose_case(self, case_description, expected_diagnosis=None, mode="question_only"):
-        """Основний метод для діагностики"""
-        
-        print(f"\n🩺 Запуск MAI-DX діагностики...")
-        print(f"📋 Режим: {mode}")
-        
-        # Створюємо оркестратор
-        orchestrator = self.create_optimized_orchestrator(mode)
-        if not orchestrator:
-            return None
-            
-        try:
-            # Якщо немає expected_diagnosis, використовуємо загальний
-            ground_truth = expected_diagnosis or "Unknown diagnosis"
-            
-            print("🔄 Аналіз випадку... (це може зайняти 2-5 хвилин)")
-            
-            # Запускаємо діагностику
-            result = orchestrator.run(
-                initial_case_info=case_description,
-                full_case_details=case_description,
-                ground_truth_diagnosis=ground_truth
-            )
-            
-            return self._format_result(result, mode)
-            
-        except Exception as e:
-            print(f"❌ Помилка діагностики: {e}")
-            return None
-    
-    def _format_result(self, result, mode):
-        """Форматуємо результат для зручного відображення"""
-        
-        # Оцінюємо якість результату
-        if result.accuracy_score >= 4.0:
-            quality = "🎉 ВІДМІННО"
-        elif result.accuracy_score >= 3.0:
-            quality = "👍 ДОБРЕ"  
-        elif result.accuracy_score >= 2.0:
-            quality = "⚠️ ЗАДОВІЛЬНО"
-        elif "not reached" in result.final_diagnosis.lower():
-            quality = "🔄 ПОТРІБНО БІЛЬШЕ ЧАСУ"
-        else:
-            quality = "🔍 ПОТРЕБУЄ ПЕРЕВІРКИ"
-            
-        formatted = {
-            "diagnosis": result.final_diagnosis,
-            "confidence": result.accuracy_score,
-            "quality": quality,
-            "cost": result.total_cost,
-            "iterations": result.iterations,
-            "mode": mode,
-            "reasoning": getattr(result, 'accuracy_reasoning', 'Недоступно')[:200] + "..."
-        }
-        
-        return formatted
-    
-    def batch_diagnose(self, cases, mode="question_only"):
-        """Діагностика кількох випадків"""
-        results = []
-        
-        for i, case in enumerate(cases, 1):
-            print(f"\n📋 Випадок {i}/{len(cases)}")
-            
-            case_text = case.get("description", "")
-            expected = case.get("expected", None)
-            
-            result = self.diagnose_case(case_text, expected, mode)
-            if result:
-                results.append({"case_id": i, **result})
-        
-        return results
-
-def demo_production_usage():
-    """Демонстрація production використання"""
-    
-    print("=" * 70)
-    print("🏥 MAI-DX PRODUCTION DEMO")
-    print("=" * 70)
-    
-    # Створюємо production instance
-    mai_dx = ProductionMAIDX()
-    
-    # Тестові випадки
-    test_cases = [
-        {
-            "description": "35-year-old man with sudden severe chest pain radiating to left arm, sweating, nausea. Pain started 2 hours ago during exercise.",
-            "expected": "Myocardial infarction"
-        },
-        {
-            "description": "22-year-old woman with severe headache, neck stiffness, fever 39°C, photophobia. Symptoms started this morning.",
-            "expected": "Meningitis"
-        },
-        {
-            "description": "45-year-old smoker with persistent cough for 3 months, weight loss 10kg, bloody sputum occasionally.",
-            "expected": "Lung cancer"
-        }
-    ]
-    
-    print(f"📋 Тестування {len(test_cases)} випадків...")
-    
-    # Запускаємо діагностику
-    results = mai_dx.batch_diagnose(test_cases, mode="question_only")
-    
-    # Виводимо результати
-    print(f"\n{'='*70}")
-    print("📊 РЕЗУЛЬТАТИ ТЕСТУВАННЯ")
-    print("="*70)
-    
-    for result in results:
-        print(f"\n🔍 Випадок {result['case_id']}:")
-        print(f"   Діагноз: {result['diagnosis']}")
-        print(f"   Якість: {result['quality']}")
-        print(f"   Оцінка: {result['confidence']}/5.0")
-        print(f"   Вартість: ${result['cost']}")
-        print(f"   Ітерації: {result['iterations']}")
-    
-    # Статистика
-    successful = sum(1 for r in results if r['confidence'] >= 2.0)
-    print(f"\n📈 Статистика: {successful}/{len(results)} успішних діагнозів")
-    
-    if successful >= len(results) * 0.7:
-        print("🎉 MAI-DX готовий для production!")
-    else:
-        print("⚠️ Потрібне додаткове налаштування")
-
-def simple_diagnostic_session():
-    """Простий інтерактивний сеанс діагностики"""
-    
-    print("\n🩺 Простий сеанс діагностики")
-    print("-" * 40)
-    
-    # Простий випадок для демонстрації
-    case = """
-    29-year-old woman with sore throat and peritonsillar swelling and bleeding.
-    Symptoms did not abate with antimicrobial therapy.
-    
-    History: Onset 7 weeks ago, worsening right-sided pain.
-    Physical Exam: Right peritonsillar mass, displaces uvula.
-    Biopsy: Round-cell neoplasm, positive for desmin and MyoD1.
-    """
-    
-    expected = "Embryonal rhabdomyosarcoma of the pharynx"
-    
-    mai_dx = ProductionMAIDX()
-    result = mai_dx.diagnose_case(case, expected, "question_only")
-    
-    if result:
-        print(f"\n🎯 Діагноз: {result['diagnosis']}")
-        print(f"⭐ Якість: {result['quality']}")
-        print(f"💰 Вартість: ${result['cost']}")
-        
-        # Аналіз близькості діагнозу
-        if "rhabdomyosarcoma" in result['diagnosis'].lower():
-            print("✅ Правильний тип пухлини ідентифіковано!")
-        
-        return True
-    else:
-        print("❌ Діагностика не вдалася")
-        return False
-
-if __name__ == "__main__":
-    try:
-        # Запускаємо простий тест
-        simple_diagnostic_session()
-        
-        # Опціонально - повний demo
-        print("\n" + "="*50)
-        print("Запустити повний production demo? (y/n): ", end="")
-        
-        # Для автоматичного запуску в тестах - пропускаємо input
-        try:
-            choice = input().lower()
-            if choice == 'y':
-                demo_production_usage()
-        except:
-            print("Пропускаємо інтерактивний demo")
-            
-    except KeyboardInterrupt:
-        print("\n⏹️ Зупинено користувачем")
-    except Exception as e:
-        print(f"\n💥 Помилка: {e}")

run_mai_dx_fixed.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Головний файл запуску MAI-DX з виправленнями та повним логуванням
+Використовуйте цей файл замість app.py
+"""
+
+import os
+import sys
+import warnings
+
+# Встановлюємо змінні середовища ДО всіх імпортів
+os.environ.update({
+    "SWARMS_VERBOSITY": "ERROR",
+    "RICH_TRACEBACK": "0", 
+    "SWARMS_SHOW_PANEL": "true",
+    "SWARMS_AUTO_PRINT": "true",
+    "PYTHONWARNINGS": "ignore",
+    "GRADIO_ANALYTICS_ENABLED": "false"
+})
+
+# Ігноруємо всі попередження
+warnings.filterwarnings("ignore")
+
+# Перевіряємо що всі необхідні файли присутні
+required_files = [
+    "enhanced_mai_dx_logger.py",
+    "mai_dx_wrapper.py",
+    "updated_mai_dx_interface.py"
+]
+
+for file in required_files:
+    if not os.path.exists(file):
+        print(f"❌ Помилка: Файл {file} не знайдено!")
+        print("Переконайтеся що всі файли з артефактів збережені в робочій директорії.")
+        sys.exit(1)
+
+# Імпортуємо інтерфейс
+try:
+    from updated_mai_dx_interface import create_updated_gradio_interface
+except ImportError as e:
+    print(f"❌ Помилка імпорту інтерфейсу: {e}")
+    print("Перевірте що всі залежності встановлені:")
+    print("pip install gradio pandas plotly python-dotenv")
+    sys.exit(1)
+
+def main():
+    """Головна функція запуску"""
+    print("🚀 Запуск MAI-DX Enhanced Platform with Full Agent Conversation Logging...")
+    print("📁 Логи будуть збережені в директорії: mai_dx_logs/")
+    print("=" * 60)
+    
+    # Створюємо директорію для логів якщо її немає
+    os.makedirs("mai_dx_logs", exist_ok=True)
+    
+    try:
+        # Створюємо та запускаємо інтерфейс
+        demo = create_updated_gradio_interface()
+        
+        # Запускаємо з налаштуваннями
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False,
+            show_error=True,
+            quiet=False
+        )
+        
+    except KeyboardInterrupt:
+        print("\n⏹️  Зупинка сервера...")
+    except Exception as e:
+        print(f"\n❌ Критична помилка: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

updated_mai_dx_interface.py

@@ -0,0 +1,730 @@
+#!/usr/bin/env python3
+"""
+Оновлений MAI-DX Gradio Interface з повним логуванням розмов агентів
+"""
+import os
+import sys
+import json
+import time
+import pandas as pd
+import gradio as gr
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass, asdict
+import warnings
+
+# Налаштування середовища
+os.environ.update({
+    "SWARMS_VERBOSITY": "ERROR",
+    "RICH_TRACEBACK": "0", 
+    "SWARMS_SHOW_PANEL": "true",
+    "SWARMS_AUTO_PRINT": "true"
+})
+warnings.filterwarnings("ignore")
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# Імпорт MAI-DX через безпечну обгортку
+try:
+    from mai_dx_wrapper import SafeMaiDxOrchestrator as MaiDxOrchestrator, MAI_DX_AVAILABLE
+except ImportError:
+    try:
+        from mai_dx import MaiDxOrchestrator
+        MAI_DX_AVAILABLE = True
+    except ImportError as e:
+        MAI_DX_AVAILABLE = False
+        IMPORT_ERROR = str(e)
+
+# Імпорт покращеного логгера
+from enhanced_mai_dx_logger import MAIDxConversationLogger, DiagnosisSession
+
+# Перевірка доступності Plotly
+try:
+    import plotly.graph_objects as go
+    import plotly.express as px
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
+    print("⚠️ Plotly не встановлено, візуалізації будуть недоступні")
+
+class RealTimeMetrics:
+    """Метрики в реальному часі"""
+    def __init__(self): 
+        self.reset()
+    
+    def reset(self):
+        self.start_time = time.time()
+        self.agents_activity = {
+            'Dr. Hypothesis': 0, 'Dr. Test-Chooser': 0, 'Dr. Challenger': 0,
+            'Dr. Stewardship': 0, 'Dr. Checklist': 0, 'Consensus Coordinator': 0,
+            'Gatekeeper': 0, 'Judge': 0
+        }
+        self.cost_progression = []
+        self.conversation_rounds = []
+    
+    def update_agent_activity(self, agent_name: str):
+        if agent_name in self.agents_activity: 
+            self.agents_activity[agent_name] += 1
+    
+    def add_cost_point(self, cost: float):
+        self.cost_progression.append({'time': time.time() - self.start_time, 'cost': cost})
+        
+    def add_conversation_round(self, round_data: dict):
+        self.conversation_rounds.append(round_data)
+
+class UpdatedMAIDXInterface:
+    """Оновлений інтерфейс з повним логуванням розмов"""
+    
+    def __init__(self):
+        self.sessions_history = []
+        self.conversation_logger = MAIDxConversationLogger("mai_dx_logs")
+        self.current_metrics = RealTimeMetrics()
+        
+        self.sample_cases = {
+            "🫀 Кардіологічний (Гострий MI)": {
+                "info": "Пацієнт: 58-річний чоловік, менеджер, гіпертонія в анамнезі\nСкарги: Гострий роздираючий біль у грудях 3 години, іррадіація в ліву руку\nОгляд: Блідий, пітливий, АТ 160/90, ЧСС 95\nЕКГ: ST-підйоми у відведеннях II, III, aVF (нижня стінка)\nТропонін I: 8.5 нг/мл (норма <0.04)\nАнамнез: Куріння 30 років, дислипідемія, сімейний анамнез ІХС",
+                "expected": "Acute inferior wall myocardial infarction (STEMI)"
+            },
+            "🧠 Неврологічний (Гострий інсульт)": {
+                "info": "Пацієнтка: 67-річна жінка, раптові неврологічні симптоми\nПрезентація: Раптова слабкість правої сторони 2 години тому\nОгляд: Свідома, дезорієнтована у часі, правостороннє опущення обличчя\nНеврологія: Правостороння геміплегія, афазія, девіація очей вліво\nКТ голови: Гострого крововиливу немає, рання ішемія у лівій МСА\nNIHSS: 15 балів",
+                "expected": "Acute ischemic stroke in the left middle cerebral artery territory"
+            },
+            "🦠 Інфекційний (Сепсис)": {
+                "info": "Пацієнт: 45-річний чоловік з прогресуючою лихоманкою\nСкарги: Висока температура 39.5°C, озноб, загальна слабкість 3 дні\nОгляд: Гарячий, тахікардія 120/хв, гіпотензія 85/50\nЛабораторно: Лейкоцити 18000, С-реактивний білок 180, прокальцитонін 5.2\nПосів крові: Pending, lactate 4.2 ммоль/л\nАнамнез: Нещодавня стоматологічна процедура",
+                "expected": "Sepsis with a possible odontogenic source"
+            }
+        }
+    
+    def diagnose_with_full_logging(
+        self, case_name: str, patient_info: str, mode: str, budget: int, max_iterations: int,
+        model_name: str, expected_diagnosis: str = "", enable_logging: bool = True,
+        progress=gr.Progress()
+    ) -> Tuple[str, str, str, Optional[object], Optional[object], str, str]:
+        
+        if not MAI_DX_AVAILABLE: 
+            return self._format_error(f"❌ MAI-DX недоступний: {IMPORT_ERROR}")
+        if not patient_info.strip(): 
+            return self._format_error("❌ Введіть інформацію про пацієнта")
+        
+        self.current_metrics.reset()
+        conversation_log = ""
+        structured_conversations = ""
+        case_id = None
+        
+        # Тимчасово відключаємо Rich форматування
+        original_show_panel = os.environ.get("SWARMS_SHOW_PANEL", "false")
+        original_auto_print = os.environ.get("SWARMS_AUTO_PRINT", "false")
+        os.environ["SWARMS_SHOW_PANEL"] = "false"
+        os.environ["SWARMS_AUTO_PRINT"] = "false"
+        
+        try:
+            progress(0.1, desc="🚀 Ініціалізація...")
+            
+            # Створюємо сесію
+            if enable_logging:
+                case_id = self.conversation_logger.start_session(
+                    case_name=case_name,
+                    patient_info=patient_info,
+                    mode=mode,
+                    budget=budget
+                )
+                conversation_log += f"📝 Розпочато логування: {case_id}\n\n"
+            
+            progress(0.2, desc="🤖 Створення AI-панелі...")
+            
+            # Створюємо orchestrator
+            orchestrator = MaiDxOrchestrator(
+                model_name=model_name, 
+                max_iterations=max_iterations, 
+                initial_budget=budget, 
+                mode=mode
+            )
+            
+            progress(0.3, desc="🔍 Запуск діагностики...")
+            start_time = time.time()
+            
+            # Виконуємо діагностику з повним захопленням
+            if enable_logging and case_id:
+                result = self.conversation_logger.capture_orchestrator_output(
+                    case_id=case_id,
+                    orchestrator_func=orchestrator.run,
+                    initial_case_info=patient_info,
+                    full_case_details=patient_info,
+                    ground_truth_diagnosis=expected_diagnosis or "Unknown"
+                )
+                
+                # Отримуємо захоплений вивід
+                session = self.conversation_logger.sessions.get(case_id)
+                if session:
+                    conversation_log += "🤖 Повний лог виконання:\n" + "="*60 + "\n"
+                    conversation_log += session.raw_output + "\n" + "="*60 + "\n\n"
+                    
+                    # Оновлюємо метрики з розмов
+                    for conv in session.conversations:
+                        self.current_metrics.add_conversation_round({
+                            'round': conv.round_number,
+                            'agents': len(set(msg.agent_name for msg in conv.messages)),
+                            'messages': len(conv.messages),
+                            'cost': conv.cost_incurred
+                        })
+                        
+                        # Оновлюємо активність агентів
+                        for msg in conv.messages:
+                            self.current_metrics.update_agent_activity(msg.agent_name)
+                            
+                        # Додаємо точки вартості
+                        if conv.cost_incurred > 0:
+                            elapsed_time = (datetime.fromisoformat(conv.end_time or conv.start_time) - 
+                                          datetime.fromisoformat(session.timestamp)).total_seconds()
+                            self.current_metrics.add_cost_point(conv.cost_incurred)
+            else:
+                # Виконуємо без логування
+                result = orchestrator.run(
+                    initial_case_info=patient_info,
+                    full_case_details=patient_info,
+                    ground_truth_diagnosis=expected_diagnosis or "Unknown"
+                )
+            
+            duration = time.time() - start_time
+            progress(0.9, desc="📊 Обробка результатів...")
+            
+            # Завершуємо сесію
+            if enable_logging and case_id:
+                saved_case_id = self.conversation_logger.end_session(
+                    case_id=case_id,
+                    final_diagnosis=result.final_diagnosis,
+                    confidence=result.accuracy_score,
+                    cost=result.total_cost,
+                    reasoning=getattr(result, 'accuracy_reasoning', 'N/A')
+                )
+                conversation_log += f"💾 Сесію збережено як: {saved_case_id}\n"
+                
+                # Генеруємо HTML звіт
+                html_path = self.conversation_logger.export_conversation_html(case_id)
+                conversation_log += f"📄 HTML звіт: {html_path}\n"
+                
+                # Форматуємо структуровані розмови
+                structured_conversations = self._format_structured_conversations(case_id)
+            
+            # Створюємо об'єкт сесії для історії
+            session = DiagnosisSession(
+                case_id=case_id or "no_logging",
+                timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                case_name=case_name,
+                patient_info=patient_info,
+                mode=mode,
+                budget=budget,
+                diagnosis=result.final_diagnosis,
+                confidence=result.accuracy_score,
+                cost=result.total_cost,
+                iterations=getattr(result, 'iterations', 0),
+                duration=duration,
+                status="✅ Успішно" if result.accuracy_score >= 3.0 else "⚠️ Потребує перегляду",
+                reasoning=getattr(result, 'accuracy_reasoning', 'N/A')
+            )
+            self.sessions_history.append(session)
+            
+            progress(1.0, desc="✅ Готово!")
+            
+            # Створюємо візуалізації
+            metrics_plot = self._create_enhanced_metrics_visualization()
+            agent_plot = self._create_conversation_flow_chart()
+            
+            return (
+                self._format_main_result(session),
+                self._format_detailed_analysis(session),
+                self._generate_enhanced_recommendations(result, expected_diagnosis),
+                metrics_plot,
+                agent_plot,
+                conversation_log,
+                structured_conversations
+            )
+            
+        except Exception as e:
+            error_msg = f"❌ Помилка діагностики: {str(e)}"
+            if case_id: 
+                error_msg += f"\n🗂️ Case ID: {case_id}"
+            return self._format_error(error_msg)
+            
+        finally:
+            # Відновлюємо оригінальні налаштування
+            os.environ["SWARMS_SHOW_PANEL"] = original_show_panel
+            os.environ["SWARMS_AUTO_PRINT"] = original_auto_print
+    
+    def _format_structured_conversations(self, case_id: str) -> str:
+        """Форматує структуровані розмови у читабельний вигляд"""
+        conversations = self.conversation_logger.get_session_conversations(case_id)
+        
+        if not conversations:
+            return "📭 Розмови не знайдено"
+        
+        output = "## 💬 Структуровані розмови агентів\n\n"
+        
+        for conv in conversations:
+            output += f"### 🔄 Раунд {conv.round_number}\n"
+            output += f"**Час:** {conv.start_time} - {conv.end_time or 'В процесі'}\n\n"
+            
+            for msg in conv.messages:
+                emoji = {
+                    'reasoning': '🤔',
+                    'decision': '💡',
+                    'input': '❓',
+                    'output': '📊'
+                }.get(msg.message_type, '💬')
+                
+                output += f"{emoji} **{msg.agent_name}** [{msg.message_type}]\n"
+                output += f"```\n{msg.content[:500]}{'...' if len(msg.content) > 500 else ''}\n```\n\n"
+            
+            if conv.decision:
+                output += f"**🎯 Рішення:** {conv.decision}\n"
+            
+            if conv.tests_ordered:
+                output += f"**🧪 Замовлені тести:** {', '.join(conv.tests_ordered)}\n"
+                
+            if conv.questions_asked:
+                output += f"**❓ Поставлені питання:** {', '.join(conv.questions_asked[:3])}...\n"
+                
+            if conv.cost_incurred > 0:
+                output += f"**💰 Вартість раунду:** ${conv.cost_incurred:.2f}\n"
+                
+            output += "\n---\n\n"
+        
+        return output
+    
+    def _create_enhanced_metrics_visualization(self):
+        """Створює покращену візуалізацію метрик"""
+        if not PLOTLY_AVAILABLE:
+            return None
+            
+        if not self.current_metrics.conversation_rounds:
+            return None
+            
+        try:
+            # Створюємо subplot з двома графіками
+            from plotly.subplots import make_subplots
+            
+            fig = make_subplots(
+                rows=2, cols=1,
+                subplot_titles=('Прогресія вартості', 'Активність по раундах'),
+                vertical_spacing=0.15
+            )
+            
+            # Графік вартості
+            if self.current_metrics.cost_progression:
+                fig.add_trace(
+                    go.Scatter(
+                        x=[p['time'] for p in self.current_metrics.cost_progression],
+                        y=[p['cost'] for p in self.current_metrics.cost_progression],
+                        mode='lines+markers',
+                        name='Вартість',
+                        line=dict(color='#3498db', width=3)
+                    ),
+                    row=1, col=1
+                )
+            
+            # Графік активності по раундах
+            rounds_data = self.current_metrics.conversation_rounds
+            if rounds_data:
+                fig.add_trace(
+                    go.Bar(
+                        x=[f"Раунд {r['round']}" for r in rounds_data],
+                        y=[r['messages'] for r in rounds_data],
+                        name='Кількість повідомлень',
+                        marker_color='#2ecc71'
+                    ),
+                    row=2, col=1
+                )
+            
+            fig.update_layout(
+                height=600,
+                showlegend=True,
+                template='plotly_white'
+            )
+            
+            return fig
+            
+        except Exception as e:
+            print(f"Помилка візуалізації: {e}")
+            return None
+    
+    def _create_conversation_flow_chart(self):
+        """Створює діаграму потоку розмов між агентами"""
+        if not PLOTLY_AVAILABLE:
+            return None
+            
+        activity_data = {k: v for k, v in self.current_metrics.agents_activity.items() if v > 0}
+        
+        if not activity_data:
+            return None
+            
+        try:
+            # Кольорова схема для різних агентів
+            colors = {
+                'Dr. Hypothesis': '#3498db',
+                'Dr. Test-Chooser': '#e74c3c',
+                'Dr. Challenger': '#f39c12',
+                'Dr. Stewardship': '#27ae60',
+                'Dr. Checklist': '#9b59b6',
+                'Consensus Coordinator': '#34495e',
+                'Gatekeeper': '#16a085',
+                'Judge': '#c0392b'
+            }
+            
+            agent_colors = [colors.get(agent, '#95a5a6') for agent in activity_data.keys()]
+            
+            fig = go.Figure(go.Bar(
+                x=list(activity_data.keys()),
+                y=list(activity_data.values()),
+                text=list(activity_data.values()),
+                textposition='auto',
+                marker_color=agent_colors
+            ))
+            
+            fig.update_layout(
+                title='🤖 Активність агентів у діагностичному процесі',
+                xaxis_title='Агенти',
+                yaxis_title='Кількість взаємодій',
+                template='plotly_white',
+                height=400,
+                margin=dict(t=60, b=100)
+            )
+            
+            fig.update_xaxes(tickangle=-45)
+            
+            return fig
+            
+        except Exception as e:
+            print(f"Помилка графіку агентів: {e}")
+            return None
+    
+    def _format_main_result(self, session):
+        efficiency = ((session.budget - session.cost) / session.budget * 100) if session.budget > 0 else 0
+        confidence_emoji = "🎯" if session.confidence >= 4.0 else "👍" if session.confidence >= 3.0 else "⚠️"
+        
+        return f"""
+## 🏥 Результати MAI-DX Діагностики
+
+### 📋 Основна інформація
+- **🗂️ Випадок**: {session.case_name}
+- **🆔 ID сесії**: {session.case_id}
+- **⏰ Час**: {session.timestamp}  
+- **🔧 Режим**: {session.mode}
+
+### {confidence_emoji} Діагностичний висновок
+**{session.diagnosis}**
+
+### 📊 Показники якості
+- **Точність**: {session.confidence:.1f}/5.0 ⭐
+- **Статус**: {session.status}
+- **Ітерації**: {session.iterations} циклів
+- **Кількість агентів**: {len([a for a in self.current_metrics.agents_activity.values() if a > 0])}
+
+### 💰 Економічні показники  
+- **Витрачено**: ${session.cost:,.2f}
+- **Бюджет**: ${session.budget:,}
+- **Ефективність**: {efficiency:.1f}% бюджету збережено
+- **Швидкість**: {session.duration:.1f} секунд
+"""
+    
+    def _format_detailed_analysis(self, session):
+        return f"""
+## 🔬 Детальний клінічний аналіз
+
+### 💭 Мед��чне обґрунтування
+{session.reasoning}
+
+### 📂 Файли логів
+- JSON: `mai_dx_logs/{session.case_id}.json`
+- Raw text: `mai_dx_logs/{session.case_id}_raw.txt`
+- HTML звіт: `mai_dx_logs/{session.case_id}_conversation.html`
+"""
+    
+    def _generate_enhanced_recommendations(self, result, expected_diagnosis):
+        comparison = ""
+        if expected_diagnosis:
+            is_match = expected_diagnosis.lower() in result.final_diagnosis.lower()
+            comparison = f"""
+### 🎯 Порівняння з очікуваним
+**Очікувався**: {expected_diagnosis}
+**Отримано**: {result.final_diagnosis}
+**Збіг**: {'✅ Так' if is_match else '❌ Ні'}
+"""
+        
+        return f"""
+## 💡 Клінічні рекомендації
+
+### 🏥 Негайні дії
+- 🔍 Верифікувати діагноз з лікарем-спеціалістом
+- 📋 Розглянути необхідність додаткових досліджень
+- 📊 Переглянути детальний лог розмов агентів
+
+{comparison}
+
+### ⚠️ Важливе застереження
+🔴 **Цей діагноз згенеровано ШІ і НЕ замінює професійну медичну консультацію.**
+"""
+    
+    def _format_error(self, error_msg):
+        return (error_msg, "", "", None, None, "", "")
+    
+    def load_sample_case(self, sample_key):
+        case_data = self.sample_cases.get(sample_key, {})
+        return case_data.get("info", ""), sample_key, case_data.get("expected", "")
+    
+    def get_session_details(self, case_id: str):
+        """Отримати детальну інформацію про сесію"""
+        conversations = self.conversation_logger.get_session_conversations(case_id)
+        
+        if not conversations:
+            return "Сесія не знайдена"
+        
+        details = f"## Детальний аналіз сесії {case_id}\n\n"
+        details += f"**Кількість раундів**: {len(conversations)}\n"
+        
+        total_messages = sum(len(conv.messages) for conv in conversations)
+        details += f"**Всього повідомлень**: {total_messages}\n\n"
+        
+        # Статистика по агентах
+        agent_stats = {}
+        for conv in conversations:
+            for msg in conv.messages:
+                agent_stats[msg.agent_name] = agent_stats.get(msg.agent_name, 0) + 1
+        
+        details += "### Статистика по агентах:\n"
+        for agent, count in sorted(agent_stats.items(), key=lambda x: x[1], reverse=True):
+            details += f"- **{agent}**: {count} повідомлень\n"
+        
+        return details
+
+def create_updated_gradio_interface():
+    interface = UpdatedMAIDXInterface()
+    
+    custom_css = """
+    .gradio-container {
+        font-family: 'Inter', sans-serif;
+    }
+    .main-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 2rem;
+        border-radius: 15px;
+        margin-bottom: 2rem;
+        text-align: center;
+    }
+    .conversation-log {
+        font-family: 'Fira Code', monospace;
+        background: #2d3748;
+        color: #e2e8f0;
+        border-radius: 8px;
+        padding: 1rem;
+        max-height: 600px;
+        overflow-y: auto;
+        white-space: pre-wrap;
+    }
+    .structured-conv {
+        background: #f7fafc;
+        border: 1px solid #e2e8f0;
+        border-radius: 8px;
+        padding: 1rem;
+        max-height: 800px;
+        overflow-y: auto;
+    }
+    """
+    
+    with gr.Blocks(
+        title="🏥 MAI-DX Enhanced Platform with Full Logging",
+        theme=gr.themes.Soft(primary_hue="blue"),
+        css=custom_css
+    ) as demo:
+        
+        gr.HTML("""
+        <div class='main-header'>
+            <h1>🏥 MAI-DX Enhanced Research Platform</h1>
+            <p>🤖 Платформа для ШІ-діагностики з повним логуванням розмов агентів</p>
+        </div>
+        """)
+        
+        with gr.Tabs():
+            with gr.Tab("🩺 Діагностика", elem_id="diagnosis-tab"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📝 Клінічний випадок")
+                        case_name = gr.Textbox(
+                            label="🏷️ Назва випадку",
+                            placeholder="Наприклад: Кардіологічний випадок №1"
+                        )
+                        
+                        sample_selector = gr.Dropdown(
+                            choices=list(interface.sample_cases.keys()),
+                            label="🎯 Готові тестові випадки",
+                            interactive=True
+                        )
+                        
+                        patient_info = gr.Textbox(
+                            label="👤 Інформація про пацієнта",
+                            lines=12,
+                            placeholder="Введіть опис клінічного випадку..."
+                        )
+                        
+                        expected_diagnosis = gr.Textbox(
+                            label="🎯 Очікуваний діагноз (англ.)",
+                            lines=2
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### ⚙️ Налаштування")
+                        
+                        mode = gr.Radio(
+                            choices=["instant", "question_only", "budgeted", "no_budget", "ensemble"],
+                            label="🔧 Режим",
+                            value="budgeted",
+                            interactive=True
+                        )
+                        
+                        budget = gr.Slider(
+                            minimum=500,
+                            maximum=10000,
+                            step=500,
+                            value=3000,
+                            label="💵 Бюджет ($)",
+                            interactive=True
+                        )
+                        
+                        max_iterations = gr.Slider(
+                            minimum=1,
+                            maximum=15,
+                            step=1,
+                            value=8,
+                            label="🔄 Макс. ітерацій",
+                            interactive=True
+                        )
+                        
+                        model_name = gr.Dropdown(
+                            choices=[
+                                "gemini/gemini-2.5-flash", 
+                                "gpt-4", 
+                                "gpt-4-turbo", 
+                                "claude-3-5-sonnet",
+                                "gpt-4o"
+                            ],
+                            label="🤖 LLM Модель",
+                            value="gemini/gemini-2.5-flash",
+                            interactive=True
+                        )
+                        
+                        enable_logging = gr.Checkbox(
+                            label="📝 Повне логування розмов",
+                            value=True,
+                            interactive=True
+                        )
+                        
+                        diagnose_btn = gr.Button(
+                            "🚀 Запустити діагностику",
+                            variant="primary",
+                            size="lg"
+                        )
+                
+                # Зв'язуємо вибір прикладу
+                sample_selector.change(
+                    interface.load_sample_case,
+                    inputs=sample_selector,
+                    outputs=[patient_info, case_name, expected_diagnosis]
+                )
+                
+                gr.Markdown("---\n## 📊 Результати діагностики")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        main_result = gr.Markdown()
+                        detailed_analysis = gr.Markdown()
+                    
+                    with gr.Column(scale=1):
+                        recommendations = gr.Markdown()
+                
+                # Візуалізації
+                if PLOTLY_AVAILABLE:
+                    with gr.Row():
+                        metrics_plot = gr.Plot(label="📈 Метрики процесу")
+                        agent_activity_plot = gr.Plot(label="🤖 Активність агентів")
+                else:
+                    metrics_plot = gr.Plot(visible=False)
+                    agent_activity_plot = gr.Plot(visible=False)
+                
+                # Логи
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 💬 Сирий вивід системи")
+                        conversation_logs = gr.Textbox(
+                            label="Raw logs",
+                            lines=15,
+                            elem_classes=["conversation-log"],
+                            interactive=False,
+                            show_copy_button=True
+                        )
+                    
+                    with gr.Column():
+                        gr.Markdown("### 🗣️ Структуровані розмови агентів")
+                        structured_conversations = gr.Markdown(
+                            elem_classes=["structured-conv"]
+                        )
+                
+                # Підключаємо функцію діагностики
+                diagnose_btn.click(
+                    interface.diagnose_with_full_logging,
+                    inputs=[
+                        case_name, patient_info, mode, budget, 
+                        max_iterations, model_name, expected_diagnosis, 
+                        enable_logging
+                    ],
+                    outputs=[
+                        main_result, detailed_analysis, recommendations,
+                        metrics_plot, agent_activity_plot,
+                        conversation_logs, structured_conversations
+                    ]
+                )
+            
+            with gr.Tab("📊 Аналіз логів", elem_id="logs-tab"):
+                gr.Markdown("### 🔍 Аналіз збережених діагностичних сесій")
+                
+                with gr.Row():
+                    case_id_input = gr.Textbox(
+                        label="🆔 ID сесії",
+                        placeholder="Введіть ID сесії для аналізу"
+                    )
+                    
+                    analyze_btn = gr.Button("📋 Аналізувати")
+                
+                session_details = gr.Markdown()
+                
+                # Функція аналізу
+                analyze_btn.click(
+                    interface.get_session_details,
+                    inputs=[case_id_input],
+                    outputs=[session_details]
+                )
+                
+                gr.Markdown("### 📁 Експорт даних")
+                
+                with gr.Row():
+                    export_format = gr.Radio(
+                        choices=["JSON", "HTML", "CSV"],
+                        label="Формат експорту",
+                        value="HTML"
+                    )
+                    
+                    export_btn = gr.Button("📤 Експортувати")
+                
+                export_status = gr.Markdown()
+
+    return demo
+
+if __name__ == "__main__":
+    print("🚀 Запуск MAI-DX Enhanced Platform with Full Agent Conversation Logging...")
+    demo = create_updated_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        debug=False
+    )

utils/analyze_logs.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""
+Скрипт для аналізу збережених логів MAI-DX
+"""
+
+import os
+import json
+import pandas as pd
+from datetime import datetime
+from collections import defaultdict
+import argparse
+
+def load_all_sessions(log_dir="mai_dx_logs"):
+    """Завантажити всі сесії з директорії логів"""
+    sessions = []
+    
+    if not os.path.exists(log_dir):
+        print(f"❌ Директорія {log_dir} не існує")
+        return sessions
+        
+    for filename in os.listdir(log_dir):
+        if filename.endswith('.json') and not filename.endswith('_analytics.json'):
+            filepath = os.path.join(log_dir, filename)
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    session = json.load(f)
+                    sessions.append(session)
+            except Exception as e:
+                print(f"⚠️ Помилка читання {filename}: {e}")
+                
+    return sessions
+
+def analyze_session(session):
+    """Детальний аналіз однієї сесії"""
+    print(f"\n{'='*60}")
+    print(f"📋 Аналіз сесії: {session['case_id']}")
+    print(f"{'='*60}")
+    
+    print(f"\n📊 Основна інформація:")
+    print(f"  - Назва випадку: {session['case_name']}")
+    print(f"  - Час: {session['timestamp']}")
+    print(f"  - Режим: {session['mode']}")
+    print(f"  - Статус: {session['status']}")
+    
+    print(f"\n💊 Діагноз:")
+    print(f"  - Фінальний діагноз: {session['diagnosis']}")
+    print(f"  - Впевненість: {session['confidence']}/5.0")
+    print(f"  - Обґрунтування: {session['reasoning'][:100]}...")
+    
+    print(f"\n💰 Економіка:")
+    print(f"  - Витрачено: ${session['cost']}")
+    print(f"  - Бюджет: ${session['budget']}")
+    print(f"  - Ефективність: {((session['budget'] - session['cost']) / session['budget'] * 100):.1f}%")
+    
+    print(f"\n⏱️ Продуктивність:")
+    print(f"  - Тривалість: {session['duration']:.1f} секунд")
+    print(f"  - Ітерацій: {session['iterations']}")
+    
+    # Аналіз розмов
+    conversations = session.get('conversations', [])
+    if conversations:
+        print(f"\n💬 Аналіз розмов:")
+        print(f"  - Всього раундів: {len(conversations)}")
+        
+        # Підрахунок активності агентів
+        agent_activity = defaultdict(int)
+        message_types = defaultdict(int)
+        total_messages = 0
+        
+        for conv in conversations:
+            for msg in conv.get('messages', []):
+                agent_activity[msg['agent_name']] += 1
+                message_types[msg['message_type']] += 1
+                total_messages += 1
+                
+        print(f"  - Всього повідомлень: {total_messages}")
+        
+        print(f"\n  🤖 Активність агентів:")
+        for agent, count in sorted(agent_activity.items(), key=lambda x: x[1], reverse=True):
+            print(f"    - {agent}: {count} повідомлень ({count/total_messages*100:.1f}%)")
+            
+        print(f"\n  📝 Типи повідомлень:")
+        for msg_type, count in sorted(message_types.items(), key=lambda x: x[1], reverse=True):
+            print(f"    - {msg_type}: {count} ({count/total_messages*100:.1f}%)")
+            
+        # Деталі раундів
+        print(f"\n  🔄 Деталі раундів:")
+        for i, conv in enumerate(conversations):
+            msgs = len(conv.get('messages', []))
+            cost = conv.get('cost_incurred', 0)
+            decision = conv.get('decision', 'N/A')
+            print(f"    Раунд {i+1}: {msgs} повідомлень, ${cost:.2f}, Рішення: {decision}")
+
+def generate_summary_report(sessions, output_file="mai_dx_summary_report.html"):
+    """Генерація зведеного HTML звіту по всіх сесіях"""
+    if not sessions:
+        print("❌ Немає сесій для аналізу")
+        return
+        
+    html_content = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>MAI-DX Summary Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
+        .container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+        h1 { color: #333; text-align: center; }
+        .summary { background: #e8f4f8; padding: 20px; border-radius: 8px; margin: 20px 0; }
+        .metric { display: inline-block; margin: 10px 20px; }
+        .metric-value { font-size: 24px; font-weight: bold; color: #007bff; }
+        .metric-label { color: #666; }
+        table { width: 100%; border-collapse: collapse; margin: 20px 0; }
+        th { background: #007bff; color: white; padding: 12px; text-align: left; }
+        td { padding: 10px; border-bottom: 1px solid #ddd; }
+        tr:hover { background: #f5f5f5; }
+        .success { color: #28a745; }
+        .warning { color: #ffc107; }
+        .danger { color: #dc3545; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🏥 MAI-DX Summary Report</h1>
+"""
+    
+    # Загальна статистика
+    total_sessions = len(sessions)
+    avg_accuracy = sum(s['confidence'] for s in sessions) / total_sessions
+    avg_cost = sum(s['cost'] for s in sessions) / total_sessions
+    avg_duration = sum(s['duration'] for s in sessions) / total_sessions
+    success_rate = sum(1 for s in sessions if s['confidence'] >= 3.0) / total_sessions * 100
+    
+    html_content += f"""
+        <div class="summary">
+            <h2>📊 Загальна статистика</h2>
+            <div class="metric">
+                <div class="metric-value">{total_sessions}</div>
+                <div class="metric-label">Всього сесій</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">{avg_accuracy:.2f}/5.0</div>
+                <div class="metric-label">Середня точність</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">${avg_cost:.2f}</div>
+                <div class="metric-label">Середня вартість</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">{avg_duration:.1f}с</div>
+                <div class="metric-label">Середній час</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">{success_rate:.1f}%</div>
+                <div class="metric-label">Успішність</div>
+            </div>
+        </div>
+        
+        <h2>📋 Детальна таблиця сесій</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>ID сесії</th>
+                    <th>Час</th>
+                    <th>Випадок</th>
+                    <th>Діагноз</th>
+                    <th>Точність</th>
+                    <th>Вартість</th>
+                    <th>Час</th>
+                    <th>Статус</th>
+                </tr>
+            </thead>
+            <tbody>
+"""
+    
+    # Сортуємо сесії за часом
+    sorted_sessions = sorted(sessions, key=lambda x: x['timestamp'], reverse=True)
+    
+    for session in sorted_sessions:
+        status_class = 'success' if session['confidence'] >= 3.0 else 'warning'
+        html_content += f"""
+                <tr>
+                    <td>{session['case_id']}</td>
+                    <td>{session['timestamp'][:19]}</td>
+                    <td>{session['case_name']}</td>
+                    <td>{session['diagnosis']}</td>
+                    <td class="{status_class}">{session['confidence']:.1f}/5.0</td>
+                    <td>${session['cost']:.2f}</td>
+                    <td>{session['duration']:.1f}с</td>
+                    <td>{session['status']}</td>
+                </tr>
+"""
+    
+    html_content += """
+            </tbody>
+        </table>
+        
+        <p style="text-align: center; color: #666; margin-top: 30px;">
+            Згенеровано: """ + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + """
+        </p>
+    </div>
+</body>
+</html>
+"""
+    
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+        
+    print(f"\n✅ Зведений звіт збережено: {output_file}")
+
+def export_to_csv(sessions, output_file="mai_dx_sessions.csv"):
+    """Експорт сесій в CSV"""
+    if not sessions:
+        print("❌ Немає сесій для експорту")
+        return
+        
+    # Створюємо DataFrame
+    data = []
+    for session in sessions:
+        # Підраховуємо агентів та повідомлення
+        total_messages = 0
+        unique_agents = set()
+        
+        for conv in session.get('conversations', []):
+            for msg in conv.get('messages', []):
+                total_messages += 1
+                unique_agents.add(msg['agent_name'])
+                
+        data.append({
+            'case_id': session['case_id'],
+            'timestamp': session['timestamp'],
+            'case_name': session['case_name'],
+            'mode': session['mode'],
+            'diagnosis': session['diagnosis'],
+            'confidence': session['confidence'],
+            'cost': session['cost'],
+            'budget': session['budget'],
+            'duration': session['duration'],
+            'iterations': session['iterations'],
+            'status': session['status'],
+            'total_messages': total_messages,
+            'unique_agents': len(unique_agents)
+        })
+    
+    df = pd.DataFrame(data)
+    df.to_csv(output_file, index=False, encoding='utf-8')
+    
+    print(f"✅ Дані експортовано в CSV: {output_file}")
+    print(f"   Всього записів: {len(df)}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Аналіз логів MAI-DX')
+    parser.add_argument('--dir', default='mai_dx_logs', help='Директорія з логами')
+    parser.add_argument('--case', help='ID конкретної сесії для детального аналізу')
+    parser.add_argument('--export-csv', action='store_true', help='Експортувати в CSV')
+    parser.add_argument('--summary', action='store_true', help='Створити зведений HTML звіт')
+    
+    args = parser.parse_args()
+    
+    print("🔬 Аналіз логів MAI-DX")
+    print("=" * 60)
+    
+    # Завантажуємо сесії
+    sessions = load_all_sessions(args.dir)
+    print(f"📁 Знайдено {len(sessions)} сесій в {args.dir}")
+    
+    if args.case:
+        # Аналіз конкретної сесії
+        session = next((s for s in sessions if s['case_id'] == args.case), None)
+        if session:
+            analyze_session(session)
+        else:
+            print(f"❌ Сесія {args.case} не знайдена")
+    elif args.export_csv:
+        # Експорт в CSV
+        export_to_csv(sessions)
+    elif args.summary:
+        # Створення зведеного звіту
+        generate_summary_report(sessions)
+    else:
+        # Загальна статистика
+        if sessions:
+            print(f"\n📊 Загальна статистика:")
+            print(f"  - Середня точність: {sum(s['confidence'] for s in sessions) / len(sessions):.2f}/5.0")
+            print(f"  - Середня вартість: ${sum(s['cost'] for s in sessions) / len(sessions):.2f}")
+            print(f"  - Середній час: {sum(s['duration'] for s in sessions) / len(sessions):.1f} секунд")
+            
+            print(f"\n💡 Для детального аналізу використовуйте:")
+            print(f"  python {__file__} --case <case_id>")
+            print(f"  python {__file__} --export-csv")
+            print(f"  python {__file__} --summary")
+
+if __name__ == "__main__":
+    main()

utils/test_logging.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Тестовий скрипт для перевірки що логування працює коректно
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import json
+from enhanced_mai_dx_logger import MAIDxConversationLogger
+
+def test_basic_logging():
+    """Тест базового логування"""
+    print("🧪 Тест 1: Базове логування")
+    
+    logger = MAIDxConversationLogger("test_logs")
+    
+    # Створюємо тестову сесію
+    case_id = logger.start_session(
+        case_name="Тестовий випадок",
+        patient_info="Тестова інформація",
+        mode="test",
+        budget=1000
+    )
+    
+    print(f"✅ Створено сесію: {case_id}")
+    
+    # Симулюємо захоплення виводу
+    def mock_orchestrator_run(*args, **kwargs):
+        print("Starting Diagnostic Loop 1/3")
+        print("2025-07-11 10:00:00 | INFO | mai_dx.main:_run_panel_deliberation:1304 - 🧠 Dr. Hypothesis analyzing differential diagnosis...")
+        print("╭─── Agent Name Dr. Hypothesis [Max Loops: 1] ───╮")
+        print("│ Analyzing patient symptoms...                   │")
+        print("│ High probability of sepsis                      │")
+        print("╰────────────────────────────────────────────────╯")
+        print("2025-07-11 10:00:05 | INFO | mai_dx.main:run:1689 - ⚕️ Panel decision: DIAGNOSE -> Sepsis")
+        
+        # Симулюємо результат
+        class MockResult:
+            final_diagnosis = "Sepsis"
+            accuracy_score = 4.0
+            total_cost = 500.0
+            
+        return MockResult()
+    
+    # Виконуємо з захопленням
+    result = logger.capture_orchestrator_output(
+        case_id=case_id,
+        orchestrator_func=mock_orchestrator_run
+    )
+    
+    print(f"✅ Діагноз: {result.final_diagnosis}")
+    
+    # Завершуємо сесію
+    saved_id = logger.end_session(
+        case_id=case_id,
+        final_diagnosis=result.final_diagnosis,
+        confidence=result.accuracy_score,
+        cost=result.total_cost,
+        reasoning="Test reasoning"
+    )
+    
+    print(f"✅ Збережено: {saved_id}")
+    
+    # Перевіряємо що файли створені
+    json_file = f"test_logs/{case_id}.json"
+    if os.path.exists(json_file):
+        with open(json_file, 'r') as f:
+            data = json.load(f)
+        print(f"✅ JSON файл містить {len(data['conversations'])} розмов")
+        
+        if data['conversations']:
+            conv = data['conversations'][0]
+            print(f"  - Раунд {conv['round_number']}: {len(conv['messages'])} повідомлень")
+    else:
+        print(f"❌ JSON файл не створено!")
+        
+    print("-" * 60)
+
+def test_conversation_parsing():
+    """Тест парсингу розмов"""
+    print("🧪 Тест 2: Парсинг складних розмов")
+    
+    logger = MAIDxConversationLogger("test_logs")
+    
+    case_id = logger.start_session(
+        case_name="Складний випадок",
+        patient_info="Множинні симптоми",
+        mode="budgeted",
+        budget=5000
+    )
+    
+    # Симулюємо складніший вивід
+    def complex_orchestrator_run(*args, **kwargs):
+        output = """
+2025-07-11 10:00:00 | INFO | mai_dx.main:run:1679 - --- Starting Diagnostic Loop 1/3 ---
+2025-07-11 10:00:00 | INFO | mai_dx.main:run:1682 - Current cost: $300 | Remaining budget: $4,700
+2025-07-11 10:00:01 | INFO | mai_dx.main:_run_panel_deliberation:1304 - 🧠 Dr. Hypothesis analyzing differential diagnosis...
+╭─────────────────────────────── Agent Name Dr. Hypothesis [Max Loops: 1 ] ───────────────────────────────╮
+│ Structured Output - Attempting Function Call Execution [10:00:02]                                       │
+│                                                                                                         │
+│  Top differential diagnoses:                                                                            │
+│  1. Acute Myocardial Infarction (85%)                                                                  │
+│  2. Pulmonary Embolism (10%)                                                                           │
+│  3. Aortic Dissection (5%)                                                                              │
+╰──────────────────────────────────────────────────────────────��──────────────────────────────────────────╯
+
+2025-07-11 10:00:05 | INFO | mai_dx.main:_run_panel_deliberation:1320 - 🔬 Dr. Test-Chooser selecting optimal tests...
+╭────────────────────────────── Agent Name Dr. Test-Chooser [Max Loops: 1 ] ──────────────────────────────╮
+│ Recommending tests:                                                                                      │
+│ - ECG (immediate)                                                                                        │
+│ - Troponin levels                                                                                        │
+│ - Chest X-ray                                                                                            │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+2025-07-11 10:00:10 | INFO | mai_dx.main:run:1689 - ⚕️ Panel decision: TEST -> ECG, Troponin, CXR
+2025-07-11 10:00:10 | INFO | mai_dx.main:run:1692 - 💭 Medical reasoning: High suspicion for cardiac event
+"""
+        print(output)
+        
+        class MockResult:
+            final_diagnosis = "Acute Myocardial Infarction"
+            accuracy_score = 4.5
+            total_cost = 850.0
+            
+        return MockResult()
+    
+    result = logger.capture_orchestrator_output(
+        case_id=case_id,
+        orchestrator_func=complex_orchestrator_run
+    )
+    
+    # Генеруємо HTML
+    html_path = logger.export_conversation_html(case_id)
+    print(f"✅ HTML звіт: {html_path}")
+    
+    # Завершуємо
+    logger.end_session(
+        case_id=case_id,
+        final_diagnosis=result.final_diagnosis,
+        confidence=result.accuracy_score,
+        cost=result.total_cost
+    )
+    
+    print("-" * 60)
+
+def test_error_handling():
+    """Тест обробки помилок"""
+    print("🧪 Тест 3: Обробка помилок")
+    
+    logger = MAIDxConversationLogger("test_logs")
+    
+    # Спроба завершити неіснуючу сесію
+    result = logger.end_session("non_existent_id")
+    print(f"✅ Обробка неіснуючої сесії: {result}")
+    
+    # Спроба отримати розмови неіснуючої сесії
+    conversations = logger.get_session_conversations("non_existent_id")
+    print(f"✅ Розмови неіснуючої сесії: {len(conversations)} елементів")
+    
+    print("-" * 60)
+
+def main():
+    """Запуск всіх тестів"""
+    print("=" * 60)
+    print("🔬 Тестування системи логування MAI-DX")
+    print("=" * 60)
+    
+    # Створюємо тестову директорію
+    os.makedirs("test_logs", exist_ok=True)
+    
+    try:
+        test_basic_logging()
+        test_conversation_parsing()
+        test_error_handling()
+        
+        print("\n✅ Всі тести пройдено успішно!")
+        print("📁 Перевірте директорію 'test_logs' для результатів")
+        
+    except Exception as e:
+        print(f"\n❌ Помилка під час тестування: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

utils/view_conversation.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Скрипт для швидкого перегляду розмов MAI-DX сесії в терміналі
+"""
+
+import os
+import json
+import sys
+import argparse
+from datetime import datetime
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.markdown import Markdown
+
+# Спробуємо імпортувати Rich, якщо немає - використаємо простий вивід
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.syntax import Syntax
+    from rich.markdown import Markdown
+    RICH_AVAILABLE = True
+    console = Console()
+except ImportError:
+    RICH_AVAILABLE = False
+    print("⚠️ Rich не встановлено. Для кращого відображення: pip install rich")
+
+def load_session(case_id, log_dir="mai_dx_logs"):
+    """Завантажити конкретну сесію"""
+    json_path = os.path.join(log_dir, f"{case_id}.json")
+    
+    if not os.path.exists(json_path):
+        # Спробуємо знайти файл з частковим збігом
+        for filename in os.listdir(log_dir):
+            if case_id in filename and filename.endswith('.json'):
+                json_path = os.path.join(log_dir, filename)
+                break
+        else:
+            return None
+            
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"❌ Помилка читання файлу: {e}")
+        return None
+
+def display_session_rich(session):
+    """Відображення сесії з Rich форматуванням"""
+    # Заголовок
+    console.print(Panel.fit(
+        f"[bold blue]MAI-DX Diagnostic Session[/bold blue]\n"
+        f"[dim]{session['case_id']}[/dim]",
+        border_style="blue"
+    ))
+    
+    # Основна інформація
+    info_table = Table(show_header=False, box=None, padding=(0, 2))
+    info_table.add_column(style="bold cyan")
+    info_table.add_column()
+    
+    info_table.add_row("📋 Випадок:", session['case_name'])
+    info_table.add_row("🕐 Час:", session['timestamp'])
+    info_table.add_row("🔧 Режим:", session['mode'])
+    info_table.add_row("💊 Діагноз:", f"[bold yellow]{session['diagnosis']}[/bold yellow]")
+    info_table.add_row("📊 Точність:", f"{session['confidence']}/5.0 {'✅' if session['confidence'] >= 3.0 else '⚠️'}")
+    info_table.add_row("💰 Вартість:", f"${session['cost']} (бюджет: ${session['budget']})")
+    info_table.add_row("⏱️ Тривалість:", f"{session['duration']:.1f} секунд")
+    
+    console.print(info_table)
+    console.print()
+    
+    # Розмови
+    conversations = session.get('conversations', [])
+    if not conversations:
+        console.print("[yellow]⚠️ Розмови не знайдено[/yellow]")
+        return
+        
+    console.print(f"[bold]💬 Розмови ({len(conversations)} раундів):[/bold]\n")
+    
+    for i, conv in enumerate(conversations):
+        # Заголовок раунду
+        console.print(Panel(
+            f"[bold]Раунд {conv['round_number']}[/bold]\n"
+            f"Час: {conv.get('start_time', 'N/A')} - {conv.get('end_time', 'N/A')}\n"
+            f"Повідомлень: {len(conv.get('messages', []))}"
+            + (f"\nРішення: [yellow]{conv['decision']}[/yellow]" if conv.get('decision') else "")
+            + (f"\nВартість: ${conv['cost_incurred']}" if conv.get('cost_incurred') else ""),
+            title=f"[cyan]Раунд {i+1}[/cyan]",
+            border_style="cyan"
+        ))
+        
+        # Повідомлення
+        for msg in conv.get('messages', []):
+            agent_color = {
+                'Dr. Hypothesis': 'blue',
+                'Dr. Test-Chooser': 'green',
+                'Dr. Challenger': 'red',
+                'Dr. Stewardship': 'yellow',
+                'Dr. Checklist': 'magenta',
+                'Consensus Coordinator': 'cyan',
+                'Judge': 'white',
+                'Gatekeeper': 'bright_black'
+            }.get(msg['agent_name'], 'white')
+            
+            msg_type_icon = {
+                'reasoning': '🤔',
+                'decision': '💡',
+                'input': '❓',
+                'output': '📊',
+                'log': '📝'
+            }.get(msg['message_type'], '💬')
+            
+            console.print(
+                f"\n[bold {agent_color}]{msg_type_icon} {msg['agent_name']}[/bold {agent_color}] "
+                f"[dim]({msg['message_type']})[/dim]"
+            )
+            
+            # Обмежуємо довжину контенту для кращого відображення
+            content = msg['content']
+            if len(content) > 500:
+                content = content[:500] + "..."
+                
+            console.print(Panel(
+                content,
+                border_style=agent_color,
+                padding=(0, 1)
+            ))
+
+def display_session_simple(session):
+    """Відображення сесії без Rich"""
+    print("="*60)
+    print(f"MAI-DX Diagnostic Session: {session['case_id']}")
+    print("="*60)
+    
+    print(f"\n📋 Випадок: {session['case_name']}")
+    print(f"🕐 Час: {session['timestamp']}")
+    print(f"💊 Діагноз: {session['diagnosis']}")
+    print(f"📊 Точність: {session['confidence']}/5.0")
+    print(f"💰 Вартість: ${session['cost']} (бюджет: ${session['budget']})")
+    
+    conversations = session.get('conversations', [])
+    if not conversations:
+        print("\n⚠️ Розмови не знайдено")
+        return
+        
+    print(f"\n💬 Розмови ({len(conversations)} раундів):")
+    
+    for i, conv in enumerate(conversations):
+        print(f"\n{'='*40}")
+        print(f"Раунд {conv['round_number']}")
+        print(f"{'='*40}")
+        
+        if conv.get('decision'):
+            print(f"Рішення: {conv['decision']}")
+            
+        for msg in conv.get('messages', []):
+            print(f"\n[{msg['message_type']}] {msg['agent_name']}:")
+            content = msg['content']
+            if len(content) > 300:
+                content = content[:300] + "..."
+            print(content)
+            print("-"*40)
+
+def export_markdown(session, output_file=None):
+    """Експорт розмов в Markdown"""
+    if not output_file:
+        output_file = f"{session['case_id']}_conversation.md"
+        
+    md_content = f"""# MAI-DX Diagnostic Session: {session['case_id']}
+
+## 📋 Інформація про сесію
+
+- **Випадок**: {session['case_name']}
+- **Час**: {session['timestamp']}
+- **Режим**: {session['mode']}
+- **Діагноз**: **{session['diagnosis']}**
+- **Точність**: {session['confidence']}/5.0
+- **Вартість**: ${session['cost']} (бюджет: ${session['budget']})
+- **Тривалість**: {session['duration']:.1f} секунд
+
+## 💬 Розмови
+
+"""
+    
+    for i, conv in enumerate(session.get('conversations', [])):
+        md_content += f"\n### Раунд {conv['round_number']}\n\n"
+        
+        if conv.get('decision'):
+            md_content += f"**Рішення**: {conv['decision']}\n\n"
+            
+        for msg in conv.get('messages', []):
+            md_content += f"\n#### {msg['agent_name']} [{msg['message_type']}]\n\n"
+            md_content += f"{msg['content']}\n\n"
+            md_content += "---\n"
+            
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(md_content)
+        
+    print(f"\n✅ Експортовано в Markdown: {output_file}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Перегляд розмов MAI-DX сесії')
+    parser.add_argument('case_id', help='ID сесії або його частина')
+    parser.add_argument('--dir', default='mai_dx_logs', help='Директорія з логами')
+    parser.add_argument('--simple', action='store_true', help='Простий вивід без Rich')
+    parser.add_argument('--export-md', action='store_true', help='Експортувати в Markdown')
+    parser.add_argument('--raw', action='store_true', help='Показати сирий текст')
+    
+    args = parser.parse_args()
+    
+    # Завантажуємо сесію
+    session = load_session(args.case_id, args.dir)
+    
+    if not session:
+        print(f"❌ Сесія '{args.case_id}' не знайдена в {args.dir}")
+        
+        # Показуємо доступні сесії
+        print("\n📁 Доступні сесії:")
+        for filename in sorted(os.listdir(args.dir)):
+            if filename.endswith('.json') and not filename.endswith('_analytics.json'):
+                print(f"  - {filename[:-5]}")
+        sys.exit(1)
+        
+    # Показуємо сирий текст якщо потрібно
+    if args.raw:
+        raw_file = os.path.join(args.dir, f"{session['case_id']}_raw.txt")
+        if os.path.exists(raw_file):
+            with open(raw_file, 'r', encoding='utf-8') as f:
+                print(f.read())
+        else:
+            print("❌ Файл з сирим текстом не знайдено")
+        return
+        
+    # Експортуємо в Markdown якщо потрібно
+    if args.export_md:
+        export_markdown(session)
+        return
+        
+    # Відображаємо сесію
+    if args.simple or not RICH_AVAILABLE:
+        display_session_simple(session)
+    else:
+        display_session_rich(session)
+
+if __name__ == "__main__":
+    main()