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

enhanced_mai_dx_logger.py

@@ -14,34 +14,26 @@ 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'
+    message_type: str
     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
@@ -56,88 +48,43 @@ class DiagnosisSession:
     status: str = "In Progress"
     reasoning: str = "N/A"
     conversations: List[AgentConversation] = field(default_factory=list)
-    raw_output: str = ""  # Повний сирий вивід
+    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
+    def __enter__(self):
         sys.stdout = self
-        sys.stderr = self
+        return self
         
-        # Перехоплення логів
-        self._setup_logging_capture()
-        
-    def stop_capture(self):
-        """Зупинити захоплення виводу"""
-        self.is_capturing = False
+    def __exit__(self, exc_type, exc_val, exc_tb):
         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)  # Дублюємо на консоль
+        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)
-        
+    def get_value(self):
+        return self._strip_ansi_codes(self.captured_output.getvalue())
+
     @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:
-        """Розпочати нову діагностичну сесію"""
+    def create_session(self, case_name: str, patient_info: str, mode: str, budget: int) -> DiagnosisSession:
         case_id = f"case_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:6]}"
-        session = DiagnosisSession(
+        return DiagnosisSession(
             case_id=case_id,
             timestamp=datetime.now().isoformat(),
             case_name=case_name,
@@ -145,405 +92,117 @@ class MAIDxConversationLogger:
             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]
+    def finalize_and_save_session(self, session: DiagnosisSession, result: Any, raw_output: str, duration: float) -> DiagnosisSession:
+        session.raw_output = raw_output
+        self._parse_captured_output(session, raw_output)
         
-        # Розпочинаємо захоплення
-        self.output_capture.start_capture()
+        session.diagnosis = getattr(result, 'final_diagnosis', 'N/A')
+        session.confidence = getattr(result, 'accuracy_score', 0.0)
+        session.cost = getattr(result, 'total_cost', 0.0)
+        session.reasoning = getattr(result, 'accuracy_reasoning', 'N/A')
+        session.iterations = len(session.conversations)
+        session.status = "✅ Успішно" if session.confidence >= 3.0 else "⚠️ Потребує перегляду"
+        session.duration = duration
         
-        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]
+        self._save_session_to_file(session)
+        self.export_conversation_html(session)
+        return session
+
+    def _parse_captured_output(self, session: DiagnosisSession, captured_text: str):
         lines = captured_text.split('\n')
-        
         current_round: Optional[AgentConversation] = None
         current_agent: Optional[str] = None
         buffer: List[str] = []
         in_agent_output = False
         round_number = 0
 
-        def finalize_round(round_obj: Optional[AgentConversation]):
-            """Завершити поточний раунд, якщо він існує."""
-            if round_obj and not round_obj.end_time:
-                round_obj.end_time = datetime.now().isoformat()
-
         for line in lines:
             stripped_line = line.strip()
-            if not stripped_line or "rich.errors.NotRenderableError" in line or "Exception in thread" in line:
-                continue
+            if not stripped_line: continue
 
-            # 1. Перевірка на початок нового раунду
             if "Starting Diagnostic Loop" in line:
-                finalize_round(current_round) # Завершуємо попередній раунд
-                
+                if current_round: current_round.end_time = datetime.now().isoformat()
                 round_match = re.search(r'Starting Diagnostic Loop (\d+)/\d+', line)
                 round_number = int(round_match.group(1)) if round_match else round_number + 1
-                
-                current_round = AgentConversation(
-                    round_number=round_number,
-                    start_time=datetime.now().isoformat()
-                )
+                current_round = AgentConversation(round_number=round_number, start_time=datetime.now().isoformat())
                 session.conversations.append(current_round)
                 continue
 
-            # 2. Перевірка на початок блоку агента
             if "Agent Name" in line and ("╭" in line or "┌" in line):
                 agent_match = re.search(r'Agent Name (.*?) \[', line)
                 if agent_match:
                     current_agent = agent_match.group(1).strip()
                     in_agent_output = True
-                    buffer = [] # Очищуємо буфер для нового агента
+                    buffer = []
                 continue
 
-            # 3. Перевірка на кінець блоку агента
-            elif in_agent_output and ("╰" in line or "└" in line):
+            if in_agent_output and ("╰" in line or "└" in line):
                 if buffer and current_agent and current_round:
                     self._add_agent_message(current_round, current_agent, '\n'.join(buffer))
-                
-                # Скидаємо стан
-                in_agent_output = False
-                current_agent = None
-                buffer = []
+                in_agent_output, current_agent, buffer = False, None, []
                 continue
 
-            # 4. Збір вмісту всередині блоку агента
-            elif 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: # Додаємо лише непусті рядки
-                    buffer.append(clean_line)
+            if in_agent_output:
+                clean_line = re.sub(r'^[│|]\s*|\s*[│|]\s*$', '', line)
+                if clean_line: buffer.append(clean_line)
                 continue
 
-            # 5. Обробка звичайних логів INFO (якщо ми не всередині блоку агента)
-            elif " | INFO " in line and current_round:
+            if " | INFO " in line and current_round:
                 info_match = re.search(r'mai_dx\.main:([^:]+):.*? - (.*)', line)
                 if info_match:
-                    action = info_match.group(1)
                     content = info_match.group(2).strip()
-                    
-                    # Обробка ключових INFO-повідомлень
                     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 decision_match: current_round.decision = f"{decision_match.group(1)}: {decision_match.group(2)}"
                     elif "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 cost_match: current_round.cost_incurred = float(cost_match.group(1))
         
-        # Завершуємо останній раунд після виходу з циклу
-        finalize_round(current_round)
+        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):
-        """Додати повідомлення агента до розмови з надійним парсингом JSON."""
-        import re
-        import json
-
-        if not conversation or not content.strip():
-            return
+    def _add_agent_message(self, conversation: AgentConversation, agent_name: str, content: str):
+        message_type = "output"
+        formatted_content = content.strip()
 
-        formatted_content = ""
-        original_content = content
-
-        # Перевіряємо, чи це структурований вивід з викликом функції
         if "Structured Output - Attempting Function Call Execution" in content:
             message_type = "function_call"
-            
             func_name_match = re.search(r"name:\s*(\w+)", content)
-            func_name = func_name_match.group(1) if func_name_match else "unknown_function"
-
-            # Надійний regex для витягнення JSON, що працює з багаторядковим текстом
-            # і стандартним модулем 're'. Він шукає блок, що починається з "arguments: {"
-            # і закінчується на "}" перед "name:".
-            args_match = re.search(r"arguments:\s*(\{.*?\})\s*,\s*\"name\":", content, re.DOTALL)
-            # Альтернативний варіант, якщо "name" не знайдено
-            if not args_match:
-                 args_match = re.search(r"arguments:\s*(\{.*\})", content, re.DOTALL)
-
-
-            formatted_content = f"🤖 **Дія:** Виклик функції `{func_name}`\n\n"
-
+            func_name = func_name_match.group(1) if func_name_match else "unknown"
+            args_match = re.search(r"arguments:\s*(\{.*\})", content, re.DOTALL)
+            formatted_content = f"🤖 **Дія:** `{func_name}`\n\n"
             if args_match:
                 try:
-                    json_str = args_match.group(1)
-                    args_data = json.loads(json_str)
-                    
-                    if func_name in ['update_differential_diagnosis', 'UpdateDifferentialDiagnosisDifferentialDiagnoses']:
-                        formatted_content += f"**Резюме:** {args_data.get('summary', 'N/A')}\n"
-                        if 'differential_diagnoses' in args_data:
-                            formatted_content += "**Основний діагноз:**\n"
-                            for diag in args_data.get('differential_diagnoses', []):
-                                prob = diag.get('probability', 0) * 100
-                                formatted_content += f"- {diag.get('diagnosis')} ({prob:.0f}%)\n"
-                        else: # Обробка іншого формату
-                            prob = args_data.get('probability', 0) * 100
-                            formatted_content += f"- {args_data.get('diagnosis')} ({prob:.0f}%)\n"
-
-
-                    elif func_name == 'make_consensus_decision':
-                        formatted_content += f"**Рішення:** {args_data.get('content', 'N/A')}\n"
-                        formatted_content += f"**Обґрунтування:** {args_data.get('reasoning', 'N/A')}"
-                    
-                    else:
-                        formatted_content += "**Аргументи:**\n"
-                        formatted_content += f"```json\n{json.dumps(args_data, indent=2, ensure_ascii=False)}\n```"
-
+                    args_data = json.loads(args_match.group(1))
+                    formatted_content += f"```json\n{json.dumps(args_data, indent=2, ensure_ascii=False)}\n```"
                 except json.JSONDecodeError:
-                    formatted_content += "Помилка парсингу JSON аргументів."
+                    formatted_content += "Помилка парсингу JSON."
             else:
-                formatted_content += "Не вдалося витягти аргументи з блоку."
-
-        else:
-            # Це звичайне текстове повідомлення
-            formatted_content = content.strip()
-            if not message_type:
-                message_type = self._determine_message_type(agent_name, formatted_content)
-
+                formatted_content += "Аргументи не знайдено."
+        
         message = AgentMessage(
-            timestamp=datetime.now().isoformat(),
-            agent_name=agent_name,
-            message_type=message_type,
-            content=formatted_content.strip(),
-            metadata={'raw_content': original_content}
+            datetime.now().isoformat(), agent_name, message_type, formatted_content, {'raw_content': content}
         )
-        
         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()
-            # Можна додати додаткову обробку
-            
-    # У файлі enhanced_mai_dx_logger.py
-    def end_session(self, case_id: str, **kwargs) -> Optional[DiagnosisSession]:
-        if case_id not in self.sessions:
-            return None
-            
-        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 session
         
     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)
+            json.dump(asdict(session), 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>
-"""
-            
+    def export_conversation_html(self, session: DiagnosisSession) -> str:
+        html_path = os.path.join(self.log_dir, f"{session.case_id}_conversation.html")
+        html_content = f"<html><head><title>Log - {session.case_id}</title></head><body>"
+        html_content += f"<h1>Session: {session.case_id}</h1>"
+        for conv in session.conversations:
+            html_content += f"<h2>Round {conv.round_number}</h2>"
             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")
+                html_content += f"<div><b>{msg.agent_name}</b> [{msg.message_type}]:<pre>{msg.content}</pre></div>"
+        html_content += "</body></html>"
         with open(html_path, 'w', encoding='utf-8') as f:
             f.write(html_content)
-            
         return html_path

run_mai_dx_fixed.py

@@ -12,8 +12,8 @@ import warnings
 os.environ.update({
     "SWARMS_VERBOSITY": "ERROR",
     "RICH_TRACEBACK": "0", 
-    "SWARMS_SHOW_PANEL": "true",
-    "SWARMS_AUTO_PRINT": "true",
+    "SWARMS_SHOW_PANEL": "false",
+    "SWARMS_AUTO_PRINT": "false",
     "PYTHONWARNINGS": "ignore",
     "GRADIO_ANALYTICS_ENABLED": "false"
 })
@@ -60,7 +60,7 @@ def main():
         demo.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=False,
+            share=True,
             debug=False,
             show_error=True,
             quiet=False

updated_mai_dx_interface.py

@@ -17,8 +17,8 @@ import warnings
 os.environ.update({
     "SWARMS_VERBOSITY": "ERROR",
     "RICH_TRACEBACK": "0", 
-    "SWARMS_SHOW_PANEL": "true",
-    "SWARMS_AUTO_PRINT": "true"
+    "SWARMS_SHOW_PANEL": "false",
+    "SWARMS_AUTO_PRINT": "false"
 })
 warnings.filterwarnings("ignore")
 
@@ -37,7 +37,7 @@ except ImportError:
         IMPORT_ERROR = str(e)
 
 # Імпорт покращеного логгера
-from enhanced_mai_dx_logger import MAIDxConversationLogger, DiagnosisSession, AgentConversation
+from enhanced_mai_dx_logger import MAIDxConversationLogger, DiagnosisSession
 
 # Перевірка доступності Plotly
 try:
@@ -100,8 +100,7 @@ class UpdatedMAIDXInterface:
         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(): 
@@ -118,17 +117,20 @@ class UpdatedMAIDXInterface:
             
             # Створюємо сесію логування, якщо увімкнено
             if enable_logging:
-                case_id = self.conversation_logger.start_session(
+                # ВИПРАВЛЕННЯ ТУТ: Використовуємо create_session
+                session = self.conversation_logger.create_session(
                     case_name=case_name,
                     patient_info=patient_info,
                     mode=mode,
                     budget=budget
                 )
+                case_id = session.case_id
                 conversation_log += f"📝 Розпочато логування сесії: {case_id}\n\n"
             
             progress(0.2, desc="🤖 Створення AI-панелі...")
             
-            # Створюємо orchestrator
+            # ... решта коду методу залишається без змін ...
+            
             orchestrator = MaiDxOrchestrator(
                 model_name=model_name, 
                 max_iterations=max_iterations, 
@@ -149,7 +151,6 @@ class UpdatedMAIDXInterface:
                     ground_truth_diagnosis=expected_diagnosis or "Unknown"
                 )
             else:
-                # Виконуємо без логування
                 result = orchestrator.run(
                     initial_case_info=patient_info,
                     full_case_details=patient_info,
@@ -159,8 +160,8 @@ class UpdatedMAIDXInterface:
             duration = time.time() - start_time
             progress(0.9, desc="📊 Обробка результатів...")
             
-            # Завершуємо сесію і отримуємо фінальний, заповнений об'єкт сесії
             if enable_logging and case_id:
+                # ВАЖЛИВО: Отримуємо об'єкт сесії з пам'яті логера, а не створюємо новий
                 session = self.conversation_logger.end_session(
                     case_id=case_id,
                     final_diagnosis=result.final_diagnosis,
@@ -169,9 +170,7 @@ class UpdatedMAIDXInterface:
                     reasoning=getattr(result, 'accuracy_reasoning', 'N/A')
                 )
             
-            # Якщо логування було вимкнене або щось пішло не так,
-            # створюємо об'єкт сесії вручну для відображення
-            if not session:
+            if not session: # Резервний варіант, якщо логування було вимкнене
                 session = DiagnosisSession(
                     case_id=case_id or "no_logging",
                     timestamp=datetime.now().isoformat(),
@@ -188,25 +187,18 @@ class UpdatedMAIDXInterface:
                     reasoning=getattr(result, 'accuracy_reasoning', 'N/A')
                 )
             
-            # Тепер, коли у нас є гарантовано існуючий об'єкт session,
-            # ми можемо заповнити решту даних для виводу
             if session:
                 self.sessions_history.append(session)
-                
-                # Додаємо сирий вивід у лог інтерфейсу
                 conversation_log += "🤖 Повний сирий вивід системи:\n" + "="*60 + "\n"
                 conversation_log += session.raw_output + "\n" + "="*60 + "\n\n"
                 conversation_log += f"💾 Сесію збережено як: {session.case_id}\n"
                 
-                # Генеруємо HTML звіт і додаємо посилання
                 if enable_logging:
                     html_path = self.conversation_logger.export_conversation_html(session.case_id)
                     conversation_log += f"📄 HTML звіт: {html_path}\n"
                 
-                # Форматуємо структуровані розмови, передаючи список напряму
                 structured_conversations = self._format_structured_conversations(session.conversations)
                 
-                # Оновлюємо метрики з розмов
                 for conv in session.conversations:
                     self.current_metrics.add_conversation_round({
                         'round': conv.round_number,
@@ -221,11 +213,9 @@ class UpdatedMAIDXInterface:
 
             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),
@@ -238,14 +228,16 @@ class UpdatedMAIDXInterface:
             
         except Exception as e:
             import traceback
-            traceback.print_exc() # Друкуємо повний traceback у консоль для налагодження
+            traceback.print_exc()
             error_msg = f"❌ Критична помилка діагностики: {str(e)}"
             if case_id: 
                 error_msg += f"\n🗂️ ID сесії: {case_id}"
-            return self._format_error(error_msg)           
-    
-    def _format_structured_conversations(self, conversations: List[AgentConversation]) -> str:
+            return self._format_error(error_msg)
+
+    def _format_structured_conversations(self, case_id: str) -> str:
         """Форматує структуровані розмови у читабельний вигляд"""
+        conversations = self.conversation_logger.get_session_conversations(case_id)
+        
         if not conversations:
             return "📭 Розмови не знайдено"
         
@@ -253,25 +245,19 @@ class UpdatedMAIDXInterface:
         
         for conv in conversations:
             output += f"### 🔄 Раунд {conv.round_number}\n"
-            if conv.start_time and conv.end_time:
-                 output += f"**Час:** {conv.start_time} - {conv.end_time}\n\n"
+            output += f"**Час:** {conv.start_time} - {conv.end_time or 'В процесі'}\n\n"
             
             for msg in conv.messages:
                 emoji = {
-                    'function_call': '🤖',
                     'reasoning': '🤔',
                     'decision': '💡',
                     'input': '❓',
                     'output': '📊'
                 }.get(msg.message_type, '💬')
                 
-                output += f"{emoji} **{msg.agent_name}** `[{msg.message_type}]`\n"
-                # Використовуємо Markdown-блоки для кращого відображення
-                if msg.message_type == 'function_call':
-                    output += f"{msg.content}\n\n"
-                else:
-                    output += f"```\n{msg.content}\n```\n\n"
-
+                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"
             
@@ -598,14 +584,14 @@ def create_updated_gradio_interface():
                         
                         model_name = gr.Dropdown(
                             choices=[
-                                "gemini/gemini-2.5-flash", 
+                                "gemini/gemini-1.5-flash", 
                                 "gpt-4", 
                                 "gpt-4-turbo", 
                                 "claude-3-5-sonnet",
                                 "gpt-4o"
                             ],
                             label="🤖 LLM Модель",
-                            value="gemini/gemini-2.5-flash",
+                            value="gemini/gemini-1.5-flash",
                             interactive=True
                         )