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

enhanced_mai_dx_logger.py

@@ -177,114 +177,90 @@ class MAIDxConversationLogger:
             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 = []
+        current_round: Optional[AgentConversation] = None
+        current_agent: Optional[str] = None
+        buffer: List[str] = []
         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:
+
+        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
-                
-            # Початок нового раунду
+
+            # 1. Перевірка на початок нового раунду
             if "Starting Diagnostic Loop" in line:
-                if current_round and buffer:
-                    # Зберігаємо попередній раунд
-                    self._save_buffered_conversation(session, current_round, buffer)
-                    buffer = []
-                    
-                # Витягуємо номер раунду
+                finalize_round(current_round) # Завершуємо попередній раунд
+                
                 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
-                    
+                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()
                 )
                 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 (\w+\.?\s*\w+)', line)
+                agent_match = re.search(r'Agent Name (.*?) \[', 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
+                    buffer = [] # Очищуємо буфер для нового агента
                 continue
-                
-            # Кінець виводу агента
-            if in_agent_output and ("╰" in line or "└" in line):
-                in_agent_output = False
+
+            # 3. Перевірка на кінець блоку агента
+            elif 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))
-                    buffer = []
-                    current_agent = None
-                continue
                 
-            # Збираємо вміст всередині рамки
-            if in_agent_output and current_agent:
-                # Очищаємо лінію від символів рамки
+                # Скидаємо стан
+                in_agent_output = False
+                current_agent = None
+                buffer = []
+                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.strip():
-                    buffer.append(clean_line.strip())
+                clean_line = re.sub(r'\s*[│|]\s*$', '', clean_line) # Видаляємо символ і в кінці
+                if clean_line: # Додаємо лише непусті рядки
+                    buffer.append(clean_line)
                 continue
-                
-            # Логи від INFO рівня
-            if " | INFO " in line:
-                # Парсимо INFO логи
-                info_match = re.search(r'mai_dx\.main:(\w+):.*? - (.+)', line)
-                if info_match and current_round:
+
+            # 5. Обробка звичайних логів INFO (якщо ми не всередині блоку агента)
+            elif " | 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)
+                    content = info_match.group(2).strip()
                     
-                    # Визначаємо агента з контексту
-                    agent_name = self._extract_agent_from_log(content)
-                    if agent_name:
-                        self._add_agent_message(
-                            current_round, 
-                            agent_name, 
-                            content,
-                            message_type="log"
-                        )
-                        
-                    # Спеціальні маркери
+                    # Обробка ключових INFO-повідомлень
                     if "Panel decision:" in content:
-                        decision_match = re.search(r'Panel decision: (\w+) -> (.+)', 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:
+                    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 "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()
-            
+        
+        # Завершуємо останній раунд після виходу з циклу
+        finalize_round(current_round)
+
     def _extract_agent_from_log(self, log_content: str) -> Optional[str]:
         """Витягти ім'я агента з лог повідомлення"""
         agent_patterns = {
@@ -340,23 +316,80 @@ class MAIDxConversationLogger:
         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
+
+        formatted_content = ""
+        original_content = content
+
+        # Перевіряємо, чи це структурований вивід з викликом функції
+        if "Structured Output - Attempting Function Call Execution" in content:
+            message_type = "function_call"
             
-        if not message_type:
-            message_type = self._determine_message_type(agent_name, content)
-        
+            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"
+
+            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```"
+
+                except json.JSONDecodeError:
+                    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)
+
         message = AgentMessage(
             timestamp=datetime.now().isoformat(),
             agent_name=agent_name,
             message_type=message_type,
-            content=content.strip(),
-            metadata={}
+            content=formatted_content.strip(),
+            metadata={'raw_content': original_content}
         )
         
         conversation.messages.append(message)
-        
+
     def _determine_message_type(self, agent_name: str, content: str) -> str:
         """Визначити тип повідомлення"""
         content_lower = content.lower()
@@ -376,10 +409,10 @@ class MAIDxConversationLogger:
             conversation.end_time = datetime.now().isoformat()
             # Можна додати додаткову обробку
             
-    def end_session(self, case_id: str, **kwargs) -> str:
-        """Завершити сесію та зберегти всі дані"""
+    # У файлі enhanced_mai_dx_logger.py
+    def end_session(self, case_id: str, **kwargs) -> Optional[DiagnosisSession]:
         if case_id not in self.sessions:
-            return "no_active_session"
+            return None
             
         session = self.sessions[case_id]
         
@@ -396,9 +429,9 @@ class MAIDxConversationLogger:
         
         # Зберігаємо у файл
         self._save_session_to_file(session)
-        
-        del self.sessions[case_id]
-        return case_id
+
+        del self.sessions[case_id]  
+        return session
         
     def _save_session_to_file(self, session: DiagnosisSession):
         """Зберегти сесію у JSON файл з повною структурою"""

updated_mai_dx_interface.py

@@ -37,7 +37,7 @@ except ImportError:
         IMPORT_ERROR = str(e)
 
 # Імпорт покращеного логгера
-from enhanced_mai_dx_logger import MAIDxConversationLogger, DiagnosisSession
+from enhanced_mai_dx_logger import MAIDxConversationLogger, DiagnosisSession, AgentConversation
 
 # Перевірка доступності Plotly
 try:
@@ -111,17 +111,12 @@ class UpdatedMAIDXInterface:
         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"
-        
+        session: Optional[DiagnosisSession] = None
+             
         try:
             progress(0.1, desc="🚀 Ініціалізація...")
             
-            # Створюємо сесію
+            # Створюємо сесію логування, якщо увімкнено
             if enable_logging:
                 case_id = self.conversation_logger.start_session(
                     case_name=case_name,
@@ -129,7 +124,7 @@ class UpdatedMAIDXInterface:
                     mode=mode,
                     budget=budget
                 )
-                conversation_log += f"📝 Розпочато логування: {case_id}\n\n"
+                conversation_log += f"📝 Розпочато логування сесії: {case_id}\n\n"
             
             progress(0.2, desc="🤖 Створення AI-панелі...")
             
@@ -144,7 +139,7 @@ class UpdatedMAIDXInterface:
             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,
@@ -153,31 +148,6 @@ class UpdatedMAIDXInterface:
                     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(
@@ -189,48 +159,73 @@ class UpdatedMAIDXInterface:
             duration = time.time() - start_time
             progress(0.9, desc="📊 Обробка результатів...")
             
-            # Завершуємо сесію
+            # Завершуємо сесію і отримуємо фінальний, заповнений об'єкт сесії
             if enable_logging and case_id:
-                saved_case_id = self.conversation_logger.end_session(
+                session = 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)
+            # Якщо логування було вимкнене або щось пішло не так,
+            # створюємо об'єкт сесії вручну для відображення
+            if not session:
+                session = DiagnosisSession(
+                    case_id=case_id or "no_logging",
+                    timestamp=datetime.now().isoformat(),
+                    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')
+                )
             
+            # Тепер, коли у нас є гарантовано існуючий об'єкт 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,
+                        '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:
+                        self.current_metrics.add_cost_point(conv.cost_incurred)
+
             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),
@@ -242,20 +237,15 @@ class UpdatedMAIDXInterface:
             )
             
         except Exception as e:
-            error_msg = f"❌ Помилка діагностики: {str(e)}"
+            import traceback
+            traceback.print_exc() # Друкуємо повний traceback у консоль для налагодження
+            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
+                error_msg += f"\n🗂️ ID сесії: {case_id}"
+            return self._format_error(error_msg)           
     
-    def _format_structured_conversations(self, case_id: str) -> str:
+    def _format_structured_conversations(self, conversations: List[AgentConversation]) -> str:
         """Форматує структуровані розмови у читабельний вигляд"""
-        conversations = self.conversation_logger.get_session_conversations(case_id)
-        
         if not conversations:
             return "📭 Розмови не знайдено"
         
@@ -263,19 +253,25 @@ class UpdatedMAIDXInterface:
         
         for conv in conversations:
             output += f"### 🔄 Раунд {conv.round_number}\n"
-            output += f"**Час:** {conv.start_time} - {conv.end_time or 'В процесі'}\n\n"
+            if conv.start_time and conv.end_time:
+                 output += f"**Час:** {conv.start_time} - {conv.end_time}\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"
-                output += f"```\n{msg.content[:500]}{'...' if len(msg.content) > 500 else ''}\n```\n\n"
-            
+                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"
+
             if conv.decision:
                 output += f"**🎯 Рішення:** {conv.decision}\n"