import time from typing import Dict, Any, List, Optional from agent_system.recipient import RecipientAgent from agent_system.triager import TriageAgent from agent_system.monitor import Monitor from agent_system.controller import TaskController from agent_system.prompter import Prompter from agent_system.inquirer import Inquirer from agent_system.virtual_patient import VirtualPatientAgent from agent_system.evaluetor import Evaluator from .task_manager import TaskManager, TaskPhase from .workflow_logger import WorkflowLogger class StepExecutor: """ 单step执行器 负责执行单个step中的完整agent pipeline流程 """ # 全局变量存储历史评分 _global_historical_scores = { "clinical_inquiry": 0.0, "communication_quality": 0.0, "multi_round_consistency": 0.0, "overall_professionalism": 0.0, "present_illness_similarity": 0.0, "past_history_similarity": 0.0, "chief_complaint_similarity": 0.0 } @classmethod def reset_historical_scores(cls): """重置全局历史评分""" cls._global_historical_scores = { "clinical_inquiry": 0.0, "communication_quality": 0.0, "multi_round_consistency": 0.0, "overall_professionalism": 0.0, "present_illness_similarity": 0.0, "past_history_similarity": 0.0, "chief_complaint_similarity": 0.0 } def __init__(self, model_type: str = "gpt-oss:latest", llm_config: dict = None): """ 初始化step执行器 Args: model_type: 使用的语言模型类型 llm_config: 语言模型配置 """ self.model_type = model_type self.llm_config = llm_config or {} # 初始化所有agent self.recipient = RecipientAgent(model_type=model_type, llm_config=self.llm_config) self.triager = TriageAgent(model_type=model_type, llm_config=self.llm_config) self.monitor = Monitor(model_type=model_type, llm_config=self.llm_config) self.controller = TaskController(model_type=model_type, llm_config=self.llm_config) self.prompter = Prompter(model_type=model_type, llm_config=self.llm_config) self.virtual_patient = VirtualPatientAgent(model_type=model_type, llm_config=self.llm_config) self.evaluator = Evaluator(model_type=model_type, llm_config=self.llm_config) def execute_step(self, step_num: int, case_data: Dict[str, Any], task_manager: TaskManager, logger: WorkflowLogger, conversation_history: str = "", previous_hpi: str = "", previous_ph: str = "", previous_chief_complaint: str = "", is_first_step: bool = False, doctor_question: str = "") -> Dict[str, Any]: """ 执行单个step的完整流程 Args: step_num: step编号 case_data: 病例数据 task_manager: 任务管理器 logger: 日志记录器 conversation_history: 对话历史 previous_hpi: 上轮现病史 previous_ph: 上轮既往史 previous_chief_complaint: 上轮主诉 is_first_step: 是否为第一个step doctor_question: 医生问题（非首轮时） Returns: Dict: step执行结果，包含更新后的病史信息、医生问题、患者回应等 """ step_result = { "step_number": step_num, "success": False, "patient_response": "", "updated_hpi": previous_hpi, "updated_ph": previous_ph, "updated_chief_complaint": previous_chief_complaint, "triage_result": { "primary_department": "", "secondary_department": "", "triage_reasoning": "" }, "doctor_question": "", "conversation_history": conversation_history, "task_completion_summary": {}, "errors": [] } try: # 更新任务管理器的当前步骤 task_manager.current_step = step_num # Step 1: 获取患者回应 patient_response = self._get_patient_response( step_num, case_data, logger, is_first_step, doctor_question ) step_result["patient_response"] = patient_response # 更新对话历史 if is_first_step: updated_conversation = f"患者: {patient_response}" else: updated_conversation = conversation_history + f"\n医生: {doctor_question}\n患者: {patient_response}" step_result["conversation_history"] = updated_conversation # Step 2: 使用Recipient更新病史信息 recipient_result = self._execute_recipient( step_num, logger, updated_conversation, previous_hpi, previous_ph, previous_chief_complaint ) step_result.update({ "updated_hpi": recipient_result.updated_HPI, "updated_ph": recipient_result.updated_PH, "updated_chief_complaint": recipient_result.chief_complaint }) # Step 3: 使用Triager进行科室分诊（仅当当前阶段是分诊阶段时） current_phase = task_manager.get_current_phase() if current_phase == TaskPhase.TRIAGE: # 当前处于分诊阶段 triage_result = self._execute_triager( step_num, logger, recipient_result ) step_result["triage_result"] = { "primary_department": triage_result.primary_department, "secondary_department": triage_result.secondary_department, "triage_reasoning": triage_result.triage_reasoning } else: # 分诊已完成或已超过分诊阶段，使用已有的分诊结果 existing_triage = step_result.get("triage_result", {}) step_result["triage_result"] = { "primary_department": existing_triage.get("primary_department", "未知"), "secondary_department": existing_triage.get("secondary_department", "未知"), "triage_reasoning": existing_triage.get("triage_reasoning", "分诊已完成") } # Step 4: 使用Monitor评估任务完成度 monitor_results = self._execute_monitor_by_phase( step_num, logger, task_manager, recipient_result, step_result.get("triage_result", {}) ) # Step 5: 更新任务分数 self._update_task_scores(step_num, logger, task_manager, monitor_results) # Step 6: 使用Controller选择下一个任务 controller_result = self._execute_controller( step_num, logger, task_manager, recipient_result ) # Step 7: 使用Prompter生成询问策略 prompter_result = self._execute_prompter( step_num, logger, recipient_result, controller_result ) # Step 8: 使用Inquirer生成医生问题 doctor_question = self._execute_inquirer( step_num, logger, recipient_result, prompter_result ) step_result["doctor_question"] = doctor_question # Step 9: 使用Evaluator进行评分 evaluator_result = self._execute_evaluator( step_num, logger, case_data, step_result ) step_result["evaluator_result"] = evaluator_result # Step 10: 获取任务完成情况摘要 step_result["task_completion_summary"] = task_manager.get_completion_summary() step_result["success"] = True except Exception as e: error_msg = f"Step {step_num} 执行失败: {str(e)}" step_result["errors"].append(error_msg) logger.log_error(step_num, "step_execution_error", error_msg, {"case_data": case_data}) print(error_msg) return step_result def _get_patient_response(self, step_num: int, case_data: Dict[str, Any], logger: WorkflowLogger, is_first_step: bool, doctor_question: str = "") -> str: """获取虚拟患者的回应""" start_time = time.time() try: # 构建虚拟患者输入 if is_first_step: worker_inquiry = "您好，请问您哪里不舒服？" else: worker_inquiry = doctor_question # 调用虚拟患者agent patient_result = self.virtual_patient.run( worker_inquiry=worker_inquiry, is_first_epoch=is_first_step, patient_case=case_data ) execution_time = time.time() - start_time patient_response = patient_result.current_chat # 记录日志 logger.log_agent_execution( step_num, "virtual_patient", { "worker_inquiry": worker_inquiry, "is_first_epoch": is_first_step, "case_data": case_data }, {"patient_response": patient_response}, execution_time ) logger.log_patient_response(step_num, patient_response, is_first_step) return patient_response except Exception as e: error_msg = f"虚拟患者执行失败: {str(e)}" logger.log_error(step_num, "virtual_patient_error", error_msg) # 返回默认回应 return "对不起，我不太清楚怎么描述，医生您看着办吧。" def _execute_recipient(self, step_num: int, logger: WorkflowLogger, conversation_history: str, previous_hpi: str, previous_ph: str, previous_chief_complaint: str): """执行Recipient agent""" start_time = time.time() input_data = { "conversation_history": conversation_history, "previous_HPI": previous_hpi, "previous_PH": previous_ph, "previous_chief_complaint": previous_chief_complaint } result = self.recipient.run(**input_data) execution_time = time.time() - start_time output_data = { "updated_HPI": result.updated_HPI, "updated_PH": result.updated_PH, "chief_complaint": result.chief_complaint } logger.log_agent_execution(step_num, "recipient", input_data, output_data, execution_time) return result def _execute_triager(self, step_num: int, logger: WorkflowLogger, recipient_result): """执行Triage agent进行科室分诊""" start_time = time.time() input_data = { "chief_complaint": recipient_result.chief_complaint, "hpi_content": recipient_result.updated_HPI, "ph_content": recipient_result.updated_PH } result = self.triager.run(**input_data) execution_time = time.time() - start_time output_data = { "primary_department": result.primary_department, "secondary_department": result.secondary_department, "triage_reasoning": result.triage_reasoning } logger.log_agent_execution(step_num, "triager", input_data, output_data, execution_time) return result def _execute_monitor_by_phase(self, step_num: int, logger: WorkflowLogger, task_manager: TaskManager, recipient_result, triage_result: Dict[str, Any] = None) -> Dict[str, Dict[str, float]]: """按阶段执行Monitor评估，只评估当前阶段未完成的任务""" monitor_results = {} current_phase = task_manager.get_current_phase() # 如果所有任务都完成了，不需要评估 if current_phase == TaskPhase.COMPLETED: return monitor_results # 获取当前阶段未完成的任务 pending_tasks = task_manager.get_pending_tasks(current_phase) if not pending_tasks: return monitor_results start_time = time.time() try: # 使用for循环逐个评估所有未完成的任务 phase_scores = {} for task in pending_tasks: task_name = task.get("name", "") task_description = task.get("description", "") # 调用Monitor评估特定任务 # 分诊阶段传入triage_result，其他阶段不传入 if current_phase == TaskPhase.TRIAGE: # 使用传入的triage_result monitor_result = self.monitor.run( hpi_content=recipient_result.updated_HPI, ph_content=recipient_result.updated_PH, chief_complaint=recipient_result.chief_complaint, task_name=task_name, task_description=task_description, triage_result=triage_result if triage_result and triage_result.get("primary_department") else None ) else: # 现病史/既往史阶段不传入triage_result monitor_result = self.monitor.run( hpi_content=recipient_result.updated_HPI, ph_content=recipient_result.updated_PH, chief_complaint=recipient_result.chief_complaint, task_name=task_name, task_description=task_description ) phase_scores[task_name] = monitor_result.completion_score print(f"任务'{task_name}'评分: {monitor_result.completion_score:.2f} - {monitor_result.reason}") execution_time = time.time() - start_time monitor_results[current_phase] = phase_scores # 记录日志 input_data = { "hpi_content": recipient_result.updated_HPI, "ph_content": recipient_result.updated_PH, "chief_complaint": recipient_result.chief_complaint, "evaluated_phase": current_phase.value, "pending_tasks": [t["name"] for t in pending_tasks] } output_data = { "phase_scores": phase_scores, "evaluated_tasks": list(phase_scores.keys()), "average_score": sum(phase_scores.values()) / len(phase_scores) if phase_scores else 0.0 } logger.log_agent_execution(step_num, "monitor", input_data, output_data, execution_time) except Exception as e: error_msg = f"Monitor执行失败: {str(e)}" logger.log_error(step_num, "monitor_error", error_msg) # 返回默认的低分评估 phase_scores = {task["name"]: 0.1 for task in pending_tasks} monitor_results[current_phase] = phase_scores return monitor_results def _update_task_scores(self, step_num: int, logger: WorkflowLogger, task_manager: TaskManager, monitor_results: Dict): """更新任务分数""" for phase, scores in monitor_results.items(): if scores: old_scores = task_manager.get_task_scores(phase).copy() task_manager.update_task_scores(phase, scores) new_scores = task_manager.get_task_scores(phase) logger.log_task_scores_update(step_num, phase.value, old_scores, new_scores) def _execute_controller(self, step_num: int, logger: WorkflowLogger, task_manager: TaskManager, recipient_result): """执行Controller agent""" start_time = time.time() # 获取当前阶段的未完成任务 current_phase = task_manager.get_current_phase() pending_tasks = task_manager.get_pending_tasks(current_phase) input_data = { "pending_tasks": pending_tasks, "chief_complaint": recipient_result.chief_complaint, "hpi_content": recipient_result.updated_HPI, "ph_content": recipient_result.updated_PH } result = self.controller.run(**input_data) execution_time = time.time() - start_time output_data = { "selected_task": result.selected_task, "specific_guidance": result.specific_guidance } logger.log_agent_execution(step_num, "controller", input_data, output_data, execution_time) return result def _execute_prompter(self, step_num: int, logger: WorkflowLogger, recipient_result, controller_result): """执行Prompter agent""" start_time = time.time() input_data = { "hpi_content": recipient_result.updated_HPI, "ph_content": recipient_result.updated_PH, "chief_complaint": recipient_result.chief_complaint, "current_task": controller_result.selected_task, "specific_guidance": controller_result.specific_guidance } result = self.prompter.run(**input_data) execution_time = time.time() - start_time output_data = { "description": result.description, "instructions": result.instructions } logger.log_agent_execution(step_num, "prompter", input_data, output_data, execution_time) return result def _execute_inquirer(self, step_num: int, logger: WorkflowLogger, recipient_result, prompter_result) -> str: """执行Inquirer agent""" start_time = time.time() try: # 使用Prompter生成的描述和指令初始化Inquirer inquirer = Inquirer( description=prompter_result.description, instructions=prompter_result.instructions, model_type=self.model_type, llm_config=self.llm_config ) input_data = { "hpi_content": recipient_result.updated_HPI, "ph_content": recipient_result.updated_PH, "chief_complaint": recipient_result.chief_complaint } result = inquirer.run(**input_data) execution_time = time.time() - start_time doctor_question = result.current_chat output_data = {"doctor_question": doctor_question} logger.log_agent_execution(step_num, "inquirer", input_data, output_data, execution_time) return doctor_question except Exception as e: error_msg = f"Inquirer执行失败: {str(e)}" logger.log_error(step_num, "inquirer_error", error_msg) # 返回默认问题 return "请您详细描述一下您的症状，包括什么时候开始的，有什么特点？" def _execute_evaluator(self, step_num: int, logger: WorkflowLogger, case_data: Dict[str, Any], step_result: Dict[str, Any]): """执行Evaluator agent""" start_time = time.time() try: # 准备评价器需要的数据格式，包含完整对话历史 conversation_history = step_result.get("conversation_history", "") round_data = { "patient_response": step_result.get("patient_response", ""), "doctor_inquiry": step_result.get("doctor_question", ""), "HPI": step_result.get("updated_hpi", ""), "PH": step_result.get("updated_ph", ""), "chief_complaint": step_result.get("updated_chief_complaint", "") } # 使用全局历史评分 historical_scores = self._global_historical_scores # 调用评价器进行评价，传入完整对话历史和历史评分 input_data = { "patient_case": case_data, "current_round": step_num, "round_data": round_data, "conversation_history": conversation_history, "historical_scores": historical_scores # 添加历史评分作为明确参数 } # 构建所有轮次的数据用于多轮评估 all_rounds_data = [] # 从对话历史中提取每轮数据 lines = conversation_history.strip().split('\n') current_round_data = {} for line in lines: line = line.strip() if line.startswith('医生:') and current_round_data: # 完成上轮，开始新轮 all_rounds_data.append(current_round_data) current_round_data = {"doctor_inquiry": line[3:].strip(), "patient_response": ""} elif line.startswith('医生:'): # 新轮开始 current_round_data = {"doctor_inquiry": line[3:].strip(), "patient_response": ""} elif line.startswith('患者:') and current_round_data: current_round_data["patient_response"] = line[3:].strip() elif line.startswith('患者:'): # 第一轮只有患者回应 current_round_data = {"doctor_inquiry": "", "patient_response": line[3:].strip()} # 添加最后一轮 if current_round_data: current_round_data.update({ "HPI": step_result.get("updated_hpi", ""), "PH": step_result.get("updated_ph", ""), "chief_complaint": step_result.get("updated_chief_complaint", "") }) all_rounds_data.append(current_round_data) # 为所有轮次添加evaluation_scores，使用全局历史评分 for i, round_data in enumerate(all_rounds_data): if i < step_num - 1: # 历史轮次 # 使用全局历史评分 round_data["evaluation_scores"] = self._global_historical_scores else: # 当前轮次 # 当前轮次尚未评分，使用空值占位 round_data["evaluation_scores"] = { "clinical_inquiry": 0.0, "communication_quality": 0.0, "multi_round_consistency": 0.0, "overall_professionalism": 0.0, "present_illness_similarity": 0.0, "past_history_similarity": 0.0, "chief_complaint_similarity": 0.0 } # 调用支持多轮的评估方法 result = self.evaluator.run( patient_case=case_data, current_round=step_num, all_rounds_data=all_rounds_data, historical_scores=historical_scores ) execution_time = time.time() - start_time output_data = { "clinical_inquiry": { "score": result.clinical_inquiry.score, "comment": result.clinical_inquiry.comment }, "communication_quality": { "score": result.communication_quality.score, "comment": result.communication_quality.comment }, "multi_round_consistency": { "score": result.multi_round_consistency.score, "comment": result.multi_round_consistency.comment }, "overall_professionalism": { "score": result.overall_professionalism.score, "comment": result.overall_professionalism.comment }, "present_illness_similarity": { "score": result.present_illness_similarity.score, "comment": result.present_illness_similarity.comment }, "past_history_similarity": { "score": result.past_history_similarity.score, "comment": result.past_history_similarity.comment }, "chief_complaint_similarity": { "score": result.chief_complaint_similarity.score, "comment": result.chief_complaint_similarity.comment }, "summary": result.summary, "key_suggestions": result.key_suggestions } logger.log_agent_execution(step_num, "evaluator", input_data, output_data, execution_time) # 更新全局历史评分 self._global_historical_scores = { "clinical_inquiry": result.clinical_inquiry.score, "communication_quality": result.communication_quality.score, "multi_round_consistency": result.multi_round_consistency.score, "overall_professionalism": result.overall_professionalism.score, "present_illness_similarity": result.present_illness_similarity.score, "past_history_similarity": result.past_history_similarity.score, "chief_complaint_similarity": result.chief_complaint_similarity.score } return result except Exception as e: error_msg = f"Evaluator执行失败: {str(e)}" logger.log_error(step_num, "evaluator_error", error_msg) # 返回默认评价结果 from agent_system.evaluetor.response_model import EvaluatorResult, EvaluationDimension default_dimension = EvaluationDimension(score=0.0, comment="评价失败") return EvaluatorResult( clinical_inquiry=default_dimension, communication_quality=default_dimension, multi_round_consistency=default_dimension, overall_professionalism=default_dimension, present_illness_similarity=default_dimension, past_history_similarity=default_dimension, chief_complaint_similarity=default_dimension, summary="评价失败", key_suggestions=["系统需要调试"] )