@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/engine/node-registry.ts

@@ -0,0 +1,289 @@
+/**
+ * @fileoverview NodeRegistry - Registry for creating Node instances
+ * 
+ * NodeRegistry manages node creation from NodeDefinition instances.
+ * It provides:
+ * - Built-in node types: tool, skill, agent, workflow
+ * - Custom node type registration via factory functions
+ * - Node creation based on node type
+ */
+
+import type { Node, NodeDefinition, NodeExecutionContext } from '../types/index';
+import { EventBus } from './event-bus';
+import { ToolNode } from '../nodes/tool-node';
+import type { ToolRegistry } from '../nodes/tool-node';
+import { SkillNode } from '../nodes/skill-node';
+import type { SkillRegistry } from '../nodes/skill-node';
+import { AgentNode } from '../nodes/agent-node';
+import type { AgentRunner } from '../nodes/agent-node';
+import { AgentComponentAdapter } from '../nodes/agent-component-adapter';
+import { WorkflowNode } from '../nodes/workflow-node';
+import type { WorkflowRunner } from '../nodes/workflow-node';
+
+// AgentComponent 类型（可选依赖）
+import type { AgentComponent } from '../../agent/agent-component';
+import type { SessionComponent } from '../../session/session-component';
+import { AskUserNode } from '../nodes/ask-user-node';
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+/**
+ * NodeRegistry initialization options
+ */
+export interface NodeRegistryOptions {
+  /** Registry for looking up tools */
+  toolRegistry?: ToolRegistry;
+  /** Registry for looking up skills */
+  skillRegistry?: SkillRegistry;
+  /** AgentComponent for executing agent nodes (auto-creates adapter) */
+  agentComponent?: AgentComponent;
+  /** Explicit AgentRunner (takes precedence over agentComponent) */
+  agentRunner?: AgentRunner;
+  /** Runner for executing workflow nodes */
+  workflowRunner?: WorkflowRunner;
+  /** Session component for agent session management */
+  sessionComponent?: SessionComponent;
+  /** @deprecated Use agentRunner instead */
+  agentRunner2?: AgentRunner;
+}
+
+/**
+ * NodeContext for node creation
+ * 
+ * Context information passed to node factories when creating nodes.
+ */
+export interface NodeContext {
+  /** Run ID for this workflow execution */
+  runId: string;
+  /** Workflow name */
+  workflowName: string;
+  /** Event bus for workflow events */
+  eventBus: EventBus;
+  /** Debug mode flag */
+  debug: boolean;
+}
+
+/**
+ * NodeFactory function type
+ * 
+ * Factory function that creates a Node instance from a NodeDefinition.
+ */
+export type NodeFactory = (
+  definition: NodeDefinition,
+  context: NodeContext
+) => Node;
+
+// ============================================================================
+// NodeRegistry Class
+// ============================================================================
+
+/**
+ * NodeRegistry
+ * 
+ * Registry for creating Node instances from NodeDefinition.
+ * 
+ * Features:
+ * - Built-in node types: tool, skill, agent, workflow
+ * - Custom node type registration via factory functions
+ * - Node creation based on node type
+ * 
+ * @example
+ * ```typescript
+ * const registry = new NodeRegistry(
+ *   toolRegistry,
+ *   skillRegistry,
+ *   agentRunner,
+ *   workflowRunner
+ * );
+ * 
+ * // Register custom node type
+ * registry.register('custom', (definition, context) => {
+ *   return new CustomNode(definition);
+ * });
+ * 
+ * // Create node from definition
+ * const node = registry.createNode(definition);
+ * ```
+ */
+export class NodeRegistry {
+  /** Map of registered node factories by type */
+  private factories: Map<string, NodeFactory> = new Map();
+  
+  /** Tool registry for looking up tools */
+  private toolRegistry?: ToolRegistry;
+  
+  /** Skill registry for looking up skills */
+  private skillRegistry?: SkillRegistry;
+  
+  /** Agent runner for executing agent nodes */
+  private agentRunner?: AgentRunner;
+  
+  /** Workflow runner for executing workflow nodes */
+  private workflowRunner?: WorkflowRunner;
+  
+  /** AgentComponent adapter (auto-created if agentComponent is provided) */
+  private agentComponentAdapter?: AgentComponentAdapter;
+  
+  /** Session component for agent session management */
+  private sessionComponent?: SessionComponent;
+
+  /**
+   * Create a new NodeRegistry
+   * 
+   * @param options - Registry options
+   * @param options.toolRegistry - Registry for looking up tools (optional)
+   * @param options.skillRegistry - Registry for looking up skills (optional)
+   * @param options.agentComponent - AgentComponent for executing agent nodes (optional, auto-creates adapter)
+   * @param options.agentRunner - Explicit AgentRunner (takes precedence over agentComponent)
+   * @param options.workflowRunner - Runner for executing workflow nodes (optional)
+   * @param options.sessionComponent - Session component for agent session management (optional)
+   */
+  constructor(options?: NodeRegistryOptions) {
+    const {
+      toolRegistry,
+      skillRegistry,
+      agentComponent,
+      agentRunner,
+      workflowRunner,
+      sessionComponent,
+    } = options ?? {};
+    
+    // Store registries
+    this.toolRegistry = toolRegistry;
+    this.skillRegistry = skillRegistry;
+    this.workflowRunner = workflowRunner;
+    this.sessionComponent = sessionComponent;
+    
+    // Create AgentRunner: 
+    // 1. Use explicit agentRunner if provided
+    // 2. Otherwise, auto-create from agentComponent if provided
+    if (agentRunner) {
+      this.agentRunner = agentRunner;
+      // If agentRunner is an AgentComponentAdapter, set session component
+      if (agentRunner.setSessionComponent && sessionComponent) {
+        agentRunner.setSessionComponent(sessionComponent);
+      }
+    } else if (agentComponent) {
+      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
+      this.agentRunner = this.agentComponentAdapter;
+    }
+    
+    // Register built-in node types
+    this.registerBuiltInTypes();
+  }
+  
+  /**
+   * Get the AgentComponentAdapter if available
+   */
+  getAgentAdapter(): AgentComponentAdapter | undefined {
+    return (this as any).agentComponentAdapter;
+  }
+  
+  /**
+   * Get the AgentRunner
+   */
+  getAgentRunner(): AgentRunner | undefined {
+    return (this as any).agentRunner;
+  }
+  
+  /**
+   * Get the SessionComponent
+   */
+  getSessionComponent(): SessionComponent | undefined {
+    return (this as any).sessionComponent;
+  }
+
+  /**
+   * Register built-in node types
+   */
+  private registerBuiltInTypes(): void {
+    // Register 'tool' node type
+    this.factories.set('tool', (definition) => {
+      if (!this.toolRegistry) {
+        throw new Error('ToolRegistry is required for tool nodes');
+      }
+      return new ToolNode(definition, this.toolRegistry);
+    });
+
+    // Register 'skill' node type
+    this.factories.set('skill', (definition) => {
+      if (!this.skillRegistry) {
+        throw new Error('SkillRegistry is required for skill nodes');
+      }
+      return new SkillNode(definition, this.skillRegistry);
+    });
+
+    // Register 'agent' node type
+    this.factories.set('agent', (definition) => {
+      if (!this.agentRunner) {
+        throw new Error('AgentRunner is required for agent nodes');
+      }
+      return new AgentNode(definition, this.agentRunner);
+    });
+
+    // Register 'workflow' node type
+    this.factories.set('workflow', (definition) => {
+      if (!this.workflowRunner) {
+        throw new Error('WorkflowRunner is required for workflow nodes');
+      }
+      return new WorkflowNode(definition, this.workflowRunner);
+    });
+
+    // Register 'ask_user' node type
+    this.factories.set('ask_user', (definition) => {
+      return new AskUserNode(definition);
+    });
+  }
+
+  /**
+   * Register a custom node factory
+   * 
+   * @param type - Node type identifier
+   * @param factory - Factory function to create nodes of this type
+   */
+  register(type: string, factory: NodeFactory): void {
+    this.factories.set(type, factory);
+  }
+
+  /**
+   * Check if a node type is registered
+   * 
+   * @param type - Node type identifier
+   * @returns True if the type is registered
+   */
+  has(type: string): boolean {
+    return this.factories.has(type);
+  }
+
+  /**
+   * List all registered node types
+   * 
+   * @returns Array of registered type names
+   */
+  list(): string[] {
+    return Array.from(this.factories.keys());
+  }
+
+  /**
+   * Create a Node instance from a NodeDefinition
+   * 
+   * @param definition - Node definition
+   * @param context - Node context (optional, for future use)
+   * @returns Node instance
+   * @throws Error if the node type is not registered
+   */
+  createNode(definition: NodeDefinition, context?: NodeContext): Node {
+    const factory = this.factories.get(definition.type);
+
+    if (!factory) {
+      const availableTypes = this.list().join(', ');
+      throw new Error(
+        `Unknown node type: ${definition.type}. Available types: ${availableTypes}`
+      );
+    }
+
+    return factory(definition, context!);
+  }
+}

package/src/env/workflow/engine/resume-removed.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { WorkflowEngine } from './engine';
+
+describe('resume() method', () => {
+  it('should have resume method for pausing recovery', () => {
+    // In the session-based design, resume() is used to recover from pauses
+    expect(typeof WorkflowEngine.prototype.resume).toBe('function');
+  });
+  
+  it('should still have run method for unified run/resume', () => {
+    // The unified run() method handles both fresh start and resume
+    expect(typeof WorkflowEngine.prototype.run).toBe('function');
+  });
+  
+  it('should still have stop method', () => {
+    expect(typeof WorkflowEngine.prototype.stop).toBe('function');
+  });
+  
+  it('should still have pause method', () => {
+    expect(typeof WorkflowEngine.prototype.pause).toBe('function');
+  });
+});