@louloulinx/metagpt 0.1.3

package/src/workflow/executor.ts

@@ -0,0 +1,193 @@
+import { EventEmitter } from 'events';
+import type { 
+  WorkflowExecutor, 
+  WorkflowConfig, 
+  WorkflowState,
+  WorkflowNode,
+  NodeExecutor,
+  WorkflowEvent
+} from '../types/workflow';
+import { 
+  WorkflowStateSchema, 
+  WorkflowNodeSchema,
+  WorkflowEventSchema 
+} from '../types/workflow';
+import { generateId } from '../utils/common';
+
+/**
+ * 基础工作流执行器实现
+ */
+export class BaseWorkflowExecutor extends EventEmitter implements WorkflowExecutor {
+  private config!: WorkflowConfig;
+  private state!: WorkflowState;
+  private nodeExecutors: Map<string, NodeExecutor>;
+  private isPaused: boolean = false;
+  private isStopped: boolean = false;
+
+  constructor() {
+    super();
+    this.nodeExecutors = new Map();
+  }
+
+  /**
+   * 注册节点执行器
+   * @param type 节点类型
+   * @param executor 执行器实例
+   */
+  public registerNodeExecutor(type: string, executor: NodeExecutor): void {
+    this.nodeExecutors.set(type, executor);
+  }
+
+  /**
+   * 执行工作流
+   * @param config 工作流配置
+   */
+  public async execute(config: WorkflowConfig): Promise<void> {
+    this.config = config;
+    this.state = WorkflowStateSchema.parse({
+      id: config.id,
+      status: 'running',
+    });
+
+    this.emit('workflow:start', this.createEvent('workflow:start'));
+
+    try {
+      await this.executeNode(this.findStartNode());
+      
+      if (!this.isStopped) {
+        this.state.status = 'completed';
+        this.emit('workflow:complete', this.createEvent('workflow:complete'));
+      }
+    } catch (error) {
+      this.state.status = 'failed';
+      this.emit('workflow:fail', this.createEvent('workflow:fail', { error }));
+      throw error;
+    }
+  }
+
+  /**
+   * 暂停工作流
+   */
+  public async pause(): Promise<void> {
+    this.isPaused = true;
+  }
+
+  /**
+   * 恢复工作流
+   */
+  public async resume(): Promise<void> {
+    this.isPaused = false;
+    if (this.state.currentNodeId) {
+      await this.executeNode(this.findNodeById(this.state.currentNodeId));
+    }
+  }
+
+  /**
+   * 停止工作流
+   */
+  public async stop(): Promise<void> {
+    this.isStopped = true;
+  }
+
+  /**
+   * 获取工作流状态
+   */
+  public getState(): WorkflowState {
+    return this.state;
+  }
+
+  /**
+   * 执行节点
+   * @param node 工作流节点
+   */
+  private async executeNode(node: WorkflowNode): Promise<void> {
+    if (this.isStopped) return;
+
+    while (this.isPaused) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
+    this.state.currentNodeId = node.id;
+    this.emit('node:start', this.createEvent('node:start', { nodeId: node.id }));
+
+    try {
+      const executor = this.nodeExecutors.get(node.type);
+      if (!executor) {
+        throw new Error(`No executor found for node type: ${node.type}`);
+      }
+
+      if (!executor.validate(node)) {
+        throw new Error(`Invalid node configuration: ${node.id}`);
+      }
+
+      const result = await executor.execute(node, {
+        workflow: this.config,
+        state: this.state,
+      });
+
+      node.status = 'completed';
+      node.result = result;
+      this.state.completedNodeIds.push(node.id);
+      
+      this.emit('node:complete', this.createEvent('node:complete', {
+        nodeId: node.id,
+        data: result,
+      }));
+
+      // 执行子节点
+      for (const childId of node.childIds) {
+        await this.executeNode(this.findNodeById(childId));
+      }
+    } catch (error) {
+      node.status = 'failed';
+      this.state.failedNodeIds.push(node.id);
+      
+      this.emit('node:fail', this.createEvent('node:fail', {
+        nodeId: node.id,
+        error,
+      }));
+      
+      throw error;
+    }
+  }
+
+  /**
+   * 查找起始节点
+   */
+  private findStartNode(): WorkflowNode {
+    const startNode = this.config.nodes.find(node => !node.parentId);
+    if (!startNode) {
+      throw new Error('No start node found in workflow');
+    }
+    return startNode;
+  }
+
+  /**
+   * 根据ID查找节点
+   * @param id 节点ID
+   */
+  private findNodeById(id: string): WorkflowNode {
+    const node = this.config.nodes.find(node => node.id === id);
+    if (!node) {
+      throw new Error(`Node not found: ${id}`);
+    }
+    return node;
+  }
+
+  /**
+   * 创建工作流事件
+   * @param type 事件类型
+   * @param data 事件数据
+   */
+  private createEvent(
+    type: WorkflowEvent['type'],
+    data: Partial<WorkflowEvent> = {}
+  ): WorkflowEvent {
+    return WorkflowEventSchema.parse({
+      type,
+      timestamp: Date.now(),
+      workflowId: this.config.id,
+      ...data,
+    });
+  }
+} 

package/src/workflow/executors/action-executor.ts

@@ -0,0 +1,72 @@
+import type { NodeExecutor, WorkflowNode } from '../../types/workflow';
+import type { Action, ActionOutput } from '../../types/action';
+
+/**
+ * 动作节点执行器
+ * 用于执行动作类型的工作流节点
+ */
+export class ActionNodeExecutor implements NodeExecutor {
+  private status: string = 'pending';
+  private result: any = null;
+
+  /**
+   * 执行动作节点
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  async execute(node: WorkflowNode, context: any): Promise<ActionOutput> {
+    try {
+      this.status = 'running';
+      
+      // 获取动作实例
+      const action = this.getAction(node);
+      if (!action) {
+        throw new Error(`Action not found in node: ${node.id}`);
+      }
+
+      // 执行动作
+      const result = await action.run();
+      this.result = result;
+      this.status = 'completed';
+      
+      return result;
+    } catch (error) {
+      this.status = 'failed';
+      this.result = error;
+      throw error;
+    }
+  }
+
+  /**
+   * 验证节点配置
+   * @param node 工作流节点
+   */
+  validate(node: WorkflowNode): boolean {
+    return (
+      node.type === 'action' &&
+      !!node.config?.action
+    );
+  }
+
+  /**
+   * 获取节点状态
+   */
+  getStatus(): string {
+    return this.status;
+  }
+
+  /**
+   * 获取执行结果
+   */
+  getResult(): any {
+    return this.result;
+  }
+
+  /**
+   * 从节点配置中获取动作实例
+   * @param node 工作流节点
+   */
+  private getAction(node: WorkflowNode): Action | undefined {
+    return node.config?.action as Action;
+  }
+} 

package/src/workflow/executors/condition-executor.ts

@@ -0,0 +1,118 @@
+import type { NodeExecutor, WorkflowNode } from '../../types/workflow';
+
+/**
+ * 条件节点配置
+ */
+interface ConditionConfig {
+  /** 条件表达式 */
+  expression: string;
+  /** 条件参数 */
+  params?: Record<string, any>;
+  /** 条件处理函数 */
+  handler?: (params: Record<string, any>) => boolean | Promise<boolean>;
+}
+
+/**
+ * 条件节点执行器
+ * 用于执行条件类型的工作流节点
+ */
+export class ConditionNodeExecutor implements NodeExecutor {
+  private status: string = 'pending';
+  private result: any = null;
+
+  /**
+   * 执行条件节点
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  async execute(node: WorkflowNode, context: any): Promise<boolean> {
+    try {
+      this.status = 'running';
+      
+      // 获取条件配置
+      const config = this.getConditionConfig(node);
+      if (!config) {
+        throw new Error(`Condition config not found in node: ${node.id}`);
+      }
+
+      // 执行条件判断
+      const result = await this.evaluateCondition(config, context);
+      this.result = result;
+      this.status = 'completed';
+      
+      return result;
+    } catch (error) {
+      this.status = 'failed';
+      this.result = error;
+      throw error;
+    }
+  }
+
+  /**
+   * 验证节点配置
+   * @param node 工作流节点
+   */
+  validate(node: WorkflowNode): boolean {
+    const config = this.getConditionConfig(node);
+    return (
+      node.type === 'condition' &&
+      !!config &&
+      (!!config.expression || !!config.handler)
+    );
+  }
+
+  /**
+   * 获取节点状态
+   */
+  getStatus(): string {
+    return this.status;
+  }
+
+  /**
+   * 获取执行结果
+   */
+  getResult(): any {
+    return this.result;
+  }
+
+  /**
+   * 从节点配置中获取条件配置
+   * @param node 工作流节点
+   */
+  private getConditionConfig(node: WorkflowNode): ConditionConfig | undefined {
+    return node.config?.condition as ConditionConfig;
+  }
+
+  /**
+   * 执行条件判断
+   * @param config 条件配置
+   * @param context 执行上下文
+   */
+  private async evaluateCondition(
+    config: ConditionConfig,
+    context: any
+  ): Promise<boolean> {
+    try {
+      // 如果提供了处理函数，优先使用处理函数
+      if (config.handler) {
+        return await config.handler(config.params || {});
+      }
+
+      // 否则使用表达式求值
+      const params = {
+        ...config.params,
+        context,
+      };
+      
+      // 使用 Function 构造函数创建表达式求值函数
+      const evaluator = new Function(
+        ...Object.keys(params),
+        `return ${config.expression};`
+      );
+      
+      return evaluator(...Object.values(params));
+    } catch (error) {
+      throw new Error(`Failed to evaluate condition: ${error}`);
+    }
+  }
+} 

package/src/workflow/executors/parallel-executor.ts

@@ -0,0 +1,201 @@
+import type { NodeExecutor, WorkflowNode } from '../../types/workflow';
+
+/**
+ * 并行节点配置
+ */
+interface ParallelConfig {
+  /** 最大并发数 */
+  maxConcurrency?: number;
+  /** 错误处理策略 */
+  errorStrategy?: 'fail-fast' | 'continue' | 'ignore';
+  /** 超时时间(ms) */
+  timeout?: number;
+}
+
+/**
+ * 并行节点执行器
+ * 用于并行执行多个子节点
+ */
+export class ParallelNodeExecutor implements NodeExecutor {
+  private status: string = 'pending';
+  private result: any = null;
+
+  /**
+   * 执行并行节点
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  async execute(node: WorkflowNode, context: any): Promise<any[]> {
+    try {
+      this.status = 'running';
+      
+      // 获取并行配置
+      const config = this.getParallelConfig(node);
+      
+      // 获取子节点执行器
+      const childExecutors = this.getChildExecutors(node, context);
+      if (childExecutors.length === 0) {
+        throw new Error(`No child nodes found in parallel node: ${node.id}`);
+      }
+
+      // 执行子节点
+      const results = await this.executeParallel(childExecutors, config);
+      this.result = results;
+      this.status = 'completed';
+      
+      return results;
+    } catch (error) {
+      this.status = 'failed';
+      this.result = error;
+      throw error;
+    }
+  }
+
+  /**
+   * 验证节点配置
+   * @param node 工作流节点
+   */
+  validate(node: WorkflowNode): boolean {
+    return (
+      node.type === 'parallel' &&
+      Array.isArray(node.childIds) &&
+      node.childIds.length > 0
+    );
+  }
+
+  /**
+   * 获取节点状态
+   */
+  getStatus(): string {
+    return this.status;
+  }
+
+  /**
+   * 获取执行结果
+   */
+  getResult(): any {
+    return this.result;
+  }
+
+  /**
+   * 从节点配置中获取并行配置
+   * @param node 工作流节点
+   */
+  private getParallelConfig(node: WorkflowNode): ParallelConfig {
+    return {
+      maxConcurrency: Infinity,
+      errorStrategy: 'fail-fast',
+      timeout: 0,
+      ...(node.config?.parallel || {}),
+    };
+  }
+
+  /**
+   * 获取子节点执行器列表
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  private getChildExecutors(
+    node: WorkflowNode,
+    context: any
+  ): Array<() => Promise<any>> {
+    return node.childIds.map(childId => {
+      const childNode = context.workflow.nodes.find(
+        (n: WorkflowNode) => n.id === childId
+      );
+      if (!childNode) {
+        throw new Error(`Child node not found: ${childId}`);
+      }
+
+      const executor = context.workflow.nodeExecutors.get(childNode.type);
+      if (!executor) {
+        throw new Error(`No executor found for node type: ${childNode.type}`);
+      }
+
+      return () => executor.execute(childNode, context);
+    });
+  }
+
+  /**
+   * 并行执行子节点
+   * @param executors 执行器列表
+   * @param config 并行配置
+   */
+  private async executeParallel(
+    executors: Array<() => Promise<any>>,
+    config: ParallelConfig
+  ): Promise<any[]> {
+    const results: any[] = [];
+    const errors: Error[] = [];
+
+    // 创建执行队列
+    const queue = [...executors];
+    const running = new Set<Promise<void>>();
+
+    while (queue.length > 0 || running.size > 0) {
+      // 检查是否可以启动新的执行器
+      while (
+        queue.length > 0 &&
+        running.size < (config.maxConcurrency || Infinity)
+      ) {
+        const executor = queue.shift()!;
+        const promise = (async () => {
+          try {
+            const result = await this.executeWithTimeout(
+              executor(),
+              config.timeout
+            );
+            results.push(result);
+          } catch (error) {
+            errors.push(error as Error);
+            if (config.errorStrategy === 'fail-fast') {
+              queue.length = 0; // 清空队列
+              throw error;
+            }
+          }
+        })();
+
+        running.add(promise);
+        // 执行完成后从运行集合中移除
+        promise.finally(() => running.delete(promise));
+      }
+
+      // 等待任意一个执行器完成
+      if (running.size > 0) {
+        await Promise.race(running);
+      }
+    }
+
+    // 处理错误
+    if (errors.length > 0 && config.errorStrategy !== 'ignore') {
+      throw new AggregateError(
+        errors,
+        `${errors.length} parallel executions failed`
+      );
+    }
+
+    return results;
+  }
+
+  /**
+   * 带超时的执行
+   * @param promise Promise
+   * @param timeout 超时时间
+   */
+  private async executeWithTimeout<T>(
+    promise: Promise<T>,
+    timeout?: number
+  ): Promise<T> {
+    if (!timeout || timeout <= 0) {
+      return promise;
+    }
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timed out after ${timeout}ms`));
+      }, timeout);
+    });
+
+    return Promise.race([promise, timeoutPromise]);
+  }
+} 

package/src/workflow/executors/role-executor.ts

@@ -0,0 +1,76 @@
+import type { NodeExecutor, WorkflowNode } from '../../types/workflow';
+import type { Role } from '../../types/role';
+import type { Message } from '../../types/message';
+
+/**
+ * 角色节点执行器
+ * 用于执行角色类型的工作流节点
+ */
+export class RoleNodeExecutor implements NodeExecutor {
+  private status: string = 'pending';
+  private result: any = null;
+
+  /**
+   * 执行角色节点
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  async execute(node: WorkflowNode, context: any): Promise<Message> {
+    try {
+      this.status = 'running';
+      
+      // 获取角色实例
+      const role = this.getRole(node);
+      if (!role) {
+        throw new Error(`Role not found in node: ${node.id}`);
+      }
+
+      // 执行角色行为
+      await role.observe();
+      await role.think();
+      const result = await role.act();
+      
+      this.result = result;
+      this.status = 'completed';
+      
+      return result;
+    } catch (error) {
+      this.status = 'failed';
+      this.result = error;
+      throw error;
+    }
+  }
+
+  /**
+   * 验证节点配置
+   * @param node 工作流节点
+   */
+  validate(node: WorkflowNode): boolean {
+    return (
+      node.type === 'role' &&
+      !!node.config?.role
+    );
+  }
+
+  /**
+   * 获取节点状态
+   */
+  getStatus(): string {
+    return this.status;
+  }
+
+  /**
+   * 获取执行结果
+   */
+  getResult(): any {
+    return this.result;
+  }
+
+  /**
+   * 从节点配置中获取角色实例
+   * @param node 工作流节点
+   */
+  private getRole(node: WorkflowNode): Role | undefined {
+    return node.config?.role as Role;
+  }
+}