@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/workflow/nodes/condition-node.ts

@@ -1,200 +0,0 @@
-/**
- * @fileoverview ConditionNode - Workflow condition node
- * 
- * Evaluates a condition and decides whether to proceed or skip.
- * 
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-
-import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
-
-/**
- * ConditionNode evaluates a condition and returns the result.
- * 
- * The condition can be:
- * - A boolean value
- * - A template expression that evaluates to a boolean
- * - A template reference to a previous node's output
- * 
- * Usage in workflow:
- * ```yaml
- * nodes:
- *   - id: check-tests-pass
- *     type: condition
- *     config:
- *       condition: "{{run-unit-tests.success}}"
- *     depends_on:
- *       - run-unit-tests
- * ```
- */
-export class ConditionNode implements Node {
-  readonly type = 'condition';
-  readonly id: string;
-  
-  constructor(
-    private definition: NodeDefinition,
-  ) {
-    this.id = definition.id;
-  }
-  
-  async execute(context: NodeExecutionContext): Promise<NodeExecutionResult> {
-    const startTime = Date.now();
-    
-    try {
-      // Get condition from config
-      const conditionConfig = this.definition.config?.condition;
-      
-      if (conditionConfig === undefined) {
-        // No condition specified, default to true (pass through)
-        return {
-          output: { success: true, condition: true },
-          error: undefined,
-          durationMs: Date.now() - startTime,
-        };
-      }
-      
-      // Resolve template references in the condition
-      const resolvedCondition = this.resolveCondition(conditionConfig, context);
-      
-      // Evaluate the condition
-      const result = this.evaluateCondition(resolvedCondition);
-      
-      return {
-        output: { success: result, condition: resolvedCondition },
-        error: undefined,
-        durationMs: Date.now() - startTime,
-      };
-    } catch (error) {
-      return {
-        output: undefined,
-        error: error instanceof Error ? error : new Error(String(error)),
-        durationMs: Date.now() - startTime,
-      };
-    }
-  }
-  
-  /**
-   * Resolve condition value, handling template references.
-   */
-  private resolveCondition(
-    condition: unknown,
-    context: NodeExecutionContext
-  ): unknown {
-    if (typeof condition === 'string') {
-      // Check if this is a template reference
-      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
-      if (templateMatch) {
-        const path = templateMatch[1].trim();
-        return this.resolveTemplate(path, context);
-      }
-      // Check if it's a literal boolean or other literal
-      if (condition === 'true') return true;
-      if (condition === 'false') return false;
-      return condition;
-    }
-    return condition;
-  }
-  
-  /**
-   * Resolve a template path to get a value from previous outputs or workflow input.
-   */
-  private resolveTemplate(path: string, context: NodeExecutionContext): unknown {
-    const trimmed = path.trim();
-    
-    // Pattern 1: input.key
-    if (trimmed.startsWith('input.')) {
-      const key = trimmed.slice(6);
-      return (context.input as Record<string, unknown>)?.[key];
-    }
-    
-    // Pattern 2: nodes.nodeId or nodes.nodeId.path
-    if (trimmed.startsWith('nodes.')) {
-      const rest = trimmed.slice(6);
-      const segments = rest.split('.');
-      const nodeId = segments[0];
-      
-      // 尝试规范化匹配（hyphen <-> underscore）
-      let nodeOutput = context.previousOutputs.get(nodeId);
-      if (nodeOutput === undefined) {
-        const normalizedUnderscore = nodeId.replace(/-/g, '_');
-        const normalizedHyphen = nodeId.replace(/_/g, '-');
-        if (normalizedUnderscore !== nodeId) {
-          nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-        }
-        if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-          nodeOutput = context.previousOutputs.get(normalizedHyphen);
-        }
-      }
-      if (nodeOutput === undefined) return undefined;
-      
-      // Navigate path
-      let value: unknown = nodeOutput;
-      for (const segment of segments.slice(1)) {
-        if (value && typeof value === 'object') {
-          value = (value as Record<string, unknown>)[segment];
-        } else {
-          return undefined;
-        }
-      }
-      return value;
-    }
-    
-    // Pattern 3: Bare nodeId or nodeId.path
-    const segments = trimmed.split('.');
-    const nodeId = segments[0];
-    
-    // 尝试规范化匹配（hyphen <-> underscore）
-    let nodeOutput = context.previousOutputs.get(nodeId);
-    if (nodeOutput === undefined) {
-      const normalizedUnderscore = nodeId.replace(/-/g, '_');
-      const normalizedHyphen = nodeId.replace(/_/g, '-');
-      if (normalizedUnderscore !== nodeId) {
-        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-      }
-      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-        nodeOutput = context.previousOutputs.get(normalizedHyphen);
-      }
-    }
-    if (nodeOutput === undefined) return undefined;
-    
-    // Navigate path
-    let value: unknown = nodeOutput;
-    for (const segment of segments.slice(1)) {
-      if (value && typeof value === 'object') {
-        value = (value as Record<string, unknown>)[segment];
-      } else {
-        return undefined;
-      }
-    }
-    return value;
-  }
-  
-  /**
-   * Evaluate a resolved condition value.
-   */
-  private evaluateCondition(value: unknown): boolean {
-    if (typeof value === 'boolean') {
-      return value;
-    }
-    if (typeof value === 'string') {
-      return value.toLowerCase() === 'true' || value === '1';
-    }
-    if (typeof value === 'number') {
-      return value !== 0;
-    }
-    if (value === null || value === undefined) {
-      return false;
-    }
-    // For objects, check if it has a 'success' property
-    if (typeof value === 'object') {
-      const obj = value as Record<string, unknown>;
-      if ('success' in obj) {
-        return Boolean(obj.success);
-      }
-      // Non-empty object is truthy
-      return Object.keys(obj).length > 0;
-    }
-    return Boolean(value);
-  }
-}

package/src/env/workflow/nodes/index.ts

@@ -1,9 +0,0 @@
-// Node implementations
-export { ToolNode } from './tool-node';
-export type { ToolRegistry, Tool } from './tool-node';
-
-export { SkillNode } from './skill-node';
-export type { SkillRegistry, Skill } from './skill-node';
-
-export { WorkflowNode } from './workflow-node';
-export type { WorkflowRunner, WorkflowRunResult } from './workflow-node';

package/src/env/workflow/nodes/merge-node.ts

@@ -1,141 +0,0 @@
-/**
- * @fileoverview MergeNode - Workflow merge/join node
- * 
- * A merge node waits for all dependencies to complete and collects their outputs.
- * 
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-
-import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
-
-/**
- * MergeNode collects outputs from all dependent nodes and optionally merges them.
- * 
- * The merge strategy can be:
- * - "collect": Collect all outputs into an array
- * - "first": Return the first completed output
- * - "last": Return the last completed output
- * - "merge": Deep merge all outputs into a single object
- * 
- * Usage in workflow:
- * ```yaml
- * nodes:
- *   - id: final
- *     type: merge
- *     config:
- *       strategy: collect
- *     depends_on:
- *       - log-workflow-complete
- * ```
- */
-export class MergeNode implements Node {
-  readonly type = 'merge';
-  readonly id: string;
-  
-  constructor(
-    private definition: NodeDefinition,
-  ) {
-    this.id = definition.id;
-  }
-  
-  async execute(context: NodeExecutionContext): Promise<NodeExecutionResult> {
-    const startTime = Date.now();
-    
-    try {
-      // Get merge strategy from config (default: collect)
-      const strategy = (this.definition.config?.strategy as string) || 'collect';
-      
-      // Get dependency outputs
-      const deps = this.definition.depends_on || [];
-      const outputs: Record<string, unknown> = {};
-      
-      for (const depId of deps) {
-        // 尝试规范化匹配（hyphen <-> underscore）
-        let output = context.previousOutputs.get(depId);
-        if (output === undefined) {
-          const normalizedUnderscore = depId.replace(/-/g, '_');
-          const normalizedHyphen = depId.replace(/_/g, '-');
-          if (normalizedUnderscore !== depId) {
-            output = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (output === undefined && normalizedHyphen !== depId) {
-            output = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (output !== undefined) {
-          outputs[depId] = output;
-        }
-      }
-      
-      // Apply merge strategy
-      let result: unknown;
-      
-      switch (strategy) {
-        case 'collect':
-          // Return all outputs as a map
-          result = outputs;
-          break;
-          
-        case 'first':
-          // Return the first output
-          const firstKey = Object.keys(outputs)[0];
-          result = firstKey ? outputs[firstKey] : undefined;
-          break;
-          
-        case 'last':
-          // Return the last output
-          const lastKey = Object.keys(outputs).pop();
-          result = lastKey ? outputs[lastKey] : undefined;
-          break;
-          
-        case 'merge':
-          // Deep merge all outputs
-          result = this.deepMerge(Object.values(outputs));
-          break;
-          
-        default:
-          result = outputs;
-      }
-      
-      return {
-        output: {
-          strategy,
-          results: result,
-          count: Object.keys(outputs).length,
-        },
-        error: undefined,
-        durationMs: Date.now() - startTime,
-      };
-    } catch (error) {
-      return {
-        output: undefined,
-        error: error instanceof Error ? error : new Error(String(error)),
-        durationMs: Date.now() - startTime,
-      };
-    }
-  }
-  
-  /**
-   * Deep merge multiple objects into a single object.
-   */
-  private deepMerge(objects: unknown[]): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-    
-    for (const obj of objects) {
-      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
-        for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-          if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key]) &&
-              value && typeof value === 'object' && !Array.isArray(value)) {
-            // Recursively merge nested objects
-            result[key] = this.deepMerge([result[key], value]);
-          } else {
-            result[key] = value;
-          }
-        }
-      }
-    }
-    
-    return result;
-  }
-}

package/src/env/workflow/nodes/skill-node.test.ts

@@ -1,253 +0,0 @@
-import { describe, it, expect, beforeEach, jest } from 'vitest';
-import { SkillNode, SkillRegistry, Skill } from './skill-node';
-import type { NodeDefinition, NodeExecutionContext } from '../types';
-import type { EventBus } from '../engine/event-bus';
-
-// Mock EventBus
-const mockEventBus = {
-  emit: jest.fn(),
-  on: jest.fn(),
-  off: jest.fn(),
-} as Partial<EventBus> as EventBus;
-
-// Mock SkillRegistry
-const mockRegistry = {
-  getSkill: jest.fn<(name: string) => Skill | undefined>(),
-  hasSkill: jest.fn<(name: string) => boolean>(),
-} as {
-  getSkill: ReturnType<typeof jest.fn>;
-  hasSkill: ReturnType<typeof jest.fn>;
-};
-
-// Mock Skill
-const mockSkill = {
-  name: 'test-skill',
-  invoke: jest.fn<(input: any, context: any) => Promise<any>>(),
-};
-
-describe('SkillNode', () => {
-  let skillNode: SkillNode;
-  let nodeDefinition: NodeDefinition;
-  let executionContext: NodeExecutionContext;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    nodeDefinition = {
-      id: 'node-1',
-      type: 'skill',
-      name: 'Test Skill Node',
-      config: {
-        skill: 'test-skill',
-        input: { message: 'hello' },
-      },
-    };
-
-    executionContext = {
-      runId: 'run-1',
-      workflowName: 'test-workflow',
-      nodeId: 'node-1',
-      input: {},
-      previousOutputs: new Map(),
-      config: nodeDefinition.config,
-      debug: false,
-      eventBus: mockEventBus,
-    };
-
-    mockRegistry.getSkill = jest.fn().mockReturnValue(mockSkill);
-    mockRegistry.hasSkill = jest.fn().mockReturnValue(true);
-    mockSkill.invoke = jest.fn().mockResolvedValue({ result: 'success' });
-  });
-
-  describe('constructor', () => {
-    it('should create a SkillNode with correct type', () => {
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      expect(skillNode.type).toBe('skill');
-      expect(skillNode.id).toBe('node-1');
-    });
-  });
-
-  describe('execute', () => {
-    it('should invoke skill successfully', async () => {
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.output).toEqual({ result: 'success' });
-      expect(result.error).toBeUndefined();
-      expect(result.durationMs).toBeGreaterThanOrEqual(0);
-      expect(mockRegistry.getSkill).toHaveBeenCalledWith('test-skill');
-      expect(mockSkill.invoke).toHaveBeenCalled();
-    });
-
-    it('should return error when skill not found', async () => {
-      mockRegistry.getSkill = jest.fn().mockReturnValue(undefined);
-      mockRegistry.hasSkill = jest.fn().mockReturnValue(false);
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.output).toBeUndefined();
-      expect(result.error).toBeDefined();
-      expect(result.error.message).toContain('Skill not found: test-skill');
-    });
-
-    it('should pass input to skill', async () => {
-      const customInput = { param1: 'value1', param2: 123 };
-      nodeDefinition.config.input = customInput;
-      executionContext.config = nodeDefinition.config;
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      await skillNode.execute(executionContext);
-      
-      expect(mockSkill.invoke).toHaveBeenCalledWith(customInput, expect.any(Object));
-    });
-
-    it('should handle skill invocation errors', async () => {
-      const error = new Error('Skill invocation failed');
-      mockSkill.invoke = jest.fn().mockRejectedValue(error);
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.output).toBeUndefined();
-      expect(result.error).toBeDefined();
-      expect(result.error.message).toBe('Skill invocation failed');
-    });
-
-    it('should resolve template references from previous outputs', async () => {
-      // Set up previous outputs
-      executionContext.previousOutputs.set('node-0', {
-        output: { value: 'from-node-0' }
-      });
-      
-      // Input contains template reference
-      nodeDefinition.config.input = {
-        message: '{{node-0.output.value}}',
-      };
-      executionContext.config = nodeDefinition.config;
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.output).toEqual({ result: 'success' });
-      expect(mockSkill.invoke).toHaveBeenCalledWith({
-        message: 'from-node-0',
-      }, expect.any(Object));
-    });
-
-    it('should resolve nested template references', async () => {
-      executionContext.previousOutputs.set('data-node', {
-        nested: {
-          deep: {
-            value: 'nested-value',
-          }
-        }
-      });
-      
-      nodeDefinition.config.input = {
-        message: '{{data-node.nested.deep.value}}',
-      };
-      executionContext.config = nodeDefinition.config;
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      await skillNode.execute(executionContext);
-      
-      expect(mockSkill.invoke).toHaveBeenCalledWith({
-        message: 'nested-value',
-      }, expect.any(Object));
-    });
-
-    it('should handle unresolved template references gracefully', async () => {
-      // Template references non-existent node
-      nodeDefinition.config.input = {
-        message: '{{non-existent.output.value}}',
-      };
-      executionContext.config = nodeDefinition.config;
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      // Should still execute with unresolved template
-      expect(mockSkill.invoke).toHaveBeenCalledWith({
-        message: '{{non-existent.output.value}}',
-      }, expect.any(Object));
-    });
-
-    it('should record execution duration', async () => {
-      mockSkill.invoke = jest.fn().mockImplementation(async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        return { result: 'success' };
-      });
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.durationMs).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should use skill name from config.skill', async () => {
-      nodeDefinition.config.skill = 'custom-skill';
-      executionContext.config = nodeDefinition.config;
-      
-      const customSkill = {
-        name: 'custom-skill',
-        invoke: jest.fn().mockResolvedValue({ custom: true }),
-      };
-      mockRegistry.getSkill = jest.fn().mockReturnValue(customSkill);
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      await skillNode.execute(executionContext);
-      
-      expect(mockRegistry.getSkill).toHaveBeenCalledWith('custom-skill');
-    });
-
-    it('should throw error when skill config is missing', async () => {
-      nodeDefinition.config = {};  // No skill specified
-      executionContext.config = nodeDefinition.config;
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      const result = await skillNode.execute(executionContext);
-      
-      expect(result.error).toBeDefined();
-      expect(result.error.message).toContain('Skill name is required');
-    });
-
-    it('should pass context to skill invoke', async () => {
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      await skillNode.execute(executionContext);
-      
-      // Verify context is passed with relevant info
-      expect(mockSkill.invoke).toHaveBeenCalledWith(
-        { message: 'hello' },
-        expect.objectContaining({
-          runId: 'run-1',
-          workflowName: 'test-workflow',
-          nodeId: 'node-1',
-        })
-      );
-    });
-  });
-
-  describe('SkillRegistry interface', () => {
-    it('should check skill existence with hasSkill', async () => {
-      mockRegistry.hasSkill = jest.fn().mockReturnValue(true);
-      
-      skillNode = new SkillNode(nodeDefinition, mockRegistry);
-      
-      // This is tested implicitly - if hasSkill returns false, 
-      // getSkill should also return undefined
-      expect(mockRegistry.hasSkill('test-skill')).toBe(true);
-    });
-  });
-});