@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/workflow/nodes/skill-node.test.js

@@ -0,0 +1,189 @@
+import { describe, it, expect, beforeEach, jest } from 'vitest';
+import { SkillNode } from "./skill-node.js";
+// Mock EventBus
+const mockEventBus = {
+    emit: jest.fn(),
+    on: jest.fn(),
+    off: jest.fn(),
+};
+// Mock SkillRegistry
+const mockRegistry = {
+    getSkill: jest.fn(),
+    hasSkill: jest.fn(),
+};
+// Mock Skill
+const mockSkill = {
+    name: 'test-skill',
+    invoke: jest.fn(),
+};
+describe('SkillNode', () => {
+    let skillNode;
+    let nodeDefinition;
+    let executionContext;
+    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);
+        });
+    });
+});
+//# sourceMappingURL=skill-node.test.js.map

package/dist/core/src/env/workflow/nodes/tool-node.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Tool Registry interface for looking up tools
+ * Supports both the full ToolRegistration and simplified Tool interface
+ */
+export interface ToolRegistry {
+    getTool?(name: string): ToolRegistration | undefined;
+    getToolByName?(name: string): Tool | undefined;
+    hasTool?(name: string): boolean;
+}
+/**
+ * Tool Registration interface (from ToolComponent)
+ */
+export interface ToolRegistration {
+    tool: Tool;
+    enabled: boolean;
+    source?: string;
+}
+/**
+ * Tool interface for execution
+ */
+export interface Tool {
+    name: string;
+    execute(input: any, context?: any): Promise<any>;
+}
+/**
+ * ToolNode executes a registered Tool with the provided input.
+ *
+ * Input can contain template strings like {{nodeId.output.path}} that will be
+ * resolved from previousOutputs.
+ */
+export declare class ToolNode implements Node {
+    private definition;
+    private toolRegistry;
+    readonly type = "tool";
+    readonly id: string;
+    constructor(definition: NodeDefinition, toolRegistry: ToolRegistry);
+    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
+    /**
+     * Resolve template references in input values.
+     * Templates can be in the format:
+     * - {{input.key}} - from workflow input
+     * - {{nodeId}} - entire previous node output
+     * - {{nodeId.path}} - nested path within previous node output
+     * - {{nodes.nodeId}} - entire previous node output (alias)
+     * - {{nodes.nodeId.path}} - nested path within previous node output
+     * - ${nodeId.output} - dollar-style template (same as {{nodeId.output}})
+     *
+     * Key behavior for template strings:
+     * - If the string is a pure template reference (e.g., "{{nodes.fetch}}"),
+     *   the resolved value is returned as-is (preserving objects/arrays)
+     * - If the string contains text + templates (e.g., "Hello {{name}}"),
+     *   returns a string with interpolated values
+     *
+     * @param input - The input object that may contain template strings
+     * @param previousOutputs - Map of previous node outputs
+     * @param workflowInput - The workflow input parameters
+     * @returns The input with template references resolved
+     */
+    private resolveTemplateReferences;
+    /**
+     * Check if a string is a pure template reference (starts with {{ and ends with }})
+     * @param str - String to check
+     * @returns The template content if pure, null otherwise
+     */
+    private extractPureTemplate;
+    /**
+     * Check if a string is a dollar-style template reference (starts with ${ and ends with })
+     * @param str - String to check
+     * @returns The template content if pure, null otherwise
+     */
+    private extractDollarTemplate;
+    /**
+     * Resolve a pure template reference and return the value as-is.
+     * @param templateContent - Content between {{ and }} or ${ and }
+     * @param previousOutputs - Map of previous node outputs
+     * @param workflowInput - The workflow input parameters
+     * @returns The resolved value (may be object, array, or primitive),
+     *          or the original template string if unresolved
+     */
+    private resolvePureTemplate;
+    /**
+     * Resolve template references in a single string (for mixed text + templates).
+     * Supports formats:
+     * - {{input.key}} - from workflow input
+     * - {{nodeId}} - entire previous node output
+     * - {{nodeId.path}} - nested path within previous node output
+     * - {{nodes.nodeId}} - entire previous node output (alias)
+     * - {{nodes.nodeId.path}} - nested path within previous node output
+     * - ${nodeId.output} - dollar-style template
+     *
+     * Note: Returns string because the input contains text around the template.
+     * For pure template references, use resolvePureTemplate instead.
+     */
+    private resolveStringTemplate;
+    /**
+     * Resolve a value from previous outputs.
+     * @param nodeId - The node ID to look up
+     * @param path - Optional dot-notation path within the node output
+     * @param previousOutputs - Map of previous node outputs
+     */
+    private resolvePath;
+    /**
+     * Get a nested value from an object using dot notation.
+     * @param obj - The object to traverse
+     * @param path - Dot-notation path (e.g., "metadata.task_id")
+     */
+    private getNestedValue;
+    /**
+     * Extract the actual output value from wrapper formats.
+     * For strings, removes trailing whitespace (especially newlines from bash commands).
+     */
+    private extractFromWrapper;
+    /**
+     * Convert a value to string for template interpolation.
+     * @param value - The value to convert
+     * @param fallback - Fallback string if value is undefined
+     */
+    private stringifyValue;
+}
+import type { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
+//# sourceMappingURL=tool-node.d.ts.map