@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,415 @@
+/**
+ * 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 class ToolNode {
+    definition;
+    toolRegistry;
+    type = 'tool';
+    id;
+    constructor(definition, toolRegistry) {
+        this.definition = definition;
+        this.toolRegistry = toolRegistry;
+        this.id = definition.id;
+    }
+    async execute(context) {
+        const startTime = Date.now();
+        try {
+            // 1. Get tool name from definition.config.tool or config.toolName
+            const toolName = (this.definition.config?.tool ?? this.definition.config?.toolName);
+            if (!toolName) {
+                throw new Error('Tool name is required. Please specify config.tool or config.toolName in the node definition.');
+            }
+            // 2. Look up tool from registry (support both interfaces)
+            let tool;
+            if (this.toolRegistry.getTool) {
+                // getTool may return ToolRegistration or Tool depending on implementation
+                const result = this.toolRegistry.getTool(toolName);
+                if (!result) {
+                    throw new Error(`Tool not found: ${toolName}`);
+                }
+                // Check if result has .tool property (ToolRegistration) or is a Tool directly
+                if ('tool' in result) {
+                    tool = result.tool;
+                }
+                else {
+                    tool = result;
+                }
+            }
+            else if (this.toolRegistry.getToolByName) {
+                // Simplified interface: getToolByName returns Tool directly
+                tool = this.toolRegistry.getToolByName(toolName);
+            }
+            if (!tool) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            // 3. Prepare input (may reference previous outputs and workflow input)
+            // Support multiple formats:
+            // - config.input: { param1: value1, param2: value2 }
+            // - config.args: { param1: value1, param2: value2 } (alias)
+            // - config.command: "string command" (for tools like bash that use command field)
+            // - config.message: "string message" (for tools like echo that use message field)
+            let input;
+            if (this.definition.config?.command !== undefined) {
+                // Special case: single command parameter (e.g., bash tool)
+                // Resolve the command template and pass as { command: resolvedCommand }
+                const commandTemplate = this.definition.config.command;
+                const resolvedCommand = this.resolveTemplateReferences(commandTemplate, context.previousOutputs, context.input);
+                input = { command: resolvedCommand };
+                console.log(`[ToolNode] command input: ${resolvedCommand}`);
+            }
+            else if (this.definition.config?.message !== undefined && Object.keys(this.definition.config).length === 1) {
+                // Special case: single message parameter (e.g., echo tool)
+                // Resolve the message template and pass as { message: resolvedMessage }
+                const messageTemplate = this.definition.config.message;
+                const resolvedMessage = this.resolveTemplateReferences(messageTemplate, context.previousOutputs, context.input);
+                input = { message: resolvedMessage };
+                console.log(`[ToolNode] message input: ${resolvedMessage}`);
+            }
+            else {
+                // Normal case: multiple parameters
+                input = this.definition.config?.input ?? this.definition.config?.args ?? {};
+                input = this.resolveTemplateReferences(input, context.previousOutputs, context.input);
+            }
+            // 4. Execute tool
+            // Try to pass context if the tool supports it, otherwise just pass input
+            let output;
+            try {
+                // First try with context (for tools that expect it)
+                const toolContext = {
+                    session_id: context.sessionId || `workflow_${context.runId}`,
+                    message_id: context.nodeId,
+                    metadata: {
+                        workflowRunId: context.runId,
+                        workflowName: context.workflowName,
+                        nodeId: context.nodeId,
+                    },
+                };
+                // Execute tool with timeout to detect hanging
+                const executePromise = tool.execute(input, toolContext);
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(`Tool ${toolName} execution timeout after 30s`)), 30000);
+                });
+                output = await Promise.race([executePromise, timeoutPromise]);
+            }
+            catch (err) {
+                // If the tool doesn't support context parameter, try without it
+                console.log(`[ToolNode] Tool ${toolName} doesn't support context, retrying without context...`);
+                output = await tool.execute(input);
+            }
+            // 5. Return result
+            return {
+                output,
+                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 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
+     */
+    resolveTemplateReferences(input, previousOutputs, workflowInput) {
+        if (typeof input === 'string') {
+            // Check if this is a pure template reference (no surrounding text)
+            // Support both {{nodeId.output}} and ${nodeId.output} formats
+            const pureTemplate = this.extractPureTemplate(input) || this.extractDollarTemplate(input);
+            if (pureTemplate) {
+                // Pure template reference - resolve and return value as-is (preserve objects/arrays)
+                return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
+            }
+            // Mixed text + templates - return resolved string
+            return this.resolveStringTemplate(input, previousOutputs, workflowInput);
+        }
+        if (Array.isArray(input)) {
+            return input.map(item => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
+        }
+        if (input !== null && typeof input === 'object') {
+            const resolved = {};
+            for (const [key, value] of Object.entries(input)) {
+                resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
+            }
+            return resolved;
+        }
+        // Return primitive values as-is
+        return input;
+    }
+    /**
+     * 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
+     */
+    extractPureTemplate(str) {
+        const trimmed = str.trim();
+        if (trimmed.startsWith('{{') && trimmed.endsWith('}}') && trimmed.length > 4) {
+            // Extract content between {{ and }}
+            const content = trimmed.slice(2, -2).trim();
+            // Check there's no other text (except the template patterns themselves)
+            if (!content.includes('{{') && !content.includes('}}')) {
+                return content;
+            }
+        }
+        return null;
+    }
+    /**
+     * 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
+     */
+    extractDollarTemplate(str) {
+        const trimmed = str.trim();
+        if (trimmed.startsWith('${') && trimmed.endsWith('}') && trimmed.length > 3) {
+            // Extract content between ${ and }
+            const content = trimmed.slice(2, -1).trim();
+            // Check there's no other text (except the template patterns themselves)
+            if (!content.includes('${') && !content.includes('}')) {
+                return content;
+            }
+        }
+        return null;
+    }
+    /**
+     * 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
+     */
+    resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
+        const trimmed = templateContent.trim();
+        const originalTemplate = `{{${templateContent}}}`;
+        // Pattern 1: {{input.key}} or ${input.key}
+        if (trimmed.startsWith('input.')) {
+            const value = this.getNestedValue(workflowInput, trimmed.slice(6));
+            return value !== undefined ? value : originalTemplate;
+        }
+        // Pattern 2: {{nodes.nodeId}} or ${nodes.nodeId}
+        if (trimmed.startsWith('nodes.')) {
+            const path = trimmed.slice(6);
+            const segments = path.split('.');
+            const nodeId = segments[0];
+            const restPath = segments.slice(1).join('.') || undefined;
+            const value = this.resolvePath(nodeId, restPath, previousOutputs);
+            return value !== undefined ? value : originalTemplate;
+        }
+        // Pattern 3: Bare nodeId (backward compatibility) - e.g., "node-1" or "node-1.output.task_id"
+        if (trimmed !== 'input' && trimmed !== 'nodes') {
+            const segments = trimmed.split('.');
+            const nodeId = segments[0];
+            const restPath = segments.slice(1).join('.') || undefined;
+            const value = this.resolvePath(nodeId, restPath, previousOutputs);
+            return value !== undefined ? value : originalTemplate;
+        }
+        return originalTemplate;
+    }
+    /**
+     * 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.
+     */
+    resolveStringTemplate(template, previousOutputs, workflowInput) {
+        let resolved = template;
+        // Pattern 1: {{input.key}} or ${input.key}
+        resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+            const value = this.getNestedValue(workflowInput, path.trim());
+            return this.stringifyValue(value, match);
+        });
+        resolved = resolved.replace(/\$\{input\.([^}]+)\}/g, (match, path) => {
+            const value = this.getNestedValue(workflowInput, path.trim());
+            return this.stringifyValue(value, match);
+        });
+        // Pattern 2: {{nodeId}} or {{nodeId.path}} (bare nodeId without 'nodes.' prefix)
+        resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
+            // Skip if it starts with 'nodes.' (handled by pattern 3) or 'input.' (handled by pattern 1)
+            if (path.trim().startsWith('nodes.') || path.trim().startsWith('input.')) {
+                return match;
+            }
+            // Split into nodeId and optional path
+            const segments = path.trim().split('.');
+            const nodeId = segments[0];
+            const restPath = segments.slice(1).join('.') || undefined;
+            const value = this.resolvePath(nodeId, restPath, previousOutputs);
+            return this.stringifyValue(value, match);
+        });
+        // Pattern 3: ${nodeId.output} - dollar-style template
+        resolved = resolved.replace(/\$\{([^}]+)\}/g, (match, path) => {
+            // Skip if it starts with 'nodes.' or 'input.'
+            if (path.trim().startsWith('nodes.') || path.trim().startsWith('input.')) {
+                return match;
+            }
+            // Split into nodeId and optional path
+            const segments = path.trim().split('.');
+            const nodeId = segments[0];
+            const restPath = segments.slice(1).join('.') || undefined;
+            const value = this.resolvePath(nodeId, restPath, previousOutputs);
+            return this.stringifyValue(value, match);
+        });
+        // Pattern 4: {{nodes.nodeId}} or {{nodes.nodeId.path}}
+        resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+            const segments = path.trim().split('.');
+            const nodeId = segments[0];
+            const restPath = segments.slice(1).join('.') || undefined;
+            // Get raw node output and extract from wrapper format
+            const nodeOutput = this.resolvePath(nodeId, undefined, previousOutputs);
+            let extractedValue = this.extractFromWrapper(nodeOutput);
+            // If extracted value is a string and restPath is "output", the user is trying
+            // to access the output property of a tool result. In this case, the string
+            // itself IS the output, so return it directly.
+            if (typeof extractedValue === 'string' && restPath === 'output') {
+                return this.stringifyValue(extractedValue, match);
+            }
+            if (restPath) {
+                const value = this.getNestedValue(extractedValue, restPath);
+                return this.stringifyValue(value, match);
+            }
+            else {
+                return this.stringifyValue(extractedValue, match);
+            }
+        });
+        return resolved;
+    }
+    /**
+     * 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
+     */
+    resolvePath(nodeId, path, previousOutputs) {
+        // Try exact match first, then try normalized versions (hyphen <-> underscore)
+        let nodeOutput = previousOutputs.get(nodeId);
+        if (nodeOutput === undefined) {
+            const normalizedUnderscore = nodeId.replace(/-/g, '_');
+            const normalizedHyphen = nodeId.replace(/_/g, '-');
+            if (normalizedUnderscore !== nodeId) {
+                nodeOutput = previousOutputs.get(normalizedUnderscore);
+            }
+            if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+                nodeOutput = previousOutputs.get(normalizedHyphen);
+            }
+        }
+        if (nodeOutput === undefined) {
+            return undefined;
+        }
+        if (path === undefined || path === '') {
+            return nodeOutput;
+        }
+        // Navigate through the path
+        return this.getNestedValue(nodeOutput, path);
+    }
+    /**
+     * 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")
+     */
+    getNestedValue(obj, path) {
+        if (obj === null || obj === undefined) {
+            return undefined;
+        }
+        const segments = path.split('.');
+        let current = obj;
+        for (const segment of segments) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[segment];
+        }
+        return current;
+    }
+    /**
+     * Extract the actual output value from wrapper formats.
+     * For strings, removes trailing whitespace (especially newlines from bash commands).
+     */
+    extractFromWrapper(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (typeof value !== 'object') {
+            return value;
+        }
+        let result;
+        if ('output' in value) {
+            result = value.output;
+        }
+        else if ('result' in value && !('output' in value)) {
+            result = value.result;
+        }
+        else {
+            return value;
+        }
+        // For string results from tools (like bash), trim trailing whitespace
+        // This prevents double newlines when embedding in shell commands
+        if (typeof result === 'string') {
+            return result.trimEnd();
+        }
+        return result;
+    }
+    /**
+     * Convert a value to string for template interpolation.
+     * @param value - The value to convert
+     * @param fallback - Fallback string if value is undefined
+     */
+    stringifyValue(value, fallback) {
+        if (value === undefined || value === null) {
+            return fallback;
+        }
+        let str;
+        if (typeof value === 'object') {
+            str = JSON.stringify(value);
+        }
+        else {
+            str = String(value);
+        }
+        // Escape special characters for shell:
+        // - \ \ -> \\\ (for echo to show literal \)
+        // - " -> \"
+        // - ` -> \`
+        // - $ -> \$
+        // - \n -> \\n (for echo to show literal \n, not newline)
+        // - \r -> \\r
+        // - \t -> \\t
+        return str
+            .replace(/\\/g, '\\\\')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t')
+            .replace(/"/g, '\\"')
+            .replace(/`/g, '\\`')
+            .replace(/\$/g, '\\$');
+    }
+}
+//# sourceMappingURL=tool-node.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-node.test.d.ts.map

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

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeEach, jest } from 'vitest';
+import { ToolNode } from "./tool-node.js";
+// Mock EventBus
+const mockEventBus = {
+    emit: jest.fn(),
+    on: jest.fn(),
+    off: jest.fn(),
+};
+// Mock ToolRegistry
+const mockRegistry = {
+    getTool: jest.fn(),
+    hasTool: jest.fn(),
+};
+// Mock Tool
+const mockTool = {
+    name: 'test-tool',
+    execute: jest.fn(),
+};
+describe('ToolNode', () => {
+    let toolNode;
+    let nodeDefinition;
+    let executionContext;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        nodeDefinition = {
+            id: 'node-1',
+            type: 'tool',
+            name: 'Test Tool Node',
+            config: {
+                tool: 'test-tool',
+                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.getTool = jest.fn().mockReturnValue(mockTool);
+        mockRegistry.hasTool = jest.fn().mockReturnValue(true);
+        mockTool.execute = jest.fn().mockResolvedValue({ result: 'success' });
+    });
+    describe('constructor', () => {
+        it('should create a ToolNode with correct type', () => {
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            expect(toolNode.type).toBe('tool');
+            expect(toolNode.id).toBe('node-1');
+        });
+    });
+    describe('execute', () => {
+        it('should execute tool successfully', async () => {
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.output).toEqual({ result: 'success' });
+            expect(result.error).toBeUndefined();
+            expect(result.durationMs).toBeGreaterThanOrEqual(0);
+            expect(mockRegistry.getTool).toHaveBeenCalledWith('test-tool');
+            // Tool is called with (input, context)
+            expect(mockTool.execute).toHaveBeenCalledWith({ message: 'hello' }, expect.objectContaining({
+                session_id: expect.any(String),
+            }));
+        });
+        it('should return error when tool not found', async () => {
+            mockRegistry.getTool = jest.fn().mockReturnValue(undefined);
+            mockRegistry.hasTool = jest.fn().mockReturnValue(false);
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.output).toBeUndefined();
+            expect(result.error).toBeDefined();
+            expect(result.error.message).toContain('Tool not found: test-tool');
+        });
+        it('should pass input to tool', async () => {
+            const customInput = { param1: 'value1', param2: 123 };
+            nodeDefinition.config.input = customInput;
+            executionContext.config = nodeDefinition.config;
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            await toolNode.execute(executionContext);
+            expect(mockTool.execute).toHaveBeenCalledWith(customInput, expect.objectContaining({
+                session_id: expect.any(String),
+            }));
+        });
+        it('should handle tool execution errors', async () => {
+            const error = new Error('Tool execution failed');
+            mockTool.execute = jest.fn().mockRejectedValue(error);
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.output).toBeUndefined();
+            expect(result.error).toBeDefined();
+            expect(result.error.message).toBe('Tool execution failed');
+        });
+        it('should resolve template references from previous outputs', async () => {
+            // Set up previous outputs
+            executionContext.previousOutputs.set('node-0', {
+                value: 'from-node-0'
+            });
+            // Input contains template reference with nodes. prefix
+            nodeDefinition.config.input = {
+                message: '{{nodes.node-0.value}}',
+            };
+            executionContext.config = nodeDefinition.config;
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.output).toEqual({ result: 'success' });
+            expect(mockTool.execute).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: '{{nodes.data-node.nested.deep.value}}',
+            };
+            executionContext.config = nodeDefinition.config;
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            await toolNode.execute(executionContext);
+            expect(mockTool.execute).toHaveBeenCalledWith({ message: 'nested-value' }, expect.objectContaining({
+                session_id: expect.any(String),
+            }));
+        });
+        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;
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            // Should still execute with unresolved template
+            expect(mockTool.execute).toHaveBeenCalledWith({ message: '{{non-existent.output.value}}' }, expect.any(Object));
+        });
+        it('should record execution duration', async () => {
+            mockTool.execute = jest.fn().mockImplementation(async () => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return { result: 'success' };
+            });
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.durationMs).toBeGreaterThanOrEqual(0);
+        });
+        it('should use tool name from config.tool', async () => {
+            nodeDefinition.config.tool = 'custom-tool';
+            executionContext.config = nodeDefinition.config;
+            mockRegistry.getTool = jest.fn().mockReturnValue({
+                name: 'custom-tool',
+                execute: jest.fn().mockResolvedValue({ custom: true }),
+            });
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            await toolNode.execute(executionContext);
+            expect(mockRegistry.getTool).toHaveBeenCalledWith('custom-tool');
+        });
+        it('should throw error when tool config is missing', async () => {
+            nodeDefinition.config = {}; // No tool specified
+            executionContext.config = nodeDefinition.config;
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            const result = await toolNode.execute(executionContext);
+            expect(result.error).toBeDefined();
+            expect(result.error.message).toContain('Tool name is required');
+        });
+    });
+    describe('ToolRegistry interface', () => {
+        it('should check tool existence with hasTool', async () => {
+            mockRegistry.hasTool = jest.fn().mockReturnValue(true);
+            toolNode = new ToolNode(nodeDefinition, mockRegistry);
+            // This is tested implicitly - if hasTool returns false, 
+            // getTool should also return undefined
+            expect(mockRegistry.hasTool('test-tool')).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=tool-node.test.js.map

package/dist/core/src/env/workflow/nodes/workflow-llm-history.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Workflow LLM History Tests
+ *
+ * TDD 测试：验证 workflow 节点之间 LLM history 共享功能
+ */
+export {};
+//# sourceMappingURL=workflow-llm-history.test.d.ts.map