@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

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

@@ -1,415 +0,0 @@
-/**
- * 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

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

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

@@ -1,181 +0,0 @@
-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

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