from flask import Flask, request, jsonify, Response, stream_with_context from flask_socketio import SocketIO, emit, join_room, leave_room import json from DataProcess import Add_Collaboration_Brief_FrontEnd from AgentCoord.RehearsalEngine_V2.ExecutePlan import executePlan from AgentCoord.RehearsalEngine_V2.ExecutePlan_Optimized import executePlan_streaming from AgentCoord.PlanEngine.basePlan_Generator import generate_basePlan from AgentCoord.PlanEngine.fill_stepTask import fill_stepTask from AgentCoord.PlanEngine.fill_stepTask_TaskProcess import ( fill_stepTask_TaskProcess, ) from AgentCoord.PlanEngine.branch_PlanOutline import branch_PlanOutline from AgentCoord.PlanEngine.branch_TaskProcess import branch_TaskProcess from AgentCoord.PlanEngine.AgentSelectModify import ( AgentSelectModify_init, AgentSelectModify_addAspect, ) import os import yaml import argparse # initialize global variables yaml_file = os.path.join(os.getcwd(), "config", "config.yaml") try: with open(yaml_file, "r", encoding="utf-8") as file: yaml_data = yaml.safe_load(file) except Exception: yaml_file = {} USE_CACHE: bool = os.getenv("USE_CACHE") if USE_CACHE is None: USE_CACHE = yaml_data.get("USE_CACHE", False) else: USE_CACHE = USE_CACHE.lower() in ["true", "1", "yes"] AgentBoard = None AgentProfile_Dict = {} Request_Cache: dict[str, str] = {} app = Flask(__name__) app.config['SECRET_KEY'] = 'agentcoord-secret-key' socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading') @app.route("/fill_stepTask_TaskProcess", methods=["post"]) def Handle_fill_stepTask_TaskProcess(): incoming_data = request.get_json() requestIdentifier = str( ( "/fill_stepTask_TaskProcess", incoming_data["General Goal"], incoming_data["stepTask_lackTaskProcess"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) filled_stepTask = fill_stepTask_TaskProcess( General_Goal=incoming_data["General Goal"], stepTask=incoming_data["stepTask_lackTaskProcess"], AgentProfile_Dict=AgentProfile_Dict, ) filled_stepTask = Add_Collaboration_Brief_FrontEnd(filled_stepTask) Request_Cache[requestIdentifier] = filled_stepTask response = jsonify(filled_stepTask) return response @app.route("/agentSelectModify_init", methods=["post"]) def Handle_agentSelectModify_init(): incoming_data = request.get_json() requestIdentifier = str( ( "/agentSelectModify_init", incoming_data["General Goal"], incoming_data["stepTask"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) scoreTable = AgentSelectModify_init( stepTask=incoming_data["stepTask"], General_Goal=incoming_data["General Goal"], Agent_Board=AgentBoard, ) Request_Cache[requestIdentifier] = scoreTable response = jsonify(scoreTable) return response @app.route("/agentSelectModify_addAspect", methods=["post"]) def Handle_agentSelectModify_addAspect(): incoming_data = request.get_json() requestIdentifier = str( ("/agentSelectModify_addAspect", incoming_data["aspectList"]) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) scoreTable = AgentSelectModify_addAspect( aspectList=incoming_data["aspectList"], Agent_Board=AgentBoard ) Request_Cache[requestIdentifier] = scoreTable response = jsonify(scoreTable) return response @app.route("/fill_stepTask", methods=["post"]) def Handle_fill_stepTask(): incoming_data = request.get_json() requestIdentifier = str( ( "/fill_stepTask", incoming_data["General Goal"], incoming_data["stepTask"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) filled_stepTask = fill_stepTask( General_Goal=incoming_data["General Goal"], stepTask=incoming_data["stepTask"], Agent_Board=AgentBoard, AgentProfile_Dict=AgentProfile_Dict, ) filled_stepTask = Add_Collaboration_Brief_FrontEnd(filled_stepTask) Request_Cache[requestIdentifier] = filled_stepTask response = jsonify(filled_stepTask) return response @app.route("/branch_PlanOutline", methods=["post"]) def Handle_branch_PlanOutline(): incoming_data = request.get_json() requestIdentifier = str( ( "/branch_PlanOutline", incoming_data["branch_Number"], incoming_data["Modification_Requirement"], incoming_data["Existing_Steps"], incoming_data["Baseline_Completion"], incoming_data["Initial Input Object"], incoming_data["General Goal"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) branchList = branch_PlanOutline( branch_Number=incoming_data["branch_Number"], Modification_Requirement=incoming_data["Modification_Requirement"], Existing_Steps=incoming_data["Existing_Steps"], Baseline_Completion=incoming_data["Baseline_Completion"], InitialObject_List=incoming_data["Initial Input Object"], General_Goal=incoming_data["General Goal"], ) branchList = Add_Collaboration_Brief_FrontEnd(branchList) Request_Cache[requestIdentifier] = branchList response = jsonify(branchList) return response @app.route("/branch_TaskProcess", methods=["post"]) def Handle_branch_TaskProcess(): incoming_data = request.get_json() requestIdentifier = str( ( "/branch_TaskProcess", incoming_data["branch_Number"], incoming_data["Modification_Requirement"], incoming_data["Existing_Steps"], incoming_data["Baseline_Completion"], incoming_data["stepTaskExisting"], incoming_data["General Goal"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) branchList = branch_TaskProcess( branch_Number=incoming_data["branch_Number"], Modification_Requirement=incoming_data["Modification_Requirement"], Existing_Steps=incoming_data["Existing_Steps"], Baseline_Completion=incoming_data["Baseline_Completion"], stepTaskExisting=incoming_data["stepTaskExisting"], General_Goal=incoming_data["General Goal"], AgentProfile_Dict=AgentProfile_Dict, ) Request_Cache[requestIdentifier] = branchList response = jsonify(branchList) return response @app.route("/generate_basePlan", methods=["post"]) def Handle_generate_basePlan(): incoming_data = request.get_json() requestIdentifier = str( ( "/generate_basePlan", incoming_data["General Goal"], incoming_data["Initial Input Object"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) try: basePlan = generate_basePlan( General_Goal=incoming_data["General Goal"], Agent_Board=AgentBoard, AgentProfile_Dict=AgentProfile_Dict, InitialObject_List=incoming_data["Initial Input Object"], ) except ValueError as e: return jsonify({"error": str(e)}), 400 except Exception as e: return jsonify({"error": f"An unexpected error occurred: {str(e)}"}), 500 basePlan_withRenderSpec = Add_Collaboration_Brief_FrontEnd(basePlan) Request_Cache[requestIdentifier] = basePlan_withRenderSpec response = jsonify(basePlan_withRenderSpec) return response @app.route("/executePlan", methods=["post"]) def Handle_executePlan(): incoming_data = request.get_json() requestIdentifier = str( ( "/executePlan", incoming_data["num_StepToRun"], incoming_data["RehearsalLog"], incoming_data["plan"], ) ) if USE_CACHE: if requestIdentifier in Request_Cache: return jsonify(Request_Cache[requestIdentifier]) RehearsalLog = executePlan( incoming_data["plan"], incoming_data["num_StepToRun"], incoming_data["RehearsalLog"], AgentProfile_Dict, ) Request_Cache[requestIdentifier] = RehearsalLog response = jsonify(RehearsalLog) return response @app.route("/executePlanOptimized", methods=["post"]) def Handle_executePlanOptimized(): """ 优化版流式执行计划（阶段1+2：步骤级流式 + 动作级智能并行） 返回 SSE 流，每完成一个动作就返回结果 - 无依赖关系的动作并行执行 - 有依赖关系的动作串行执行 前端使用 EventSource 接收 """ incoming_data = request.get_json() def generate(): try: for chunk in executePlan_streaming( plan=incoming_data["plan"], num_StepToRun=incoming_data.get("num_StepToRun"), RehearsalLog=incoming_data.get("RehearsalLog", []), AgentProfile_Dict=AgentProfile_Dict, ): yield chunk except Exception as e: error_event = json.dumps({ "type": "error", "message": str(e) }, ensure_ascii=False) yield f"data: {error_event}\n\n" return Response( stream_with_context(generate()), mimetype="text/event-stream", headers={ "Cache-Control": "no-cache", "X-Accel-Buffering": "no", } ) @app.route("/_saveRequestCashe", methods=["post"]) def Handle_saveRequestCashe(): with open( os.path.join(os.getcwd(), "RequestCache", "Request_Cache.json"), "w" ) as json_file: json.dump(Request_Cache, json_file, indent=4) response = jsonify( {"code": 200, "content": "request cashe sucessfully saved"} ) return response @app.route("/setAgents", methods=["POST"]) def set_agents(): global AgentBoard, AgentProfile_Dict,yaml_data AgentBoard = request.json AgentProfile_Dict = {} for item in AgentBoard: name = item["Name"] if all(item.get(field) for field in ["apiUrl","apiKey","apiModel"]): agent_config = { "profile": item["Profile"], "apiUrl": item["apiUrl"], "apiKey": item["apiKey"], "apiModel": item["apiModel"], "useCustomAPI":True } else: agent_config = { "profile": item["Profile"], "apiUrl": yaml_data.get("OPENAI_API_BASE"), "apiKey": yaml_data.get("OPENAI_API_KEY"), "apiModel": yaml_data.get("OPENAI_API_MODEL"), "useCustomAPI":False } AgentProfile_Dict[name] = agent_config return jsonify({"code": 200, "content": "set agentboard successfully"}) def init(): global AgentBoard, AgentProfile_Dict, Request_Cache # Load Request Cache try: with open( os.path.join(os.getcwd(), "RequestCache", "Request_Cache.json"), "r" ) as json_file: Request_Cache = json.load(json_file) print(f"✅ Loaded Request_Cache with {len(Request_Cache)} entries") except Exception as e: print(f"⚠️ Failed to load Request_Cache: {e}") Request_Cache = {} # Load Agent Board try: with open( os.path.join(os.getcwd(), "AgentRepo", "agentBoard_v1.json"), "r", encoding="utf-8" ) as json_file: AgentBoard = json.load(json_file) print(f"✅ Loaded AgentBoard with {len(AgentBoard)} agents") # Build AgentProfile_Dict AgentProfile_Dict = {} for item in AgentBoard: name = item["Name"] profile = item["Profile"] AgentProfile_Dict[name] = profile print(f"✅ Built AgentProfile_Dict with {len(AgentProfile_Dict)} profiles") except Exception as e: print(f"⚠️ Failed to load AgentBoard: {e}") AgentBoard = [] AgentProfile_Dict = {} # ==================== WebSocket 连接管理 ==================== @socketio.on('connect') def handle_connect(): """客户端连接""" print(f"✅ WebSocket client connected: {request.sid}") emit('connected', {'sid': request.sid, 'message': 'WebSocket连接成功'}) @socketio.on('disconnect') def handle_disconnect(): """客户端断开连接""" print(f"❌ WebSocket client disconnected: {request.sid}") @socketio.on('ping') def handle_ping(): """心跳检测""" emit('pong') # ==================== WebSocket 事件处理 ==================== # 注：以下为WebSocket版本的接口，与REST API并存 # 逐步迁移核心接口到WebSocket @socketio.on('execute_plan_optimized') def handle_execute_plan_optimized_ws(data): """ WebSocket版本：优化版流式执行计划 支持步骤级流式 + 动作级智能并行 请求格式： { "id": "request-id", "action": "execute_plan_optimized", "data": { "plan": {...}, "num_StepToRun": null, "RehearsalLog": [] } } """ request_id = data.get('id') incoming_data = data.get('data', {}) try: plan = incoming_data.get("plan") num_StepToRun = incoming_data.get("num_StepToRun") RehearsalLog = incoming_data.get("RehearsalLog", []) # 使用原有的流式执行函数 for chunk in executePlan_streaming( plan=plan, num_StepToRun=num_StepToRun, RehearsalLog=RehearsalLog, AgentProfile_Dict=AgentProfile_Dict, ): # 通过WebSocket推送进度 emit('progress', { 'id': request_id, 'status': 'streaming', 'data': chunk.replace('data: ', '').replace('\n\n', '') }) # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'complete', 'data': None }) except Exception as e: # 发送错误信息 emit('progress', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('generate_base_plan') def handle_generate_base_plan_ws(data): """ WebSocket版本：生成基础计划（支持流式/分步返回） 请求格式： { "id": "request-id", "action": "generate_base_plan", "data": { "General Goal": "...", "Initial Input Object": [...] } } 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "generating_outline", "message": "正在生成计划大纲..."} - progress: {"id": request_id, "status": "streaming", "stage": "processing_steps", "step": 1, "total": 3, "message": "正在处理步骤 1/3..."} - response: {"id": request_id, "status": "success", "data": basePlan} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 requestIdentifier = str(( "/generate_basePlan", incoming_data.get("General Goal"), incoming_data.get("Initial Input Object"), )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 阶段1：生成计划大纲 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generating_outline', 'message': '📋 正在生成计划大纲...' }) from AgentCoord.PlanEngine.planOutline_Generator import generate_PlanOutline PlanOutline = generate_PlanOutline( InitialObject_List=incoming_data.get("Initial Input Object"), General_Goal=incoming_data.get("General Goal") ) # 阶段2：构建基础计划（逐步添加步骤） emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'building_plan', 'total_steps': len(PlanOutline), 'message': f'🔨 正在构建计划，共 {len(PlanOutline)} 个步骤...' }) basePlan = { "General Goal": incoming_data.get("General Goal"), "Initial Input Object": incoming_data.get("Initial Input Object"), "Collaboration Process": [] } for idx, stepItem in enumerate(PlanOutline, 1): # 添加智能体选择和任务流程字段 stepItem["AgentSelection"] = [] stepItem["TaskProcess"] = [] stepItem["Collaboration_Brief_frontEnd"] = { "template": "", "data": {} } basePlan["Collaboration Process"].append(stepItem) # 发送进度更新 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'adding_step', 'step': idx, 'total': len(PlanOutline), 'step_name': stepItem.get("StepName", ""), 'message': f'✅ 已添加步骤 {idx}/{len(PlanOutline)}: {stepItem.get("StepName", "")}' }) # 阶段3：处理渲染规范 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'rendering', 'message': '🎨 正在处理渲染规范...' }) basePlan_withRenderSpec = Add_Collaboration_Brief_FrontEnd(basePlan) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = basePlan_withRenderSpec # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': '✅ 计划生成完成' }) # 返回最终结果 emit('response', { 'id': request_id, 'status': 'success', 'data': basePlan_withRenderSpec }) except ValueError as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': f"An unexpected error occurred: {str(e)}" }) @socketio.on('fill_step_task') def handle_fill_step_task_ws(data): """ WebSocket版本：填充步骤任务（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "message": "开始填充步骤任务..."} - progress: {"id": request_id, "status": "streaming", "stage": "agent_selection", "message": "正在生成智能体选择..."} - progress: {"id": request_id, "status": "streaming", "stage": "task_process", "message": "正在生成任务流程..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "任务填充完成"} - response: {"id": request_id, "status": "success", "data": filled_stepTask} """ request_id = data.get('id') incoming_data = data.get('data', {}) print(f"📥 [WS] 收到 fill_step_task 请求: {request_id}") try: # 检查缓存 requestIdentifier = str(( "/fill_stepTask", incoming_data.get("General Goal"), incoming_data.get("stepTask"), )) if USE_CACHE and requestIdentifier in Request_Cache: print(f"✅ [WS] 使用缓存返回: {request_id}") emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'message': f'🚀 开始填充步骤任务: {incoming_data.get("stepTask", {}).get("StepName", "")}' }) print(f"⏳ [WS] 开始处理 fill_step_task...") # 阶段1：生成智能体选择 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'agent_selection', 'message': '👥 正在生成智能体选择...' }) from AgentCoord.PlanEngine.AgentSelection_Generator import generate_AgentSelection stepTask = incoming_data.get("stepTask") Current_Task = { "TaskName": stepTask.get("StepName"), "InputObject_List": stepTask.get("InputObject_List"), "OutputObject": stepTask.get("OutputObject"), "TaskContent": stepTask.get("TaskContent"), } AgentSelection = generate_AgentSelection( General_Goal=incoming_data.get("General Goal"), Current_Task=Current_Task, Agent_Board=AgentBoard, ) emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'agent_selection_done', 'message': f'✅ 智能体选择完成: {", ".join(AgentSelection)}' }) # 阶段2：生成任务流程 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'task_process', 'message': '📝 正在生成任务流程...' }) import AgentCoord.util as util from AgentCoord.PlanEngine.taskProcess_Generator import generate_TaskProcess Current_Task_Description = { "TaskName": stepTask.get("StepName"), "AgentInvolved": [ {"Name": name, "Profile": AgentProfile_Dict[name]} for name in AgentSelection ], "InputObject_List": stepTask.get("InputObject_List"), "OutputObject": stepTask.get("OutputObject"), "CurrentTaskDescription": util.generate_template_sentence_for_CollaborationBrief( stepTask.get("InputObject_List"), stepTask.get("OutputObject"), AgentSelection, stepTask.get("TaskContent"), ), } TaskProcess = generate_TaskProcess( General_Goal=incoming_data.get("General Goal"), Current_Task_Description=Current_Task_Description, ) # 构建结果 stepTask["AgentSelection"] = AgentSelection stepTask["TaskProcess"] = TaskProcess emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'task_process_done', 'message': f'✅ 任务流程生成完成，共 {len(TaskProcess)} 个动作' }) # 阶段3：处理渲染规范 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'rendering', 'message': '🎨 正在处理渲染规范...' }) filled_stepTask = Add_Collaboration_Brief_FrontEnd(stepTask) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = filled_stepTask # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': '✅ 任务填充完成' }) # 返回结果 print(f"✅ [WS] fill_step_task 处理完成: {request_id}") emit('response', { 'id': request_id, 'status': 'success', 'data': filled_stepTask }) except Exception as e: print(f"❌ [WS] fill_step_task 处理失败: {request_id}, 错误: {str(e)}") emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('fill_step_task_process') def handle_fill_step_task_process_ws(data): """ WebSocket版本：填充步骤任务流程（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "message": "开始生成任务流程..."} - progress: {"id": request_id, "status": "streaming", "stage": "generating", "message": "正在生成任务流程..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "任务流程生成完成"} - response: {"id": request_id, "status": "success", "data": filled_stepTask} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 requestIdentifier = str(( "/fill_stepTask_TaskProcess", incoming_data.get("General Goal"), incoming_data.get("stepTask_lackTaskProcess"), )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 stepTask = incoming_data.get("stepTask_lackTaskProcess") emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'message': f'🚀 开始生成任务流程: {stepTask.get("StepName", "")}' }) # 生成任务流程 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generating', 'message': '📝 正在生成任务流程...' }) filled_stepTask = fill_stepTask_TaskProcess( General_Goal=incoming_data.get("General Goal"), stepTask=stepTask, AgentProfile_Dict=AgentProfile_Dict, ) emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generated', 'message': f'✅ 任务流程生成完成，共 {len(filled_stepTask.get("TaskProcess", []))} 个动作' }) # 处理渲染规范 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'rendering', 'message': '🎨 正在处理渲染规范...' }) filled_stepTask = Add_Collaboration_Brief_FrontEnd(filled_stepTask) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = filled_stepTask # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': '✅ 任务流程生成完成' }) # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': filled_stepTask }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('branch_plan_outline') def handle_branch_plan_outline_ws(data): """ WebSocket版本：分支任务大纲（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "branch": 1, "total": 3, "message": "正在生成分支 1/3..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "分支大纲生成完成"} - response: {"id": request_id, "status": "success", "data": branchList} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 requestIdentifier = str(( "/branch_PlanOutline", incoming_data.get("branch_Number"), incoming_data.get("Modification_Requirement"), incoming_data.get("Existing_Steps"), incoming_data.get("Baseline_Completion"), incoming_data.get("Initial Input Object"), incoming_data.get("General Goal"), )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 branch_Number = incoming_data.get("branch_Number") emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'total_branches': branch_Number, 'message': f'🚀 开始生成分支大纲，共 {branch_Number} 个分支...' }) # 生成大纲分支（逐步生成） from AgentCoord.util.converter import read_LLM_Completion from AgentCoord.PlanEngine.branch_PlanOutline import JSON_PLAN_OUTLINE_BRANCHING import json prompt = f""" ## Instruction Based on "Existing Steps", your task is to comeplete the "Remaining Steps" for the plan for "General Goal". Note: "Modification Requirement" specifies how to modify the "Baseline Completion" for a better/alternative solution. **IMPORTANT LANGUAGE REQUIREMENT: You must respond in Chinese (中文) for all content, including StepName, TaskContent, and OutputObject fields.** ## General Goal (Specify the general goal for the plan) {incoming_data.get("General Goal")} ## Initial Key Object List (Specify the list of initial key objects available for use as the input object of a Step) {incoming_data.get("Initial Input Object")} ## Existing Steps {json.dumps(incoming_data.get("Existing_Steps"), indent=4)} ## Baseline Completion {json.dumps(incoming_data.get("Baseline_Completion"), indent=4)} ## Modification Requirement {incoming_data.get("Modification_Requirement")} """ branch_List = [] for i in range(branch_Number): # 发送进度更新 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generating_branch', 'branch': i + 1, 'total': branch_Number, 'message': f'🌿 正在生成分支大纲 {i+1}/{branch_Number}...' }) messages = [ { "role": "system", "content": f" The JSON object must use the schema: {json.dumps(JSON_PLAN_OUTLINE_BRANCHING.model_json_schema(), indent=2)}", }, {"role": "system", "content": prompt}, ] Remaining_Steps = read_LLM_Completion(messages, useGroq=False)["Remaining Steps"] branch_List.append(Remaining_Steps) emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'branch_done', 'branch': i + 1, 'total': branch_Number, 'steps_count': len(Remaining_Steps), 'message': f'✅ 分支 {i+1}/{branch_Number} 生成完成，包含 {len(Remaining_Steps)} 个步骤' }) # 处理渲染规范 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'rendering', 'message': '🎨 正在处理渲染规范...' }) branchList = Add_Collaboration_Brief_FrontEnd(branch_List) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = branchList # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': f'✅ 分支大纲生成完成，共 {branch_Number} 个分支' }) # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': branchList }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('branch_task_process') def handle_branch_task_process_ws(data): """ WebSocket版本：分支任务流程（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "branch": 1, "total": 3, "message": "正在生成分支任务流程 1/3..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "分支任务流程生成完成"} - response: {"id": request_id, "status": "success", "data": branchList} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 requestIdentifier = str(( "/branch_TaskProcess", incoming_data.get("branch_Number"), incoming_data.get("Modification_Requirement"), incoming_data.get("Existing_Steps"), incoming_data.get("Baseline_Completion"), incoming_data.get("stepTaskExisting"), incoming_data.get("General Goal"), )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 branch_Number = incoming_data.get("branch_Number") emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'total_branches': branch_Number, 'message': f'🚀 开始生成分支任务流程，共 {branch_Number} 个分支...' }) # 生成任务流程分支（逐步生成） from AgentCoord.util.converter import read_LLM_Completion from AgentCoord.PlanEngine.branch_TaskProcess import ( JSON_TASK_PROCESS_BRANCHING, ACT_SET, PROMPT_TASK_PROCESS_BRANCHING ) import AgentCoord.util as util import json stepTaskExisting = incoming_data.get("stepTaskExisting") Current_Task_Description = { "TaskName": stepTaskExisting.get("StepName"), "AgentInvolved": [ {"Name": name, "Profile": AgentProfile_Dict[name]} for name in stepTaskExisting.get("AgentSelection", []) ], "InputObject_List": stepTaskExisting.get("InputObject_List"), "OutputObject": stepTaskExisting.get("OutputObject"), "CurrentTaskDescription": util.generate_template_sentence_for_CollaborationBrief( stepTaskExisting.get("InputObject_List"), stepTaskExisting.get("OutputObject"), stepTaskExisting.get("AgentSelection"), stepTaskExisting.get("TaskContent"), ), } prompt = PROMPT_TASK_PROCESS_BRANCHING.format( Modification_Requirement=incoming_data.get("Modification_Requirement"), Current_Task_Description=json.dumps(Current_Task_Description, indent=4), Existing_Steps=json.dumps(incoming_data.get("Existing_Steps"), indent=4), Baseline_Completion=json.dumps(incoming_data.get("Baseline_Completion"), indent=4), General_Goal=incoming_data.get("General Goal"), Act_Set=ACT_SET, ) branch_List = [] for i in range(branch_Number): # 发送进度更新 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generating_branch', 'branch': i + 1, 'total': branch_Number, 'message': f'🌿 正在生成分支任务流程 {i+1}/{branch_Number}...' }) messages = [ { "role": "system", "content": f" The JSON object must use the schema: {json.dumps(JSON_TASK_PROCESS_BRANCHING.model_json_schema(), indent=2)}", }, {"role": "system", "content": prompt}, ] Remaining_Steps = read_LLM_Completion(messages, useGroq=False)["Remaining Steps"] branch_List.append(Remaining_Steps) emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'branch_done', 'branch': i + 1, 'total': branch_Number, 'actions_count': len(Remaining_Steps), 'message': f'✅ 分支 {i+1}/{branch_Number} 生成完成，包含 {len(Remaining_Steps)} 个动作' }) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = branch_List # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': f'✅ 分支任务流程生成完成，共 {branch_Number} 个分支' }) # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': branch_List }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('agent_select_modify_init') def handle_agent_select_modify_init_ws(data): """ WebSocket版本：智能体选择评分初始化（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "message": "开始生成能力需求..."} - progress: {"id": request_id, "status": "streaming", "stage": "requirements", "message": "能力需求: [xxx, yyy, zzz]"} - progress: {"id": request_id, "status": "streaming", "stage": "scoring", "aspect": 1, "total": 3, "message": "正在评分能力 1/3..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "智能体评分完成"} - response: {"id": request_id, "status": "success", "data": scoreTable} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 requestIdentifier = str(( "/agentSelectModify_init", incoming_data.get("General Goal"), incoming_data.get("stepTask"), )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'message': '🚀 开始生成智能体能力需求...' }) from AgentCoord.util.converter import read_LLM_Completion from AgentCoord.PlanEngine.AgentSelectModify import ( JSON_ABILITY_REQUIREMENT_GENERATION, PROMPT_ABILITY_REQUIREMENT_GENERATION, agentAbilityScoring ) import json # 阶段1：生成能力需求列表 stepTask = incoming_data.get("stepTask") Current_Task = { "TaskName": stepTask.get("StepName"), "InputObject_List": stepTask.get("InputObject_List"), "OutputObject": stepTask.get("OutputObject"), "TaskContent": stepTask.get("TaskContent"), } emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'generating_requirements', 'message': '📋 正在生成能力需求列表...' }) messages = [ { "role": "system", "content": f" The JSON object must use the schema: {json.dumps(JSON_ABILITY_REQUIREMENT_GENERATION.model_json_schema(), indent=2)}", }, { "role": "system", "content": PROMPT_ABILITY_REQUIREMENT_GENERATION.format( General_Goal=incoming_data.get("General Goal"), Current_Task=json.dumps(Current_Task, indent=4), ), }, ] Ability_Requirement_List = read_LLM_Completion(messages)["AbilityRequirement"] emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'requirements_generated', 'requirements': Ability_Requirement_List, 'message': f'✅ 能力需求生成完成: {", ".join(Ability_Requirement_List)}' }) # 阶段2：为每个能力需求进行智能体评分 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'scoring', 'total_aspects': len(Ability_Requirement_List), 'message': f'📊 开始为 {len(Ability_Requirement_List)} 个能力需求评分...' }) scoreTable = agentAbilityScoring(AgentBoard, Ability_Requirement_List) # 逐步报告评分进度 for idx, (ability, scores) in enumerate(scoreTable.items(), 1): emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'aspect_scored', 'aspect': idx, 'total': len(Ability_Requirement_List), 'ability': ability, 'message': f'✅ 能力 "{ability}" 评分完成 ({idx}/{len(Ability_Requirement_List)})' }) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = scoreTable # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': f'✅ 智能体评分完成，共 {len(Ability_Requirement_List)} 个能力维度' }) # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': scoreTable }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('agent_select_modify_add_aspect') def handle_agent_select_modify_add_aspect_ws(data): """ WebSocket版本：添加新的评估维度（支持流式/分步返回） 流式事件： - progress: {"id": request_id, "status": "streaming", "stage": "starting", "aspect": "新能力", "message": "开始为新能力评分..."} - progress: {"id": request_id, "status": "streaming", "stage": "scoring", "message": "正在评分..."} - progress: {"id": request_id, "status": "streaming", "stage": "complete", "message": "评分完成"} - response: {"id": request_id, "status": "success", "data": scoreTable} """ request_id = data.get('id') incoming_data = data.get('data', {}) try: # 检查缓存 aspectList = incoming_data.get("aspectList") newAspect = aspectList[-1] if aspectList else None requestIdentifier = str(( "/agentSelectModify_addAspect", aspectList, )) if USE_CACHE and requestIdentifier in Request_Cache: emit('response', { 'id': request_id, 'status': 'success', 'data': Request_Cache[requestIdentifier] }) return # 开始处理 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'starting', 'message': f'🚀 开始为新能力维度评分: {newAspect or "Unknown"}' }) # 添加新维度并评分 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'scoring', 'aspect': newAspect, 'message': f'📊 正在为能力 "{newAspect}" 评分...' }) scoreTable = AgentSelectModify_addAspect( aspectList=aspectList, Agent_Board=AgentBoard ) # 发送完成信号 emit('progress', { 'id': request_id, 'status': 'streaming', 'stage': 'complete', 'message': f'✅ 能力 "{newAspect}" 评分完成' }) # 缓存结果 if USE_CACHE: Request_Cache[requestIdentifier] = scoreTable # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': scoreTable }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('set_agents') def handle_set_agents_ws(data): """ WebSocket版本：设置智能体 """ request_id = data.get('id') incoming_data = data.get('data', {}) global AgentBoard, AgentProfile_Dict, yaml_data try: AgentBoard = incoming_data AgentProfile_Dict = {} for item in AgentBoard: name = item["Name"] if all(item.get(field) for field in ["apiUrl", "apiKey", "apiModel"]): agent_config = { "profile": item["Profile"], "apiUrl": item["apiUrl"], "apiKey": item["apiKey"], "apiModel": item["apiModel"], "useCustomAPI": True } else: agent_config = { "profile": item["Profile"], "apiUrl": yaml_data.get("OPENAI_API_BASE"), "apiKey": yaml_data.get("OPENAI_API_KEY"), "apiModel": yaml_data.get("OPENAI_API_MODEL"), "useCustomAPI": False } AgentProfile_Dict[name] = agent_config # 返回结果 emit('response', { 'id': request_id, 'status': 'success', 'data': {"code": 200, "content": "set agentboard successfully"} }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('stop_generation') def handle_stop_generation(data): """ WebSocket版本：停止生成任务 请求格式： { "id": "request-id", "action": "stop_generation", "data": { "goal": "任务描述" } } """ request_id = data.get('id') incoming_data = data.get('data', {}) try: goal = incoming_data.get('goal', '') # TODO: 这里可以添加实际的停止逻辑 # 例如：设置全局停止标志，通知所有正在运行的生成任务停止 print(f"🛑 收到停止生成请求: goal={goal}") # 返回成功响应 emit('response', { 'id': request_id, 'status': 'success', 'data': {"message": "已发送停止信号"} }) except Exception as e: emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('pause_execution') def handle_pause_execution(data): """ WebSocket版本：暂停任务执行 请求格式： { "id": "request-id", "action": "pause_execution", "data": { "goal": "任务描述" } } """ request_id = data.get('id') incoming_data = data.get('data', {}) try: from AgentCoord.RehearsalEngine_V2.execution_state import execution_state_manager goal = incoming_data.get('goal', '') # 检查当前执行的任务是否匹配 current_goal = execution_state_manager.get_goal() if current_goal and current_goal != goal: print(f"⚠️ 任务目标不匹配: 当前={current_goal}, 请求={goal}") emit('response', { 'id': request_id, 'status': 'error', 'error': '任务目标不匹配' }) return # 调用执行状态管理器暂停 success = execution_state_manager.pause_execution() if success: print(f"⏸️ [DEBUG] 暂停成功! 当前状态: {execution_state_manager.get_status().value}") print(f"⏸️ [DEBUG] should_pause: {execution_state_manager._should_pause}") emit('response', { 'id': request_id, 'status': 'success', 'data': {"message": "已暂停执行，可随时继续"} }) else: print(f"⚠️ [DEBUG] 暂停失败，当前状态: {execution_state_manager.get_status().value}") emit('response', { 'id': request_id, 'status': 'error', 'error': f'无法暂停，当前状态: {execution_state_manager.get_status().value}' }) except Exception as e: print(f"❌ 暂停执行失败: {str(e)}") emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) @socketio.on('resume_execution') def handle_resume_execution(data): """ WebSocket版本：恢复任务执行 请求格式： { "id": "request-id", "action": "resume_execution", "data": { "goal": "任务描述" } } """ request_id = data.get('id') incoming_data = data.get('data', {}) try: from AgentCoord.RehearsalEngine_V2.execution_state import execution_state_manager goal = incoming_data.get('goal', '') # 检查当前执行的任务是否匹配 current_goal = execution_state_manager.get_goal() if current_goal and current_goal != goal: print(f"⚠️ 任务目标不匹配: 当前={current_goal}, 请求={goal}") emit('response', { 'id': request_id, 'status': 'error', 'error': '任务目标不匹配' }) return # 调用执行状态管理器恢复 success = execution_state_manager.resume_execution() if success: print(f"▶️ 已恢复执行: goal={goal}") emit('response', { 'id': request_id, 'status': 'success', 'data': {"message": "已恢复执行"} }) else: print(f"⚠️ 恢复失败，当前状态: {execution_state_manager.get_status()}") emit('response', { 'id': request_id, 'status': 'error', 'error': f'无法恢复，当前状态: {execution_state_manager.get_status().value}' }) except Exception as e: print(f"❌ 恢复执行失败: {str(e)}") emit('response', { 'id': request_id, 'status': 'error', 'error': str(e) }) if __name__ == "__main__": parser = argparse.ArgumentParser( description="start the backend for AgentCoord" ) parser.add_argument( "--port", type=int, default=8000, help="set the port number, 8000 by default.", ) args = parser.parse_args() init() # 使用 socketio.run 替代 app.run，支持WebSocket socketio.run(app, host="0.0.0.0", port=args.port, debug=True, allow_unsafe_werkzeug=True)