""" 工作流执行引擎 """ from typing import Dict, Any, List, Optional import asyncio from collections import defaultdict, deque import json import logging from app.services.llm_service import llm_service from app.services.condition_parser import condition_parser from app.services.data_transformer import data_transformer from app.core.exceptions import WorkflowExecutionError from app.core.database import SessionLocal from app.models.agent import Agent logger = logging.getLogger(__name__) class WorkflowEngine: """工作流执行引擎""" def __init__(self, workflow_id: str, workflow_data: Dict[str, Any], logger=None, db=None): """ 初始化工作流引擎 Args: workflow_id: 工作流ID workflow_data: 工作流数据（包含nodes和edges） logger: 执行日志记录器（可选） db: 数据库会话（可选，用于Agent节点加载Agent配置） """ self.workflow_id = workflow_id self.nodes = {node['id']: node for node in workflow_data.get('nodes', [])} self.edges = workflow_data.get('edges', []) self.execution_graph = None self.node_outputs = {} self.logger = logger self.db = db def build_execution_graph(self, active_edges: Optional[List[Dict[str, Any]]] = None) -> List[str]: """ 构建执行图（DAG）并返回拓扑排序结果 Args: active_edges: 活跃的边列表（用于条件分支过滤） Returns: 拓扑排序后的节点ID列表 """ # 使用活跃的边，如果没有提供则使用所有边 edges_to_use = active_edges if active_edges is not None else self.edges # 构建邻接表和入度表 graph = defaultdict(list) in_degree = defaultdict(int) # 初始化所有节点的入度 for node_id in self.nodes.keys(): in_degree[node_id] = 0 # 构建图 for edge in edges_to_use: source = edge['source'] target = edge['target'] graph[source].append(target) in_degree[target] += 1 # 拓扑排序（Kahn算法） queue = deque() result = [] # 找到所有入度为0的节点（起始节点） for node_id in self.nodes.keys(): if in_degree[node_id] == 0: queue.append(node_id) while queue: node_id = queue.popleft() result.append(node_id) # 处理该节点的所有出边 for neighbor in graph[node_id]: in_degree[neighbor] -= 1 if in_degree[neighbor] == 0: queue.append(neighbor) # 检查是否有环（只检查可达节点） reachable_nodes = set(result) if len(reachable_nodes) < len(self.nodes): # 有些节点不可达，这是正常的（条件分支） pass self.execution_graph = result return result def get_node_input(self, node_id: str, node_outputs: Dict[str, Any], active_edges: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]: """ 获取节点的输入数据 Args: node_id: 节点ID node_outputs: 所有节点的输出数据 active_edges: 活跃的边列表（用于条件分支过滤） Returns: 节点的输入数据 """ # 使用活跃的边，如果没有提供则使用所有边 edges_to_use = active_edges if active_edges is not None else self.edges # 找到所有指向该节点的边 input_data = {} for edge in edges_to_use: if edge['target'] == node_id: source_id = edge['source'] source_output = node_outputs.get(source_id, {}) logger.debug(f"[rjb] 获取节点输入: target={node_id}, source={source_id}, source_output={source_output}, sourceHandle={edge.get('sourceHandle')}") # 如果有sourceHandle，使用它作为key if 'sourceHandle' in edge and edge['sourceHandle']: input_data[edge['sourceHandle']] = source_output else: # 否则合并所有输入 if isinstance(source_output, dict): input_data.update(source_output) else: input_data['input'] = source_output logger.debug(f"[rjb] 节点输入结果: node_id={node_id}, input_data={input_data}") return input_data def _get_nested_value(self, data: Dict[str, Any], path: str) -> Any: """ 从嵌套字典中获取值（支持点号路径和数组索引） Args: data: 数据字典 path: 路径，如 "user.name" 或 "items[0].price" Returns: 路径对应的值 """ if not path: return data parts = path.split('.') result = data for part in parts: if '[' in part and ']' in part: # 处理数组索引，如 "items[0]" key = part[:part.index('[')] index_str = part[part.index('[') + 1:part.index(']')] if isinstance(result, dict): result = result.get(key) elif isinstance(result, list): try: result = result[int(index_str)] except (ValueError, IndexError): return None else: return None if result is None: return None else: # 普通键访问 if isinstance(result, dict): result = result.get(part) else: return None if result is None: return None return result async def _execute_loop_body(self, loop_node_id: str, loop_input: Dict[str, Any], iteration_index: int) -> Dict[str, Any]: """ 执行循环体 Args: loop_node_id: 循环节点ID loop_input: 循环体的输入数据 iteration_index: 当前迭代索引 Returns: 循环体的执行结果 """ # 找到循环节点的直接子节点（循环体开始节点） loop_body_start_nodes = [] for edge in self.edges: if edge.get('source') == loop_node_id: target_id = edge.get('target') if target_id and target_id in self.nodes: loop_body_start_nodes.append(target_id) if not loop_body_start_nodes: # 如果没有子节点，直接返回输入数据 return {'output': loop_input, 'status': 'success'} # 执行循环体：从循环体开始节点执行到循环结束节点或没有更多节点 # 简化处理：只执行第一个子节点链 executed_in_loop = set() loop_results = {} current_node_id = loop_body_start_nodes[0] # 简化：只执行第一个子节点链 # 执行循环体内的节点（简化版本：只执行直接连接的子节点） max_iterations = 100 # 防止无限循环 iteration = 0 while current_node_id and iteration < max_iterations: iteration += 1 if current_node_id in executed_in_loop: break # 避免循环体内部循环 if current_node_id not in self.nodes: break node = self.nodes[current_node_id] executed_in_loop.add(current_node_id) # 如果是循环结束节点，停止执行 if node.get('type') == 'loop_end' or node.get('type') == 'end': break # 执行节点 result = await self.execute_node(node, loop_input) loop_results[current_node_id] = result if result.get('status') != 'success': return result # 更新输入数据为当前节点的输出 if result.get('output'): if isinstance(result.get('output'), dict): loop_input = {**loop_input, **result.get('output')} else: loop_input = {**loop_input, 'result': result.get('output')} # 找到下一个节点（简化：只找第一个子节点） next_node_id = None for edge in self.edges: if edge.get('source') == current_node_id: target_id = edge.get('target') if target_id and target_id in self.nodes and target_id not in executed_in_loop: # 跳过循环节点本身 if target_id != loop_node_id: next_node_id = target_id break current_node_id = next_node_id # 返回最后一个节点的输出 if loop_results: last_result = list(loop_results.values())[-1] return last_result return {'output': loop_input, 'status': 'success'} def _mark_loop_body_executed(self, node_id: str, executed_nodes: set, active_edges: List[Dict[str, Any]]): """ 递归标记循环体内的节点为已执行 Args: node_id: 当前节点ID executed_nodes: 已执行节点集合 active_edges: 活跃的边列表 """ if node_id in executed_nodes: return executed_nodes.add(node_id) # 查找所有子节点 for edge in active_edges: if edge.get('source') == node_id: target_id = edge.get('target') if target_id in self.nodes: target_node = self.nodes[target_id] # 如果是循环结束节点，停止递归 if target_node.get('type') in ['loop_end', 'end']: continue # 递归标记子节点 self._mark_loop_body_executed(target_id, executed_nodes, active_edges) async def execute_node(self, node: Dict[str, Any], input_data: Dict[str, Any]) -> Dict[str, Any]: """ 执行单个节点 Args: node: 节点配置 input_data: 输入数据 Returns: 节点执行结果 """ # 确保可以访问全局的 json 模块 import json as json_module node_type = node.get('type', 'unknown') node_id = node.get('id') import time start_time = time.time() # 记录节点开始执行 if self.logger: self.logger.log_node_start(node_id, node_type, input_data) try: if node_type == 'start': # 起始节点：返回输入数据 logger.debug(f"[rjb] 开始节点执行: node_id={node_id}, input_data={input_data}") result = {'output': input_data, 'status': 'success'} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) logger.debug(f"[rjb] 开始节点输出: node_id={node_id}, output={result.get('output')}") return result elif node_type == 'input': # 输入节点：处理输入数据 result = {'output': input_data, 'status': 'success'} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result elif node_type == 'llm' or node_type == 'template': # LLM节点：调用AI模型 node_data = node.get('data', {}) logger.debug(f"[rjb] LLM节点执行: node_id={node_id}, input_data={input_data}, input_data type={type(input_data)}") logger.debug(f"[rjb] LLM节点数据: node_id={node_id}, node_data keys={list(node_data.keys())}, api_key={'已配置' if node_data.get('api_key') else '未配置'}") prompt = node_data.get('prompt', '') # 如果prompt为空，使用默认提示词 if not prompt: prompt = "请处理以下输入数据：\n{input}" # 格式化prompt，替换变量 try: # 将input_data转换为字符串用于格式化 if isinstance(input_data, dict): # 如果prompt中包含变量，尝试格式化 if '{' in prompt and '}' in prompt: # 尝试格式化所有input_data中的键 formatted_prompt = prompt for key, value in input_data.items(): placeholder = f'{{{key}}}' if placeholder in formatted_prompt: formatted_prompt = formatted_prompt.replace( placeholder, json_module.dumps(value, ensure_ascii=False) if isinstance(value, (dict, list)) else str(value) ) # 如果还有{input}占位符，替换为整个input_data if '{input}' in formatted_prompt: formatted_prompt = formatted_prompt.replace( '{input}', json_module.dumps(input_data, ensure_ascii=False) ) prompt = formatted_prompt else: # 如果没有占位符，将input_data作为JSON附加到prompt prompt = f"{prompt}\n\n输入数据：\n{json_module.dumps(input_data, ensure_ascii=False)}" else: # 如果input_data不是dict，直接转换为字符串 if '{input}' in prompt: prompt = prompt.replace('{input}', str(input_data)) else: prompt = f"{prompt}\n\n输入：{str(input_data)}" except Exception as e: # 格式化失败，使用原始prompt和input_data try: prompt = f"{prompt}\n\n输入数据：\n{json_module.dumps(input_data, ensure_ascii=False)}" except: prompt = f"{prompt}\n\n输入数据：{str(input_data)}" # 获取LLM配置 provider = node_data.get('provider', 'openai') model = node_data.get('model', 'gpt-3.5-turbo') temperature = node_data.get('temperature', 0.7) max_tokens = node_data.get('max_tokens') # 不传递 api_key 和 base_url，让 LLM 服务使用系统默认配置（与节点测试保持一致） api_key = None base_url = None # 调用LLM服务 try: if self.logger: logger.debug(f"[rjb] LLM节点配置: provider={provider}, model={model}, 使用系统默认API Key配置") self.logger.info(f"调用LLM服务: {provider}/{model}", node_id=node_id, node_type=node_type) result = await llm_service.call_llm( prompt=prompt, provider=provider, model=model, temperature=temperature, max_tokens=max_tokens # 不传递 api_key 和 base_url，使用系统默认配置 ) exec_result = {'output': result, 'status': 'success'} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result, duration) return exec_result except Exception as e: # LLM调用失败，返回错误 if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'LLM调用失败: {str(e)}' } elif node_type == 'condition': # 条件节点：判断分支 condition = node.get('data', {}).get('condition', '') if not condition: # 如果没有条件表达式，默认返回False return { 'output': False, 'status': 'success', 'branch': 'false' } # 使用条件解析器评估表达式 try: result = condition_parser.evaluate_condition(condition, input_data) exec_result = { 'output': result, 'status': 'success', 'branch': 'true' if result else 'false' } if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, {'result': result, 'branch': exec_result['branch']}, duration) return exec_result except Exception as e: # 条件评估失败 if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': False, 'status': 'failed', 'error': f'条件评估失败: {str(e)}', 'branch': 'false' } elif node_type == 'data' or node_type == 'transform': # 数据转换节点 node_data = node.get('data', {}) mapping = node_data.get('mapping', {}) filter_rules = node_data.get('filter_rules', []) compute_rules = node_data.get('compute_rules', {}) mode = node_data.get('mode', 'mapping') try: result = data_transformer.transform_data( input_data=input_data, mapping=mapping, filter_rules=filter_rules, compute_rules=compute_rules, mode=mode ) exec_result = {'output': result, 'status': 'success'} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result, duration) return exec_result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'数据转换失败: {str(e)}' } elif node_type == 'loop' or node_type == 'foreach': # 循环节点：对数组进行循环处理 node_data = node.get('data', {}) items_path = node_data.get('items_path', 'items') # 数组数据路径 item_variable = node_data.get('item_variable', 'item') # 循环变量名 # 从输入数据中获取数组 items = self._get_nested_value(input_data, items_path) if not isinstance(items, list): if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, ValueError(f"路径 {items_path} 的值不是数组"), duration) return { 'output': None, 'status': 'failed', 'error': f'路径 {items_path} 的值不是数组，当前类型: {type(items).__name__}' } if self.logger: self.logger.info(f"循环节点开始处理 {len(items)} 个元素", node_id=node_id, node_type=node_type, data={"items_count": len(items)}) # 执行循环：对每个元素执行循环体 loop_results = [] for index, item in enumerate(items): if self.logger: self.logger.info(f"循环迭代 {index + 1}/{len(items)}", node_id=node_id, node_type=node_type, data={"index": index, "item": item}) # 准备循环体的输入数据 loop_input = { **input_data, # 保留原始输入数据 item_variable: item, # 当前循环项 f'{item_variable}_index': index, # 索引 f'{item_variable}_total': len(items) # 总数 } # 执行循环体（获取循环节点的子节点） loop_body_result = await self._execute_loop_body( node_id, loop_input, index ) if loop_body_result.get('status') == 'success': loop_results.append(loop_body_result.get('output', item)) else: # 如果循环体执行失败，可以选择继续或停止 error_handling = node_data.get('error_handling', 'continue') if error_handling == 'stop': if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, Exception(f"循环体执行失败，停止循环: {loop_body_result.get('error')}"), duration) return { 'output': None, 'status': 'failed', 'error': f'循环体执行失败: {loop_body_result.get("error")}', 'completed_items': index, 'results': loop_results } else: # continue: 继续执行，记录错误 if self.logger: self.logger.warn(f"循环迭代 {index + 1} 失败，继续执行", node_id=node_id, node_type=node_type, data={"error": loop_body_result.get('error')}) loop_results.append(None) exec_result = { 'output': loop_results, 'status': 'success', 'items_processed': len(items), 'results_count': len(loop_results) } if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, {'results_count': len(loop_results)}, duration) return exec_result elif node_type == 'http' or node_type == 'request': # HTTP请求节点：发送HTTP请求 node_data = node.get('data', {}) url = node_data.get('url', '') method = node_data.get('method', 'GET').upper() headers = node_data.get('headers', {}) params = node_data.get('params', {}) body = node_data.get('body', {}) timeout = node_data.get('timeout', 30) # 如果URL、headers、params、body中包含变量，从input_data中替换 import re def replace_variables(text: str, data: Dict[str, Any]) -> str: """替换字符串中的变量占位符""" if not isinstance(text, str): return text # 支持 {key} 或 ${key} 格式 pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) return str(value) if value is not None else match.group(0) return re.sub(pattern, replacer, text) # 替换URL中的变量 if url: url = replace_variables(url, input_data) # 替换headers中的变量 if isinstance(headers, dict): headers = {k: replace_variables(str(v), input_data) for k, v in headers.items()} elif isinstance(headers, str): try: headers = json.loads(replace_variables(headers, input_data)) except: headers = {} # 替换params中的变量 if isinstance(params, dict): params = {k: replace_variables(str(v), input_data) if isinstance(v, str) else v for k, v in params.items()} elif isinstance(params, str): try: params = json.loads(replace_variables(params, input_data)) except: params = {} # 替换body中的变量 if isinstance(body, dict): # 递归替换字典中的变量 def replace_dict_vars(d: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]: result = {} for k, v in d.items(): new_k = replace_variables(k, data) if isinstance(v, dict): result[new_k] = replace_dict_vars(v, data) elif isinstance(v, str): result[new_k] = replace_variables(v, data) else: result[new_k] = v return result body = replace_dict_vars(body, input_data) elif isinstance(body, str): body = replace_variables(body, input_data) try: body = json.loads(body) except: pass try: import httpx async with httpx.AsyncClient(timeout=timeout) as client: if method == 'GET': response = await client.get(url, params=params, headers=headers) elif method == 'POST': response = await client.post(url, json=body, params=params, headers=headers) elif method == 'PUT': response = await client.put(url, json=body, params=params, headers=headers) elif method == 'DELETE': response = await client.delete(url, params=params, headers=headers) elif method == 'PATCH': response = await client.patch(url, json=body, params=params, headers=headers) else: raise ValueError(f"不支持的HTTP方法: {method}") # 尝试解析JSON响应 try: response_data = response.json() except: response_data = response.text result = { 'output': { 'status_code': response.status_code, 'headers': dict(response.headers), 'data': response_data }, 'status': 'success' } if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'HTTP请求失败: {str(e)}' } elif node_type == 'database' or node_type == 'db': # 数据库操作节点：执行数据库操作 node_data = node.get('data', {}) data_source_id = node_data.get('data_source_id') operation = node_data.get('operation', 'query') # query/insert/update/delete sql = node_data.get('sql', '') table = node_data.get('table', '') data = node_data.get('data', {}) where = node_data.get('where', {}) # 如果SQL中包含变量，从input_data中替换 if sql and isinstance(sql, str): import re def replace_sql_vars(text: str, data: Dict[str, Any]) -> str: pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) if value is None: return match.group(0) # 如果是字符串，需要转义SQL注入 if isinstance(value, str): # 简单转义，实际应该使用参数化查询 escaped_value = value.replace("'", "''") return f"'{escaped_value}'" return str(value) return re.sub(pattern, replacer, text) sql = replace_sql_vars(sql, input_data) try: # 从数据库加载数据源配置 if not self.db: raise ValueError("数据库会话未提供，无法执行数据库操作") from app.models.data_source import DataSource from app.services.data_source_connector import create_connector data_source = self.db.query(DataSource).filter( DataSource.id == data_source_id ).first() if not data_source: raise ValueError(f"数据源不存在: {data_source_id}") connector = create_connector(data_source.type, data_source.config) if operation == 'query': # 查询操作 if not sql: raise ValueError("查询操作需要提供SQL语句") query_params = {'query': sql} result_data = connector.query(query_params) result = {'output': result_data, 'status': 'success'} elif operation == 'insert': # 插入操作 if not table: raise ValueError("插入操作需要提供表名") # 构建INSERT SQL columns = ', '.join(data.keys()) # 处理字符串值，转义单引号 def escape_value(v): if isinstance(v, str): escaped = v.replace("'", "''") return f"'{escaped}'" return str(v) values = ', '.join([escape_value(v) for v in data.values()]) insert_sql = f"INSERT INTO {table} ({columns}) VALUES ({values})" query_params = {'query': insert_sql} result_data = connector.query(query_params) result = {'output': {'affected_rows': 1, 'data': result_data}, 'status': 'success'} elif operation == 'update': # 更新操作 if not table or not where: raise ValueError("更新操作需要提供表名和WHERE条件") set_clause = ', '.join([f"{k} = '{v}'" if isinstance(v, str) else f"{k} = {v}" for k, v in data.items()]) where_clause = ' AND '.join([f"{k} = '{v}'" if isinstance(v, str) else f"{k} = {v}" for k, v in where.items()]) update_sql = f"UPDATE {table} SET {set_clause} WHERE {where_clause}" query_params = {'query': update_sql} result_data = connector.query(query_params) result = {'output': {'affected_rows': 1, 'data': result_data}, 'status': 'success'} elif operation == 'delete': # 删除操作 if not table or not where: raise ValueError("删除操作需要提供表名和WHERE条件") # 处理字符串值，转义单引号 def escape_sql_value(k, v): if isinstance(v, str): escaped = v.replace("'", "''") return f"{k} = '{escaped}'" return f"{k} = {v}" where_clause = ' AND '.join([escape_sql_value(k, v) for k, v in where.items()]) delete_sql = f"DELETE FROM {table} WHERE {where_clause}" query_params = {'query': delete_sql} result_data = connector.query(query_params) result = {'output': {'affected_rows': 1, 'data': result_data}, 'status': 'success'} else: raise ValueError(f"不支持的数据库操作: {operation}") if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'数据库操作失败: {str(e)}' } elif node_type == 'file' or node_type == 'file_operation': # 文件操作节点：文件读取、写入、上传、下载 node_data = node.get('data', {}) operation = node_data.get('operation', 'read') # read/write/upload/download file_path = node_data.get('file_path', '') content = node_data.get('content', '') encoding = node_data.get('encoding', 'utf-8') # 替换文件路径和内容中的变量 import re def replace_variables(text: str, data: Dict[str, Any]) -> str: """替换字符串中的变量占位符""" if not isinstance(text, str): return text pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) return str(value) if value is not None else match.group(0) return re.sub(pattern, replacer, text) if file_path: file_path = replace_variables(file_path, input_data) if isinstance(content, str): content = replace_variables(content, input_data) try: import os import json import base64 from pathlib import Path if operation == 'read': # 读取文件 if not file_path: raise ValueError("读取操作需要提供文件路径") if not os.path.exists(file_path): raise FileNotFoundError(f"文件不存在: {file_path}") # 根据文件扩展名决定读取方式 file_ext = Path(file_path).suffix.lower() if file_ext == '.json': with open(file_path, 'r', encoding=encoding) as f: data = json.load(f) elif file_ext in ['.txt', '.md', '.log']: with open(file_path, 'r', encoding=encoding) as f: data = f.read() else: # 二进制文件，返回base64编码 with open(file_path, 'rb') as f: data = base64.b64encode(f.read()).decode('utf-8') result = {'output': data, 'status': 'success'} elif operation == 'write': # 写入文件 if not file_path: raise ValueError("写入操作需要提供文件路径") # 确保目录存在 os.makedirs(os.path.dirname(file_path) if os.path.dirname(file_path) else '.', exist_ok=True) # 如果content是字典或列表，转换为JSON if isinstance(content, (dict, list)): content = json.dumps(content, ensure_ascii=False, indent=2) # 根据文件扩展名决定写入方式 file_ext = Path(file_path).suffix.lower() if file_ext == '.json': with open(file_path, 'w', encoding=encoding) as f: json.dump(json.loads(content) if isinstance(content, str) else content, f, ensure_ascii=False, indent=2) else: with open(file_path, 'w', encoding=encoding) as f: f.write(str(content)) result = {'output': {'file_path': file_path, 'message': '文件写入成功'}, 'status': 'success'} elif operation == 'upload': # 文件上传（从base64或URL上传） upload_type = node_data.get('upload_type', 'base64') # base64/url target_path = node_data.get('target_path', '') if upload_type == 'base64': # 从输入数据中获取base64编码的文件内容 file_data = input_data.get('file_data') or input_data.get('content') if not file_data: raise ValueError("上传操作需要提供file_data或content字段") # 解码base64 if isinstance(file_data, str): file_bytes = base64.b64decode(file_data) else: file_bytes = file_data # 写入目标路径 if not target_path: raise ValueError("上传操作需要提供target_path") os.makedirs(os.path.dirname(target_path) if os.path.dirname(target_path) else '.', exist_ok=True) with open(target_path, 'wb') as f: f.write(file_bytes) result = {'output': {'file_path': target_path, 'message': '文件上传成功'}, 'status': 'success'} else: # URL上传（下载后保存） import httpx url = node_data.get('url', '') if not url: raise ValueError("URL上传需要提供url") async with httpx.AsyncClient() as client: response = await client.get(url) response.raise_for_status() if not target_path: # 从URL提取文件名 target_path = os.path.basename(url) or 'downloaded_file' os.makedirs(os.path.dirname(target_path) if os.path.dirname(target_path) else '.', exist_ok=True) with open(target_path, 'wb') as f: f.write(response.content) result = {'output': {'file_path': target_path, 'message': '文件下载并保存成功'}, 'status': 'success'} elif operation == 'download': # 文件下载（返回base64编码或文件URL） download_format = node_data.get('download_format', 'base64') # base64/url if not file_path: raise ValueError("下载操作需要提供文件路径") if not os.path.exists(file_path): raise FileNotFoundError(f"文件不存在: {file_path}") if download_format == 'base64': # 返回base64编码 with open(file_path, 'rb') as f: file_bytes = f.read() file_base64 = base64.b64encode(file_bytes).decode('utf-8') result = {'output': {'file_name': os.path.basename(file_path), 'content': file_base64, 'format': 'base64'}, 'status': 'success'} else: # 返回文件路径（实际应用中可能需要生成临时URL） result = {'output': {'file_path': file_path, 'format': 'path'}, 'status': 'success'} else: raise ValueError(f"不支持的文件操作: {operation}") if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'文件操作失败: {str(e)}' } elif node_type == 'webhook': # Webhook节点：发送Webhook请求到外部系统 node_data = node.get('data', {}) url = node_data.get('url', '') method = node_data.get('method', 'POST').upper() headers = node_data.get('headers', {}) body = node_data.get('body', {}) timeout = node_data.get('timeout', 30) # 如果URL、headers、body中包含变量，从input_data中替换 import re def replace_variables(text: str, data: Dict[str, Any]) -> str: """替换字符串中的变量占位符""" if not isinstance(text, str): return text pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) return str(value) if value is not None else match.group(0) return re.sub(pattern, replacer, text) # 替换URL中的变量 if url: url = replace_variables(url, input_data) # 替换headers中的变量 if isinstance(headers, dict): headers = {k: replace_variables(str(v), input_data) for k, v in headers.items()} elif isinstance(headers, str): try: headers = json.loads(replace_variables(headers, input_data)) except: headers = {} # 替换body中的变量 if isinstance(body, dict): # 递归替换字典中的变量 def replace_dict_vars(d: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]: result = {} for k, v in d.items(): new_k = replace_variables(k, data) if isinstance(v, dict): result[new_k] = replace_dict_vars(v, data) elif isinstance(v, str): result[new_k] = replace_variables(v, data) else: result[new_k] = v return result body = replace_dict_vars(body, input_data) elif isinstance(body, str): body = replace_variables(body, input_data) try: body = json.loads(body) except: pass # 如果没有配置body，默认使用input_data作为body if not body: body = input_data try: import httpx async with httpx.AsyncClient(timeout=timeout) as client: if method == 'GET': response = await client.get(url, headers=headers) elif method == 'POST': response = await client.post(url, json=body, headers=headers) elif method == 'PUT': response = await client.put(url, json=body, headers=headers) elif method == 'PATCH': response = await client.patch(url, json=body, headers=headers) else: raise ValueError(f"Webhook不支持HTTP方法: {method}") # 尝试解析JSON响应 try: response_data = response.json() except: response_data = response.text result = { 'output': { 'status_code': response.status_code, 'headers': dict(response.headers), 'data': response_data }, 'status': 'success' } if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'Webhook请求失败: {str(e)}' } elif node_type == 'schedule' or node_type == 'delay' or node_type == 'timer': # 定时任务节点：延迟执行或定时执行 node_data = node.get('data', {}) delay_type = node_data.get('delay_type', 'fixed') # fixed: 固定延迟, cron: cron表达式 delay_value = node_data.get('delay_value', 0) # 延迟值（秒） delay_unit = node_data.get('delay_unit', 'seconds') # seconds, minutes, hours # 计算实际延迟时间（毫秒） if delay_unit == 'seconds': delay_ms = int(delay_value * 1000) elif delay_unit == 'minutes': delay_ms = int(delay_value * 60 * 1000) elif delay_unit == 'hours': delay_ms = int(delay_value * 60 * 60 * 1000) else: delay_ms = int(delay_value * 1000) # 如果延迟时间大于0，则等待 if delay_ms > 0: if self.logger: self.logger.info( f"定时任务节点等待 {delay_value} {delay_unit}", node_id=node_id, node_type=node_type, data={'delay_ms': delay_ms, 'delay_value': delay_value, 'delay_unit': delay_unit} ) await asyncio.sleep(delay_ms / 1000.0) # 返回输入数据（定时节点只是延迟，不改变数据） result = {'output': input_data, 'status': 'success', 'delay_ms': delay_ms} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result elif node_type == 'email' or node_type == 'mail': # 邮件节点：发送邮件通知 node_data = node.get('data', {}) smtp_host = node_data.get('smtp_host', '') smtp_port = node_data.get('smtp_port', 587) smtp_user = node_data.get('smtp_user', '') smtp_password = node_data.get('smtp_password', '') use_tls = node_data.get('use_tls', True) from_email = node_data.get('from_email', '') to_email = node_data.get('to_email', '') cc_email = node_data.get('cc_email', '') bcc_email = node_data.get('bcc_email', '') subject = node_data.get('subject', '') body = node_data.get('body', '') body_type = node_data.get('body_type', 'text') # text/html attachments = node_data.get('attachments', []) # 附件列表 # 替换变量 import re def replace_variables(text: str, data: Dict[str, Any]) -> str: """替换字符串中的变量占位符""" if not isinstance(text, str): return text pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) return str(value) if value is not None else match.group(0) return re.sub(pattern, replacer, text) # 替换所有配置中的变量 smtp_host = replace_variables(smtp_host, input_data) smtp_user = replace_variables(smtp_user, input_data) smtp_password = replace_variables(smtp_password, input_data) from_email = replace_variables(from_email, input_data) to_email = replace_variables(to_email, input_data) cc_email = replace_variables(cc_email, input_data) bcc_email = replace_variables(bcc_email, input_data) subject = replace_variables(subject, input_data) body = replace_variables(body, input_data) # 验证必需参数 if not smtp_host: raise ValueError("邮件节点需要配置SMTP服务器地址") if not from_email: raise ValueError("邮件节点需要配置发件人邮箱") if not to_email: raise ValueError("邮件节点需要配置收件人邮箱") if not subject: raise ValueError("邮件节点需要配置邮件主题") try: import aiosmtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.mime.base import MIMEBase from email import encoders import base64 import os # 创建邮件消息 msg = MIMEMultipart('alternative') msg['From'] = from_email msg['To'] = to_email if cc_email: msg['Cc'] = cc_email msg['Subject'] = subject # 添加邮件正文 if body_type == 'html': msg.attach(MIMEText(body, 'html', 'utf-8')) else: msg.attach(MIMEText(body, 'plain', 'utf-8')) # 处理附件 for attachment in attachments: if isinstance(attachment, dict): file_path = attachment.get('file_path', '') file_name = attachment.get('file_name', '') file_content = attachment.get('file_content', '') # base64编码的内容 # 替换变量 file_path = replace_variables(file_path, input_data) file_name = replace_variables(file_name, input_data) if file_path and os.path.exists(file_path): # 从文件路径读取 with open(file_path, 'rb') as f: file_data = f.read() if not file_name: file_name = os.path.basename(file_path) elif file_content: # 从base64内容读取 file_data = base64.b64decode(file_content) if not file_name: file_name = 'attachment' else: continue # 添加附件 part = MIMEBase('application', 'octet-stream') part.set_payload(file_data) encoders.encode_base64(part) part.add_header( 'Content-Disposition', f'attachment; filename= {file_name}' ) msg.attach(part) # 发送邮件 recipients = [to_email] if cc_email: recipients.extend([email.strip() for email in cc_email.split(',')]) if bcc_email: recipients.extend([email.strip() for email in bcc_email.split(',')]) async with aiosmtplib.SMTP(hostname=smtp_host, port=smtp_port) as smtp: if use_tls: await smtp.starttls() if smtp_user and smtp_password: await smtp.login(smtp_user, smtp_password) await smtp.send_message(msg, recipients=recipients) result = { 'output': { 'message': '邮件发送成功', 'from': from_email, 'to': to_email, 'subject': subject, 'recipients_count': len(recipients) }, 'status': 'success' } if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'邮件发送失败: {str(e)}' } elif node_type == 'message_queue' or node_type == 'mq' or node_type == 'rabbitmq' or node_type == 'kafka': # 消息队列节点：发送消息到RabbitMQ或Kafka node_data = node.get('data', {}) queue_type = node_data.get('queue_type', 'rabbitmq') # rabbitmq/kafka # 替换变量 import re def replace_variables(text: str, data: Dict[str, Any]) -> str: """替换字符串中的变量占位符""" if not isinstance(text, str): return text pattern = r'\{([^}]+)\}|\$\{([^}]+)\}' def replacer(match): key = match.group(1) or match.group(2) value = self._get_nested_value(data, key) return str(value) if value is not None else match.group(0) return re.sub(pattern, replacer, text) try: if queue_type == 'rabbitmq': # RabbitMQ实现 import aio_pika import json # 获取RabbitMQ配置 host = replace_variables(node_data.get('host', 'localhost'), input_data) port = node_data.get('port', 5672) username = replace_variables(node_data.get('username', 'guest'), input_data) password = replace_variables(node_data.get('password', 'guest'), input_data) exchange = replace_variables(node_data.get('exchange', ''), input_data) routing_key = replace_variables(node_data.get('routing_key', ''), input_data) queue_name = replace_variables(node_data.get('queue_name', ''), input_data) message = node_data.get('message', input_data) # 如果message是字符串，尝试替换变量 if isinstance(message, str): message = replace_variables(message, input_data) try: message = json.loads(message) except: pass elif isinstance(message, dict): # 递归替换字典中的变量 def replace_dict_vars(d: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]: result = {} for k, v in d.items(): new_k = replace_variables(k, data) if isinstance(v, dict): result[new_k] = replace_dict_vars(v, data) elif isinstance(v, str): result[new_k] = replace_variables(v, data) else: result[new_k] = v return result message = replace_dict_vars(message, input_data) # 如果没有配置message，使用input_data if not message: message = input_data # 连接RabbitMQ connection_url = f"amqp://{username}:{password}@{host}:{port}/" connection = await aio_pika.connect_robust(connection_url) channel = await connection.channel() # 发送消息 message_body = json.dumps(message, ensure_ascii=False).encode('utf-8') if exchange: # 使用exchange和routing_key await channel.default_exchange.publish( aio_pika.Message(message_body), routing_key=routing_key or queue_name ) elif queue_name: # 直接发送到队列 queue = await channel.declare_queue(queue_name, durable=True) await channel.default_exchange.publish( aio_pika.Message(message_body), routing_key=queue_name ) else: raise ValueError("RabbitMQ节点需要配置exchange或queue_name") await connection.close() result = { 'output': { 'message': '消息已发送到RabbitMQ', 'queue_type': 'rabbitmq', 'exchange': exchange, 'routing_key': routing_key or queue_name, 'queue_name': queue_name, 'message_size': len(message_body) }, 'status': 'success' } elif queue_type == 'kafka': # Kafka实现 from kafka import KafkaProducer import json # 获取Kafka配置 bootstrap_servers = replace_variables(node_data.get('bootstrap_servers', 'localhost:9092'), input_data) topic = replace_variables(node_data.get('topic', ''), input_data) message = node_data.get('message', input_data) # 如果message是字符串，尝试替换变量 if isinstance(message, str): message = replace_variables(message, input_data) try: message = json.loads(message) except: pass elif isinstance(message, dict): # 递归替换字典中的变量 def replace_dict_vars(d: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]: result = {} for k, v in d.items(): new_k = replace_variables(k, data) if isinstance(v, dict): result[new_k] = replace_dict_vars(v, data) elif isinstance(v, str): result[new_k] = replace_variables(v, data) else: result[new_k] = v return result message = replace_dict_vars(message, input_data) # 如果没有配置message，使用input_data if not message: message = input_data if not topic: raise ValueError("Kafka节点需要配置topic") # 创建Kafka生产者（注意：kafka-python是同步的，需要在线程池中运行） import asyncio from concurrent.futures import ThreadPoolExecutor def send_kafka_message(): producer = KafkaProducer( bootstrap_servers=bootstrap_servers.split(','), value_serializer=lambda v: json.dumps(v, ensure_ascii=False).encode('utf-8') ) future = producer.send(topic, message) record_metadata = future.get(timeout=10) producer.close() return record_metadata # 在线程池中执行同步操作 loop = asyncio.get_event_loop() with ThreadPoolExecutor() as executor: record_metadata = await loop.run_in_executor(executor, send_kafka_message) result = { 'output': { 'message': '消息已发送到Kafka', 'queue_type': 'kafka', 'topic': topic, 'partition': record_metadata.partition, 'offset': record_metadata.offset }, 'status': 'success' } else: raise ValueError(f"不支持的消息队列类型: {queue_type}") if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, result.get('output'), duration) return result except Exception as e: if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': f'消息队列发送失败: {str(e)}' } elif node_type == 'output' or node_type == 'end': # 输出节点：返回最终结果 # 对于人机交互场景，End节点应该返回纯文本字符串，而不是JSON logger.debug(f"[rjb] End节点处理: node_id={node_id}, input_data={input_data}, input_data type={type(input_data)}") final_output = input_data # 递归解包，提取实际的文本内容 if isinstance(input_data, dict): # 如果只有一个 key 且是 'input'，提取其值 if len(input_data) == 1 and 'input' in input_data: final_output = input_data['input'] logger.debug(f"[rjb] End节点提取第一层: final_output={final_output}, type={type(final_output)}") # 如果提取的值仍然是字典且只有一个 'input' key，继续提取 if isinstance(final_output, dict) and len(final_output) == 1 and 'input' in final_output: final_output = final_output['input'] logger.debug(f"[rjb] End节点提取第二层: final_output={final_output}, type={type(final_output)}") # 确保最终输出是字符串（对于人机交互场景） # 如果是字典，尝试转换为字符串；如果是其他类型，也转换为字符串 if not isinstance(final_output, str): if isinstance(final_output, dict): # 如果是字典，尝试提取文本内容或转换为JSON字符串 # 优先查找常见的文本字段 if 'text' in final_output: final_output = str(final_output['text']) elif 'content' in final_output: final_output = str(final_output['content']) elif 'message' in final_output: final_output = str(final_output['message']) elif 'response' in final_output: final_output = str(final_output['response']) elif len(final_output) == 1: # 如果只有一个key，直接使用其值 final_output = str(list(final_output.values())[0]) else: # 否则转换为JSON字符串 final_output = json_module.dumps(final_output, ensure_ascii=False) else: final_output = str(final_output) logger.debug(f"[rjb] End节点最终输出: final_output={final_output}, type={type(final_output)}") result = {'output': final_output, 'status': 'success'} if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_complete(node_id, node_type, final_output, duration) return result else: # 未知节点类型 return { 'output': input_data, 'status': 'success', 'message': f'节点类型 {node_type} 暂未实现' } except Exception as e: logger.error(f"节点执行失败: {node_id} ({node_type}) - {str(e)}", exc_info=True) if self.logger: duration = int((time.time() - start_time) * 1000) self.logger.log_node_error(node_id, node_type, e, duration) return { 'output': None, 'status': 'failed', 'error': str(e), 'node_id': node_id, 'node_type': node_type } async def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]: """ 执行完整工作流 Args: input_data: 初始输入数据 Returns: 执行结果 """ # 记录工作流开始执行 if self.logger: self.logger.info("工作流开始执行", data={"input": input_data}) # 初始化节点输出 self.node_outputs = {} active_edges = self.edges.copy() # 活跃的边列表 executed_nodes = set() # 已执行的节点 # 按拓扑顺序执行节点（动态构建执行图） results = {} while True: # 构建当前活跃的执行图 execution_order = self.build_execution_graph(active_edges) # 找到下一个要执行的节点（未执行且入度为0） next_node_id = None for node_id in execution_order: if node_id not in executed_nodes: # 检查所有前置节点是否已执行 can_execute = True for edge in active_edges: if edge['target'] == node_id: if edge['source'] not in executed_nodes: can_execute = False break if can_execute: next_node_id = node_id break if not next_node_id: break # 没有更多节点可执行 node = self.nodes[next_node_id] executed_nodes.add(next_node_id) # 调试：检查节点数据结构 if node.get('type') == 'llm': logger.debug(f"[rjb] 执行LLM节点: node_id={next_node_id}, node keys={list(node.keys())}, data keys={list(node.get('data', {}).keys()) if node.get('data') else []}") # 获取节点输入（使用活跃的边） node_input = self.get_node_input(next_node_id, self.node_outputs, active_edges) # 如果是起始节点，使用初始输入 if node.get('type') == 'start' and not node_input: node_input = input_data # 调试：记录节点输入数据 if node.get('type') == 'llm': logger.debug(f"[rjb] LLM节点输入: node_id={next_node_id}, node_input={node_input}, node_outputs keys={list(self.node_outputs.keys())}") # 执行节点 result = await self.execute_node(node, node_input) results[next_node_id] = result # 保存节点输出 if result.get('status') == 'success': self.node_outputs[next_node_id] = result.get('output', {}) # 如果是条件节点，根据分支结果过滤边 if node.get('type') == 'condition': branch = result.get('branch', 'false') # 移除不符合条件的边 active_edges = [ edge for edge in active_edges if not (edge['source'] == next_node_id and edge.get('sourceHandle') != branch) ] # 如果是循环节点，跳过循环体的节点（循环体已在节点内部执行） if node.get('type') in ['loop', 'foreach']: # 标记循环体的节点为已执行（简化处理） for edge in active_edges[:]: # 使用切片复制列表 if edge.get('source') == next_node_id: target_id = edge.get('target') if target_id in self.nodes: # 检查是否是循环结束节点 target_node = self.nodes[target_id] if target_node.get('type') not in ['loop_end', 'end']: # 标记为已执行（循环体已在循环节点内部执行） executed_nodes.add(target_id) # 继续查找循环体内的节点 self._mark_loop_body_executed(target_id, executed_nodes, active_edges) else: # 执行失败，停止工作流 error_msg = result.get('error', '未知错误') node_type = node.get('type', 'unknown') logger.error(f"工作流执行失败 - 节点: {next_node_id} ({node_type}), 错误: {error_msg}") raise WorkflowExecutionError( detail=error_msg, node_id=next_node_id ) # 返回最终结果（最后一个执行的节点的输出） if executed_nodes: # 找到最后一个节点（没有出边的节点） last_node_id = None for node_id in executed_nodes: has_outgoing = any(edge['source'] == node_id for edge in active_edges) if not has_outgoing: last_node_id = node_id break if not last_node_id: # 如果没有找到，使用最后一个执行的节点 last_node_id = list(executed_nodes)[-1] # 获取最终结果 final_output = self.node_outputs.get(last_node_id) # 如果最终输出是字典且只有一个 'input' key，提取其值 # 这样可以确保最终结果不是重复包装的格式 if isinstance(final_output, dict) and len(final_output) == 1 and 'input' in final_output: final_output = final_output['input'] # 如果提取的值仍然是字典且只有一个 'input' key，继续提取 if isinstance(final_output, dict) and len(final_output) == 1 and 'input' in final_output: final_output = final_output['input'] # 确保最终结果是字符串（对于人机交互场景） # 如果是字典，尝试转换为字符串；如果是其他类型，也转换为字符串 if not isinstance(final_output, str): if isinstance(final_output, dict): # 如果是字典，尝试提取文本内容或转换为JSON字符串 # 优先查找常见的文本字段 if 'text' in final_output: final_output = str(final_output['text']) elif 'content' in final_output: final_output = str(final_output['content']) elif 'message' in final_output: final_output = str(final_output['message']) elif 'response' in final_output: final_output = str(final_output['response']) elif len(final_output) == 1: # 如果只有一个key，直接使用其值 final_output = str(list(final_output.values())[0]) else: # 否则转换为JSON字符串 final_output = json_module.dumps(final_output, ensure_ascii=False) else: final_output = str(final_output) final_result = { 'status': 'completed', 'result': final_output, 'node_results': results } # 记录工作流执行完成 if self.logger: self.logger.info("工作流执行完成", data={"result": final_result.get('result')}) return final_result if self.logger: self.logger.warn("工作流执行完成，但没有执行任何节点") return {'status': 'completed', 'result': None}